#include <destrum/Scene/SceneManager.h>

#include <algorithm>
#include <iterator>
#include <stdexcept>

#include <destrum/Scene/Scene.h>
#include <destrum/Util/DeltaTime.h>

Scene& SceneManager::GetCurrentScene() const {
    if (m_scenes.empty()) {
        throw std::out_of_range("No scenes are available");
    }

    if (m_ActiveSceneIndex < 0 || m_ActiveSceneIndex >= static_cast<int>(m_scenes.size())) {
        throw std::out_of_range("Active scene index is invalid");
    }

    return *m_scenes[static_cast<std::size_t>(m_ActiveSceneIndex)];
}

void SceneManager::Update(float dt) {
    if (m_scenes.empty()) return;
    (void)GetCurrentScene();
    const auto scene = m_scenes.at(static_cast<std::size_t>(m_ActiveSceneIndex));
    scene->Update(dt);
}

void SceneManager::FixedUpdate(float dt) {
    if (m_scenes.empty()) return;
    (void)GetCurrentScene();
    const auto scene = m_scenes.at(static_cast<std::size_t>(m_ActiveSceneIndex));
    scene->FixedUpdate(dt);
}

void SceneManager::LateUpdate(float dt) {
    if (m_scenes.empty()) return;
    (void)GetCurrentScene();
    const auto scene = m_scenes.at(static_cast<std::size_t>(m_ActiveSceneIndex));
    scene->LateUpdate(dt);
}

void SceneManager::Render(const RenderContext& ctx) {
    if (m_scenes.empty()) return;
    (void)GetCurrentScene();
    const auto scene = m_scenes.at(static_cast<std::size_t>(m_ActiveSceneIndex));
    scene->Render(ctx);
}

void SceneManager::RenderImgui() {
    if (m_scenes.empty()) return;
    (void)GetCurrentScene();
    const auto scene = m_scenes.at(static_cast<std::size_t>(m_ActiveSceneIndex));
    scene->RenderImgui();
}

void SceneManager::HandleGameObjectDestroy() {
    for (const auto& scene : m_scenes) {
        scene->CleanupDestroyedGameObjects();
    }
}

void SceneManager::DestroyGameObjects() {
    for (const auto& scene: m_scenes) {
        scene->DestroyGameObjects();
    }
}

void SceneManager::UnloadAllScenes() {
    for (const auto& scene : m_scenes) {
        scene->Unload();
    }
}

void SceneManager::HandleSceneDestroy() {
    const std::shared_ptr<Scene> activeScene =
        m_ActiveSceneIndex >= 0 &&
        m_ActiveSceneIndex < static_cast<int>(m_scenes.size())
            ? m_scenes[static_cast<std::size_t>(m_ActiveSceneIndex)]
            : nullptr;

    for (auto it = m_scenes.begin(); it != m_scenes.end();) {
        if ((*it)->IsBeingUnloaded()) {
            it = m_scenes.erase(it);
        } else {
            ++it;
        }
    }

    if (m_scenes.empty()) {
        m_ActiveSceneIndex = 0;
        return;
    }

    if (activeScene != nullptr) {
        const auto activeIt = std::find(m_scenes.begin(), m_scenes.end(), activeScene);
        if (activeIt != m_scenes.end()) {
            m_ActiveSceneIndex = static_cast<int>(std::distance(m_scenes.begin(), activeIt));
            return;
        }
    }

    m_ActiveSceneIndex = std::clamp(
        m_ActiveSceneIndex,
        0,
        static_cast<int>(m_scenes.size()) - 1);
}

void SceneManager::HandleScene() {
    HandleGameObjectDestroy();
    HandleSceneDestroy();
}

void SceneManager::Destroy() {
    if (m_scenes.empty()) {
        m_ActiveSceneIndex = 0;
        return;
    }

    UnloadAllScenes();
    DestroyGameObjects();
    HandleGameObjectDestroy();
    HandleSceneDestroy();
}

void SceneManager::SwitchScene(int index) {
    // InputManager::GetInstance().RemoveAllBindings();

    if (index < 0 || index >= static_cast<int>(m_scenes.size())) {
        throw std::out_of_range("Scene index out of range");
    }
    if (index == m_ActiveSceneIndex) {
        return;
    }

    m_scenes[static_cast<std::size_t>(m_ActiveSceneIndex)]->UnloadBindings();
    m_ActiveSceneIndex = index;
    m_scenes[static_cast<std::size_t>(m_ActiveSceneIndex)]->LoadBindings();
}

Scene &SceneManager::CreateScene(const std::string &name) {
    const auto scene = std::shared_ptr<Scene>(new Scene(name));
    m_scenes.push_back(scene);
    if (m_scenes.size() == 1) {
        m_ActiveSceneIndex = 0;
    }
    return *scene;
}