#include "Core/Scene/Base/Scene.h"

class EmptyScene : public Scene
{
public:
    EmptyScene(std::string sceneName);

    static std::shared_ptr<Scene> Create(std::string sceneName);

    void Initialize() override;
};

EmptyScene::EmptyScene(std::string sceneName) : Scene(sceneName)
{
    // 씬별 초기 설정이 필요한 경우 여기에 작성
}

std::shared_ptr<Scene> EmptyScene::Create(std::string sceneName)
{
    activeScene = std::make_shared<EmptyScene>(sceneName);

    return activeScene;
}

void EmptyScene::Initialize()
{
    Scene::Initialize();

    // 씬에 필요한 오브젝트, 카메라, 라이트 등을 여기서 생성 및 설정
    // 예: CreateGameObject("Player");
    //     AddCamera(...);
    //     AddLight(...);
}

// 씬 생성 및 활성화
LoadScene(EmptyScene::Create("MyGameScene"));

class EngineLoop
{
public:
    virtual void Initialize() = 0;      // 초기화 - 씬/오브젝트 생성 직후 1회 실행
    virtual void BeforeFrame() = 0;     // 첫 프레임 시작 전 1회 실행
    virtual void Start() = 0;           // 첫 Update 전 1회 실행
    virtual void LateStart() = 0;       // Start 이후 1회 실행
    virtual void Update(float deltaTime) = 0;      // 매 프레임 실행 (메인 로직)
    virtual void LateUpdate() = 0;      // Update 이후 매 프레임 실행
    virtual void Finalize() = 0;        // 씬 종료 시 정리 작업
    virtual void Destroy() = 0;         // 오브젝트 파괴 시 실행
    
    virtual void OnEnable() = 0;        // 오브젝트/컴포넌트 활성화 시 실행
    virtual void OnDisable() = 0;       // 오브젝트/컴포넌트 비활성화 시 실행
    virtual void Reset() = 0;           // 리셋 요청 시 실행
};

[씬 로드 단계]
1. Scene::Create()          // 씬 인스턴스 생성
2. Scene::Initialize()      // 씬 초기화
   └─> Object::Initialize() (모든 오브젝트)
       └─> Component::Initialize() (활성화된 컴포넌트)
3. Scene::BeforeFrame()     // 첫 프레임 전 준비
   └─> Object::BeforeFrame()
       └─> Component::BeforeFrame()
4. Scene::Start()           // 씬 시작
   └─> Object::Start()
       └─> Component::Start()
5. Scene::LateStart()       // 시작 후처리
   └─> Object::LateStart()
       └─> Component::LateStart()

[게임 루프 시작]
6. Scene::Update(deltaTime)      // 매 프레임 반복
   └─> Object::Update(deltaTime)
       └─> Component::Update(deltaTime)
7. Scene::LateUpdate()           // 매 프레임 반복
   └─> Object::LateUpdate()
       └─> Component::LateUpdate()

[씬 종료 단계]
8. Scene::Finalize()        // 씬 종료 정리
   └─> Object::Finalize()
       └─> Component::Finalize()
9. Scene::Destroy()         // 씬 파괴
   └─> Object::Destroy()
       └─> Component::Destroy()

// 씬 로드 시퀀스
currentScene = SponzaScene::Create("Sponza");
currentScene->Initialize();
currentScene->BeforeFrame();
currentScene->Start();
currentScene->LateStart();

// 게임 루프
while (isRunning)
{
    float deltaTime = CalculateDeltaTime();
    
    currentScene->Update(deltaTime);
    currentScene->LateUpdate();
    
    Render();
}

// 씬 종료
currentScene->Finalize();
currentScene->Destroy();

std::shared_ptr<Object> 변수이름 = AddObject(Object::Create("오브젝트 이름"));

void MyScene::Initialize()
{
    Scene::Initialize();
    
    // 빈 오브젝트 생성 (TransformComponent만 가짐)
    std::shared_ptr<Object> emptyObject = AddObject(Object::Create("Empty GameObject"));
}

void MyScene::Initialize()
{
    Scene::Initialize();
    
    // 플레이어 오브젝트 생성 및 컴포넌트 추가
    std::shared_ptr<Object> player = AddObject(Object::Create("Player"));
    player->AddComponent<Model>("Model/Player.fbx");
    player->AddComponent<PhysicsComponent>();
    player->transform->SetPosition(0.0f, 5.0f, 0.0f);
}

class MyScene : public Scene
{
public:
    void Initialize() override
    {
        Scene::Initialize();
        
        // 플레이어 오브젝트 생성 및 참조 저장
        player = AddObject(Object::Create("Player"));
        player->AddComponent<Model>("Model/Player.fbx");
        
        // 적 오브젝트 생성
        enemy = AddObject(Object::Create("Enemy"));
        enemy->AddComponent<Model>("Model/Enemy.fbx");
    }
};

// 이름으로 오브젝트 검색
std::shared_ptr<Object> player = GetObject("Player");

if (player != nullptr)
{
    // 오브젝트가 존재할 때만 실행
    player->transform->SetPosition(0.0f, 5.0f, 0.0f);
}

// 인덱스로 오브젝트 검색 (0부터 시작)
std::shared_ptr<Object> firstObject = GetObject(0);

// 모든 오브젝트 순회
std::vector<std::shared_ptr<Object>> allObjects = GetObjects();

for (auto& obj : allObjects)
    std::cout << "Object Name: " << obj->GetName() << std::endl;

// 특정 이름의 오브젝트가 씬에 있는지 확인
if (HasObject("Enemy"))
{
    // Enemy 오브젝트가 존재하는 경우
    auto enemy = GetObject("Enemy");
    // ...
}

// 이름으로 제거
std::shared_ptr<Object> removed = RemoveObject("Enemy");

// 인덱스로 제거
std::shared_ptr<Object> removed = RemoveObject(0);

// 제거된 오브젝트는 더 이상 씬의 업데이트 루프에서 호출되지 않음

// 오브젝트 비활성화 (업데이트 루프에서 제외됨)
myObject->SetActive(false);

// 오브젝트 활성화
myObject->SetActive(true);

// 활성화 상태 확인
bool isActive = myObject->GetActive();

// 기본 문법
std::shared_ptr<컴포넌트클래스> 변수이름 = 오브젝트->AddComponent<컴포넌트클래스>();

// 예제: Model 컴포넌트 추가
std::shared_ptr<Model> modelComponent = player->AddComponent<Model>("Model/Player.fbx", 2.0f);

// 예제: PhysicsComponent 추가
auto physics = box->AddComponent<PhysicsComponent>(10.0f, true);
physics->SetMaterial(0.6f, 0.4f, 0.5f);

// TransformComponent 가져오기
auto transform = player->GetComponent<TransformComponent>();
transform->SetPosition(0.0f, 5.0f, 0.0f);

// 컴포넌트 존재 확인 후 사용
auto model = enemy->GetComponent<Model>();
if (model != nullptr)
{
    model->Submit(RenderingChannel::main);
}

// transform은 모든 오브젝트가 기본으로 가지므로 직접 접근 가능
player->transform->SetRotationFromEuler(0.0f, Math::PI, 0.0f);

// 위치 설정
player->transform->SetPosition(0.0f, 5.0f, 10.0f);

// 회전 설정 (오일러 각도, 라디안)
player->transform->SetRotationFromEuler(0.0f, Math::PI / 2.0f, 0.0f);

// 크기 설정
player->transform->SetScale(2.0f, 2.0f, 2.0f);

// 방향 벡터 가져오기
Vector3 forward = player->transform->GetForward();
Vector3 right = player->transform->GetRight();

// 부모-자식 관계 설정
child->transform->SetParent(parent->transform);

// 카메라 생성 및 등록
std::shared_ptr<Object> camera = AddObject(Object::Create("Main Camera"));
cameras.AddCamera(camera->AddComponent<Camera>());

// 카메라 위치 및 회전 설정
camera->transform->SetPosition(-22.0f, 4.0f, 0.0f);
camera->transform->SetRotationFromEuler(0.0f, Math::PI / 2.0f, 0.0f);

// 활성 카메라 전환
cameras.SetActiveCamera(0);

// 모델 로드 (기본 스케일 1.0)
player->AddComponent<Model>("Model/Character.fbx");

// 모델 로드 (스케일 2배)
enemy->AddComponent<Model>("Model/Enemy.obj", 2.0f);

// 모델 로드 (스케일 0.05배 축소)
building->AddComponent<Model>("Model/Building.gltf", 0.05f);

// 동적 객체 (질량 10kg)
auto physics = box->AddComponent<PhysicsComponent>(10.0f, true);

// 물리 재질 설정 (정적마찰, 동적마찰, 반발계수)
physics->SetMaterial(0.6f, 0.4f, 0.5f);

// 중력 설정
physics->SetGravity(true);

// 힘 적용
physics->AddForce(physx::PxVec3(100.0f, 0.0f, 0.0f));

// 제약 조건 설정 (X, Z축 위치 고정)
physics->SetPositionConstraint(true, false, true);

// 큐브 생성
std::shared_ptr<Object> cube = AddObject(Object::Create("Cube"));
auto cubeComp = cube->AddComponent<ColorCubeObject>();
cubeComp->SetColor(GraphicResource::Image::Color(255, 0, 0));  // 빨강
cubeComp->SetLit(true);  // 라이팅 적용

// 구 생성
std::shared_ptr<Object> sphere = AddObject(Object::Create("Sphere"));
sphere->AddComponent<ColorSphereObject>();

// 템플릿 방식
if (player->HasComponent<Model>())
{
    auto model = player->GetComponent<Model>();
    // 모델 관련 작업
}

// 문자열 방식
if (player->HasComponent("PhysicsComponent"))
{
    // 물리 관련 작업
}

// 컴포넌트 비활성화
auto model = player->GetComponent<Model>();
model->SetEnable(false);  // 렌더링 중지

// 컴포넌트 활성화
model->SetEnable(true);   // 렌더링 재개

// 활성화 상태 확인
bool isActive = model->GetEnable();

// 컴포넌트 제거 (클래스 이름 사용)
player->RemoveComponent("Model");
player->RemoveComponent("PhysicsComponent");

// TransformComponent는 제거할 수 없음 (필수 컴포넌트)

// 모든 컴포넌트 순회
std::vector<std::shared_ptr<Component>> allComponents = player->GetAllComponents();

for (auto& component : allComponents)
{
    std::cout << "Component: " << component->GetClassName() << std::endl;
}

// App.cpp의 KeyBoardInput() 메소드 예시
void App::KeyBoardInput()
{
    KeyBoard& keyBoard = GetKeyBoard();

    // ESC 키를 누르면 커서 표시 토글
    if (keyBoard.IsPressed(VK_ESCAPE))
        GetWindow().ToggleCursorShow();

    // F1 키를 누르면 ImGui 데모 표시
    if (keyBoard.IsPressed(VK_F1))
        GetWindow().ToggleImGuiDemoShow();

    // R 키를 누르면 첫 번째 씬으로 전환
    if (keyBoard.IsPressed('R'))
        GetWindow().ChangeActiveScene("ShadowMapTest");

    // T 키를 누르면 두 번째 씬으로 전환
    if (keyBoard.IsPressed('T'))
        GetWindow().ChangeActiveScene("NormalOffsetTest");

    // 이벤트 큐에서 모든 키보드 이벤트를 처리
    while (auto keyEvent = keyBoard.ReadKey())
    {
        if (keyEvent->GetType() == KeyBoard::Event::Type::Press)
        {
            unsigned char keyCode = keyEvent->GetCode();
            // 키 Press 이벤트 처리
        }
        else if (keyEvent->GetType() == KeyBoard::Event::Type::Release)
        {
            unsigned char keyCode = keyEvent->GetCode();
            // 키 Release 이벤트 처리
        }
    }
}

// 마우스 위치 확인
Mouse& mouse = GetMouse();
std::pair<int, int> pos = mouse.GetPos();  // [x, y]

// 마우스 버튼 상태 확인
if (mouse.LeftIsPressed())
{
    // 왼쪽 버튼이 누려있을 때의 처리
}

if (mouse.RightIsPressed())
{
    // 오른쪽 버튼이 누려있을 때의 처리
}

// 마우스 이벤트 처리
while (auto mouseEvent = mouse.Read())
{
    switch (mouseEvent->GetType())
    {
    case Mouse::Event::Type::LPress:
        // 왼쪽 버튼 클릭 처리
        break;
    case Mouse::Event::Type::Move:
        std::pair<int, int> pos = mouseEvent->GetPos();
        // 마우스 이동 처리
        break;
    case Mouse::Event::Type::WheelUp:
        // 휠 업 처리 (예: 줌 인)
        break;
    case Mouse::Event::Type::WheelDown:
        // 휠 다운 처리 (예: 줌 아웃)
        break;
    }
}

// FPS 카메라를 위한 Raw 입력 사용
mouse.EnableRaw();
while (auto delta = mouse.ReadRawDelta())
{
    auto d = *delta;
    // 마우스 델타 값으로 카메라 회전 처리
    camera.Rotate(d.first * sensitivity, d.second * sensitivity);
}

while (auto event = keyboard.ReadKey()) 
{ 
    // 이벤트 처리 
}

if (keyboard.IsPressed('W')) 
{ 
    // 이동 처리 
}

// 연속 이동
if (keyboard.IsPressed('W')) MoveForward();

// 단발성 점프
while (auto event = keyboard.ReadKey())
{
    if (event->GetType() == KeyBoard::Event::Type::Press && 
        event->GetCode() == VK_SPACE)
        Jump();
}

class CameraViewFrustumCulling
{
private:
    enum Plane { Near, Far, Left, Right, Top, Bottom, Count };
    DirectX::XMFLOAT4 frustumPlanes[Plane::Count];  // 6개의 평면 방정식
    DirectX::XMMATRIX viewProjection;
};

void CameraViewFrustumCulling::UpdateFromViewProjection(const XMMATRIX& viewProjection)
{
    XMMATRIX viewProjT = XMMatrixTranspose(viewProjection);
    
    // 행렬을 행별로 분해
    rowX = viewProjT.r[0];
    rowY = viewProjT.r[1];
    rowZ = viewProjT.r[2];
    rowW = viewProjT.r[3];

    // Gribb-Hartmann 방법으로 평면 추출
    frustumPlanes[Left]   = Normalize(rowW + rowX);
    frustumPlanes[Right]  = Normalize(rowW - rowX);
    frustumPlanes[Bottom] = Normalize(rowW + rowY);
    frustumPlanes[Top]    = Normalize(rowW - rowY);
    frustumPlanes[Near]   = Normalize(rowW + rowZ);
    frustumPlanes[Far]    = Normalize(rowW - rowZ);
}

bool CameraViewFrustumCulling::CheckSphere(const XMFLOAT3& center, float radius) const
{
    for (int i = 0; i < Plane::Count; i++)
    {
        // 점과 평면 사이의 거리 계산
        float distance = frustumPlanes[i].x * center.x +
                        frustumPlanes[i].y * center.y +
                        frustumPlanes[i].z * center.z +
                        frustumPlanes[i].w;

        // 구의 중심이 평면으로부터 반지름보다 멀면 외부
        if (distance < -radius)
            return false;
    }
    return true;  // 모든 평면 테스트 통과 → 내부 또는 교차
}

bool CameraViewFrustumCulling::CheckBox(const XMFLOAT3& center, const XMFLOAT3& extents) const
{
    for (int i = 0; i < Plane::Count; i++)
    {
        XMVECTOR plane = XMLoadFloat4(&frustumPlanes[i]);
        XMVECTOR centerVec = XMLoadFloat3(¢er);
        
        float nx = frustumPlanes[i].x;
        float ny = frustumPlanes[i].y;
        float nz = frustumPlanes[i].z;

        // 평면 법선 방향으로 가장 먼 꼭지점까지의 거리
        float ex = extents.x * fabs(nx) + 
                   extents.y * fabs(ny) + 
                   extents.z * fabs(nz);

        // 중심에서 평면까지의 거리
        float distance = XMVectorGetX(XMPlaneDotCoord(plane, centerVec));

        // 가장 먼 꼭지점도 평면 바깥이면 외부
        if (distance < -ex)
            return false;
    }
    return true;  // 모든 평면 테스트 통과 → 내부 또는 교차
}

class Object : public EngineLoop
{
protected:
    // 컴포넌트 이름을 키로, 컴포넌트 포인터를 값으로 저장
    std::unordered_map<std::string, std::shared_ptr<Component>> components;

public:
    // O(1) 컴포넌트 검색
    template <ComponentChild ComponentClass>
    std::shared_ptr<ComponentClass> GetComponent()
    {
        for (auto& component : components)
        {
            if (component.second->GetClassName() == ComponentClass::GetStaticClassName())
                return std::dynamic_pointer_cast<ComponentClass>(component.second);
        }
        return nullptr;
    }
    
    // 문자열 키로 직접 접근 (가장 빠름)
    const std::shared_ptr<Component> GetComponent(std::string componentName)
    {
        if (components.find(componentName) == components.end())
            return nullptr;
        return components[componentName];
    }
};

// Component를 상속받은 클래스만 허용하는 Concept
template<typename T>
concept ComponentChild = std::is_base_of_v<Component, T>;

// Concept를 사용한 타입 안전 메서드
template <ComponentChild ComponentClass>
std::shared_ptr<ComponentClass> GetComponent() { /* ... */ }

template <ComponentChild ComponentClass, typename... Args>
std::shared_ptr<ComponentClass> AddComponent(Args&&... args) { /* ... */ }

template <ComponentChild ComponentClass, typename... Args>
std::shared_ptr<ComponentClass> AddComponent(Args&&... args)
{
    // 중복 확인
    std::string componentName = ComponentClass::GetStaticClassName();
    if (components.find(componentName) != components.end())
        return std::dynamic_pointer_cast<ComponentClass>(components[componentName]);

    // Perfect Forwarding으로 인자 전달 (복사 없음)
    auto component = std::make_shared<ComponentClass>(
        shared_from_this(), 
        std::forward<Args>(args)...
    );

    component->SetObject(shared_from_this());
    component->transform = this->transform;
    
    components[component->GetClassName()] = component;
    return component;
}

class Object : public std::enable_shared_from_this<Object>
{
public:
    // Factory Method로 생성 강제
    static std::shared_ptr<Object> Create(std::string name)
    {
        std::shared_ptr<Object> newObject = std::make_shared<Object>(name);
        
        // TransformComponent 자동 생성
        auto transformComponent = std::make_shared<TransformComponent>(newObject);
        newObject->components[transformComponent->GetClassName()] = transformComponent;
        transformComponent->SetObject(newObject);
        newObject->transform = transformComponent;
        transformComponent->transform = transformComponent;

        return newObject;
    }
};

Image Image::FromFile(const std::string& name)
{
    std::wstring tempDDSFolder = L"Temp/TextureCache/";
    std::wstring tempDDSPath = tempDDSFolder + fileName + L".dds";
    
    DirectX::ScratchImage scratch;
    HRESULT hr;
    
    // 캐시 폴더 생성
    if (!std::filesystem::exists(tempDDSFolder))
        std::filesystem::create_directories(tempDDSFolder);
    else
        hr = LoadTempDDSTexture(tempDDSPath, scratch);  // 캐시 로드
    
    // 캐시 미존재 시 원본 로드 후 DDS 저장
    if (FAILED(hr))
    {
        hr = DirectX::LoadFromWICFile(name.c_str(), ...);
        
        if (SUCCEEDED(hr))
            SaveToDDSFile(..., tempDDSPath.c_str());  // 캐시 저장
    }
    
    return Image(scratch);
}

Image Image::FromFile(const std::string& name)
{
    std::wstring tempDDSFolder = L"Temp/TextureCache/";
    std::wstring tempDDSPath = tempDDSFolder + StringConverter::GetFileName(name) + L".dds";

    DirectX::ScratchImage scratch;
    HRESULT hr;

    // 캐시 폴더 생성
    if (!std::filesystem::exists(tempDDSFolder))
    {
        std::filesystem::create_directories(tempDDSFolder);
        hr = S_FALSE; // 캐시 없음
    }
    else
        hr = LoadTempDDSTexture(tempDDSPath, scratch); // 메모리 매핑으로 DDS 로드 시도

    // 캐시 미존재 또는 로드 실패 시 원본 로드 후 DDS 저장
    if (FAILED(hr))
    {
        hr = DirectX::LoadFromWICFile(StringConverter::ToWide(name).c_str(), DirectX::WIC_FLAGS_IGNORE_SRGB, nullptr, scratch);

        if (SUCCEEDED(hr))
            SaveToDDSFile(scratch.GetImages(), scratch.GetImageCount(), scratch.GetMetadata(), DDS_FLAGS_NONE, tempDDSPath.c_str());
    }

    return Image(std::move(scratch));
}

// ExceptionInfo.h - 고정 버퍼 구조
class ExceptionInfo
{
private:
    char message[100][128];  // 고정 크기 버퍼
    UINT messageCount = 0;

public:
    const char* GetMessages()
    {
        messageCount = 0;
        // IDXGIInfoQueue에서 메시지 수집 후 버퍼에 복사
        // strncpy_s(message[messageCount++], msg, sizeof(message[0])-1);
        return reinterpret_cast<const char*>(message);
    }
};

// GraphicsException.h - 매크로 정의 (변경 후)
#ifndef NDEBUG
    // 오류 검출 시 GetMessages() 호출하여 예외 생성
    #define GRAPHIC_EXCEPT(hr) DxGraphic::HRException{ __LINE__, __FILE__, (hr), infoManager.GetMessages() }
    
    // 디버그 정보만 있는 경우 처리
    #define GRAPHIC_THROW_INFO_ONLY(hr) \
        infoManager.Set(); (hr); { \
            auto v = infoManager.GetMessages(); \
            if(v[0] != '\0') { \
                throw DxGraphic::InfoException{ __LINE__, __FILE__, v }; \
            } \
        }
#else
    #define GRAPHIC_EXCEPT(hr) DxGraphic::HRException(__LINE__, __FILE__, (hr))
#endif