#pragma once

#include "Component.h"
#include "TransformComponent.h"
#include <string>
#include <vector>
#include <memory>
#include <algorithm>
#include <unordered_map>
#include <istream>
#include <ostream>
#include <random>
#include <type_traits>

namespace XCEngine {
namespace Components {

class Scene;

class GameObject {
public:
    using ID = uint64_t;
    static constexpr ID INVALID_ID = 0;

    GameObject();
    explicit GameObject(const std::string& name);
    ~GameObject();

    ID GetID() const { return m_id; }
    uint64_t GetUUID() const { return m_uuid; }
    const std::string& GetName() const { return m_name; }
    void SetName(const std::string& name) { m_name = name; }
    const std::string& GetTag() const { return m_tag; }
    void SetTag(const std::string& tag) { m_tag = tag.empty() ? std::string("Untagged") : tag; }
    bool CompareTag(const std::string& tag) const { return m_tag == tag; }
    uint8_t GetLayer() const { return m_layer; }
    void SetLayer(uint8_t layer) { m_layer = std::min<uint8_t>(layer, 31u); }

    void DetachFromParent();

    Scene* GetScene() const { return m_scene; }

    TransformComponent* GetTransform() { return m_transform; }
    const TransformComponent* GetTransform() const { return m_transform; }

    template<typename T, typename... Args>
    T* AddComponent(Args&&... args) {
        if constexpr (std::is_base_of_v<TransformComponent, T>) {
            return dynamic_cast<T*>(m_transform);
        }

        auto component = std::make_unique<T>(std::forward<Args>(args)...);
        component->m_gameObject = this;
        T* ptr = component.get();
        m_components.emplace_back(std::move(component));
        NotifyComponentAdded(ptr);
        return ptr;
    }

    template<typename T>
    T* GetComponent() {
        if (T* casted = dynamic_cast<T*>(m_transform)) {
            return casted;
        }

        for (auto& comp : m_components) {
            if (T* casted = dynamic_cast<T*>(comp.get())) {
                return casted;
            }
        }
        return nullptr;
    }

    template<typename T>
    const T* GetComponent() const {
        if (const T* casted = dynamic_cast<const T*>(m_transform)) {
            return casted;
        }

        for (auto& comp : m_components) {
            if (T* casted = dynamic_cast<T*>(comp.get())) {
                return casted;
            }
        }
        return nullptr;
    }

    template<typename T>
    std::vector<T*> GetComponents() {
        std::vector<T*> result;
        if (T* casted = dynamic_cast<T*>(m_transform)) {
            result.push_back(casted);
        }
        for (auto& comp : m_components) {
            if (T* casted = dynamic_cast<T*>(comp.get())) {
                result.push_back(casted);
            }
        }
        return result;
    }

    template<typename T>
    std::vector<const T*> GetComponents() const {
        std::vector<const T*> result;
        if (const T* casted = dynamic_cast<const T*>(m_transform)) {
            result.push_back(casted);
        }
        for (auto& comp : m_components) {
            if (const T* casted = dynamic_cast<const T*>(comp.get())) {
                result.push_back(casted);
            }
        }
        return result;
    }

    template<typename T>
    void RemoveComponent() {
        if (dynamic_cast<T*>(m_transform)) {
            return;
        }

        for (auto it = m_components.begin(); it != m_components.end(); ++it) {
            if (T* casted = dynamic_cast<T*>(it->get())) {
                NotifyComponentRemoving(casted);
                m_components.erase(it);
                return;
            }
        }
    }

    bool RemoveComponent(Component* component) {
        if (!component || component == m_transform) {
            return false;
        }

        auto it = std::find_if(m_components.begin(), m_components.end(),
            [component](const std::unique_ptr<Component>& entry) {
                return entry.get() == component;
            });
        if (it == m_components.end()) {
            return false;
        }

        NotifyComponentRemoving(component);
        m_components.erase(it);
        return true;
    }

    template<typename T>
    T* GetComponentInChildren() {
        T* comp = GetComponent<T>();
        if (comp) {
            return comp;
        }
        for (auto* child : m_children) {
            comp = child->GetComponentInChildren<T>();
            if (comp) {
                return comp;
            }
        }
        return nullptr;
    }

    template<typename T>
    T* GetComponentInParent() {
        if (m_parent) {
            T* comp = m_parent->GetComponent<T>();
            if (comp) {
                return comp;
            }
            return m_parent->GetComponentInParent<T>();
        }
        return nullptr;
    }

    template<typename T>
    std::vector<T*> GetComponentsInChildren() {
        std::vector<T*> result;
        std::vector<T*> comps = GetComponents<T>();
        result.insert(result.end(), comps.begin(), comps.end());

        for (auto* child : m_children) {
            std::vector<T*> childComps = child->GetComponentsInChildren<T>();
            result.insert(result.end(), childComps.begin(), childComps.end());
        }
        return result;
    }

    GameObject* GetParent() const { return m_parent; }
    void SetParent(GameObject* parent);
    void SetParent(GameObject* parent, bool worldPositionStays);
    void SetParent(GameObject* parent, size_t siblingIndex, bool worldPositionStays);

    size_t GetChildCount() const { return m_children.size(); }
    GameObject* GetChild(size_t index) const;
    std::vector<GameObject*> GetChildren() const;
    void DetachChildren();

    bool IsActive() const { return m_activeSelf; }
    void SetActive(bool active);
    bool IsActiveInHierarchy() const;

    static GameObject* Find(const std::string& name);
    static std::vector<GameObject*> FindObjectsOfType();
    static std::vector<GameObject*> FindGameObjectsWithTag(const std::string& tag);

    void Awake();
    void Start();
    void Update(float deltaTime);
    void FixedUpdate();
    void LateUpdate(float deltaTime);
    void OnDestroy();

    void Destroy();

    void Serialize(std::ostream& os) const;
    void Deserialize(std::istream& is);

private:
    void NotifyComponentAdded(Component* component);
    void NotifyComponentRemoving(Component* component);
    void NotifyComponentsBecameActive();
    void NotifyComponentsBecameInactive();
    void PropagateActiveInHierarchyChange(bool oldParentActiveInHierarchy, bool newParentActiveInHierarchy);

    ID m_id = INVALID_ID;
    uint64_t m_uuid = 0;
    std::string m_name;
    std::string m_tag = "Untagged";
    bool m_activeSelf = true;
    bool m_started = false;
    uint8_t m_layer = 0;
    
    GameObject* m_parent = nullptr;
    std::vector<GameObject*> m_children;
    
    Scene* m_scene = nullptr;
    TransformComponent* m_transform = nullptr;
    std::vector<std::unique_ptr<Component>> m_components;

    static ID s_nextID;
    static std::unordered_map<ID, GameObject*>& GetGlobalRegistry();

    friend class Scene;
    friend class SceneManager;
};

} // namespace Components
} // namespace XCEngine