#include "LocationEditor.h"
#include "Location.h"
#include "Character.h"
#include "utils/Utils.h"
#include "render/OpenGlExtensions.h"
#include "TextModel.h"
#include "external/nlohmann/json.hpp"
#include <iostream>
#include <filesystem>
#include <fstream>
#include <random>
#include <cmath>
#include <algorithm>

namespace ZL
{
    extern const char* CONST_ZIP_FILE;

    LocationEditor::LocationEditor(Location& location)
        : loc(location)
    {
    }

    void LocationEditor::buildNavMeshes()
    {
        navigationEditorNavMeshes.clear();
        if (!loc.navigation) return;
        const float y = loc.navigation->getFloorY() + 0.02f;
        const Eigen::Vector3f red(1.0f, 0.0f, 0.0f);
        for (const auto& obs : loc.navigation->getObstaclePolygons()) {
            if (obs.polygon.size() < 3) continue;
            VertexRenderStruct mesh;
            mesh.data = CreatePolygonFloor(obs.polygon, y, red);
            mesh.RefreshVBO();
            navigationEditorNavMeshes.push_back(std::move(mesh));
        }
    }

    void LocationEditor::drawNavigation()
    {
        loc.renderer.shaderManager.PushShader("defaultColor");
        loc.renderer.SetMatrix();
        for (const auto& mesh : navigationEditorNavMeshes) {
            loc.renderer.DrawVertexRenderStruct(mesh);
        }
        loc.renderer.shaderManager.PopShader();
        loc.renderer.SetMatrix();
    }

    void LocationEditor::rebuildPointsMesh()
    {
        VertexDataStruct data;
        const Eigen::Vector3f yellow(1.0f, 1.0f, 0.0f);
        const float y = loc.navigation ? loc.navigation->getFloorY() + 0.05f : 0.05f;
        const float s = 0.2f;

        for (const auto& pt : navigationEditorPoints) {
            Eigen::Vector3f v0(pt.x(),     y, pt.z() - s * 1.15f);
            Eigen::Vector3f v1(pt.x() - s, y, pt.z() + s * 0.58f);
            Eigen::Vector3f v2(pt.x() + s, y, pt.z() + s * 0.58f);

            data.PositionData.push_back(v0);
            data.PositionData.push_back(v1);
            data.PositionData.push_back(v2);
            data.ColorData.push_back(yellow);
            data.ColorData.push_back(yellow);
            data.ColorData.push_back(yellow);
        }

        navigationEditorPointsMesh.data = std::move(data);
        navigationEditorPointsMesh.RefreshVBO();
    }

    void LocationEditor::drawPoints()
    {
        if (navigationEditorPoints.empty()) return;
        loc.renderer.shaderManager.PushShader("defaultColor");
        loc.renderer.SetMatrix();
        loc.renderer.DrawVertexRenderStruct(navigationEditorPointsMesh);
        loc.renderer.shaderManager.PopShader();
        loc.renderer.SetMatrix();
    }

    void LocationEditor::handleLeftClick(const Eigen::Vector3f& hit, bool ctrlHeld)
    {
        if (ctrlHeld) {
            const float removeRadius = 1.0f;
            for (auto it = navigationEditorPoints.begin(); it != navigationEditorPoints.end(); ++it) {
                const float dx = it->x() - hit.x();
                const float dz = it->z() - hit.z();
                if (dx * dx + dz * dz <= removeRadius * removeRadius) {
                    navigationEditorPoints.erase(it);
                    rebuildPointsMesh();
                    std::cout << "[NAV_EDITOR] Removed point, " << navigationEditorPoints.size() << " remaining\n";
                    return;
                }
            }
            std::cout << "[NAV_EDITOR] No point found within " << removeRadius << " units of click\n";
        } else {
            navigationEditorPoints.push_back(hit);
            rebuildPointsMesh();
            std::cout << "[NAV_EDITOR] Added point (" << hit.x() << ", " << hit.z()
                      << "), total: " << navigationEditorPoints.size() << "\n";
        }
    }

    void LocationEditor::handleRightClick()
    {
        if (navigationEditorPoints.size() < 3) {
            std::cout << "[NAV_EDITOR] Need at least 3 points to form a polygon (have "
                      << navigationEditorPoints.size() << "); clearing\n";
            navigationEditorPoints.clear();
            rebuildPointsMesh();
            return;
        }

        PathFinder::ObstaclePolygon poly;
        poly.name = "editor_obstacle_" + std::to_string(++navigationEditorObstacleCounter);
        for (const auto& pt : navigationEditorPoints) {
            poly.polygon.emplace_back(pt.x(), pt.z());
        }

        if (loc.navigation) loc.navigation->addObstaclePolygon(poly);
        std::cout << "[NAV_EDITOR] Added obstacle '" << poly.name << "' with "
                  << poly.polygon.size() << " vertices\n";

        {
            const float y = loc.navigation ? loc.navigation->getFloorY() + 0.02f : 0.02f;
            const Eigen::Vector3f red(1.0f, 0.0f, 0.0f);
            VertexRenderStruct mesh;
            mesh.data = CreatePolygonFloor(poly.polygon, y, red);
            mesh.RefreshVBO();
            navigationEditorNavMeshes.push_back(std::move(mesh));
        }

        navigationEditorPoints.clear();
        rebuildPointsMesh();
    }

    void LocationEditor::save()
    {
        std::string baseName;
        for (int i = 1; ; ++i) {
            char buf[32];
            snprintf(buf, sizeof(buf), "saved_mesh%03d", i);
            baseName = buf;
            if (!std::filesystem::exists(baseName + ".json")) break;
        }

        if (!loc.navigation) return;

        if (loc.navigation->saveConfig(baseName + ".json"))
            std::cout << "[NAV_EDITOR] Saved config to: " << baseName << ".json\n";
        else
            std::cerr << "[NAV_EDITOR] Failed to save config to: " << baseName << ".json\n";

        if (loc.navigation->saveGrid(baseName + ".txt"))
            std::cout << "[NAV_EDITOR] Saved grid to: " << baseName << ".txt\n";
        else
            std::cerr << "[NAV_EDITOR] Failed to save grid to: " << baseName << ".txt\n";
    }

    void LocationEditor::reload()
    {
        loc.setupNavigation(loc.navigationMapPaths);
        std::cout << "[NAV_EDITOR] Reloaded navigation maps (" << loc.navigationMapPaths.size() << " maps)\n";
    }

    static VertexDataStruct CreateBoundsBoxMesh(const Eigen::Vector3f corners[8], const Eigen::Vector3f& color)
    {
        VertexDataStruct data;

        auto addTriangle = [&](const Eigen::Vector3f& a, const Eigen::Vector3f& b, const Eigen::Vector3f& c) {
            data.PositionData.push_back(a);
            data.PositionData.push_back(b);
            data.PositionData.push_back(c);
            data.ColorData.push_back(color);
            data.ColorData.push_back(color);
            data.ColorData.push_back(color);
        };

        auto addFace = [&](int a, int b, int c, int d) {
            addTriangle(corners[a], corners[b], corners[c]);
            addTriangle(corners[a], corners[c], corners[d]);
        };

        // corners: 0-3 = bottom ring (y=min), 4-7 = top ring (y=max)
        // 0=(x0,y0,z0) 1=(x1,y0,z0) 2=(x1,y0,z1) 3=(x0,y0,z1)
        // 4=(x0,y1,z0) 5=(x1,y1,z0) 6=(x1,y1,z1) 7=(x0,y1,z1)
        addFace(0, 1, 2, 3); // bottom
        addFace(7, 6, 5, 4); // top
        addFace(0, 4, 5, 1); // front  (z=min)
        addFace(3, 2, 6, 7); // back   (z=max)
        addFace(0, 3, 7, 4); // left   (x=min)
        addFace(1, 5, 6, 2); // right  (x=max)

        return data;
    }

    void LocationEditor::buildInteractiveObjectBoundsMeshes()
    {
        interactiveObjectBoundsMeshes.clear();
        interactionPositionMeshes.clear();

        const Eigen::Vector3f zero = Eigen::Vector3f::Zero();
        const Eigen::Vector3f colorDefault(0.1f, 0.9f, 0.6f);  // teal
        const Eigen::Vector3f colorSelected(1.0f, 1.0f, 0.0f); // yellow
        const Eigen::Vector3f colorPole(1.0f, 0.55f, 0.0f);    // orange

        int idx = 0;
        for (const auto& obj : loc.interactiveObjects) {
            const bool isSelected = (idx == selectedInteractiveObjectIndex);

            // --- bounds box ---
            if (obj.boundsMin != zero || obj.boundsMax != zero) {
                const Eigen::Vector3f& color = isSelected ? colorSelected : colorDefault;

                const float x0 = obj.boundsMin.x(), x1 = obj.boundsMax.x();
                const float y0 = obj.boundsMin.y(), y1 = obj.boundsMax.y();
                const float z0 = obj.boundsMin.z(), z1 = obj.boundsMax.z();

                Eigen::Vector3f corners[8] = {
                    { x0, y0, z0 }, { x1, y0, z0 },
                    { x1, y0, z1 }, { x0, y0, z1 },
                    { x0, y1, z0 }, { x1, y1, z0 },
                    { x1, y1, z1 }, { x0, y1, z1 },
                };

                // Apply the same TRS the draw function applies: scale → rotateY → translate
                if (obj.scale != 1.f) {
                    for (auto& c : corners) c *= obj.scale;
                }
                if (obj.rotationY != 0.f) {
                    const float cosR = std::cos(obj.rotationY);
                    const float sinR = std::sin(obj.rotationY);
                    for (auto& c : corners) {
                        const float nx = c.x() * cosR - c.z() * sinR;
                        const float nz = c.x() * sinR + c.z() * cosR;
                        c.x() = nx;
                        c.z() = nz;
                    }
                }
                for (auto& c : corners) c += obj.position;

                VertexRenderStruct mesh;
                mesh.data = CreateBoundsBoxMesh(corners, color);
                mesh.RefreshVBO();
                interactiveObjectBoundsMeshes.push_back(std::move(mesh));
            }

            // --- interaction position pole ---
            if (obj.hasInteractionPosition) {
                const Eigen::Vector3f& p = obj.interactionPosition;
                static constexpr float hw = 0.05f;  // half width/depth
                static constexpr float hh = 1.5f;   // half height (pole = 3.0 tall)

                Eigen::Vector3f corners[8] = {
                    { p.x()-hw, p.y()-hh, p.z()-hw }, { p.x()+hw, p.y()-hh, p.z()-hw },
                    { p.x()+hw, p.y()-hh, p.z()+hw }, { p.x()-hw, p.y()-hh, p.z()+hw },
                    { p.x()-hw, p.y()+hh, p.z()-hw }, { p.x()+hw, p.y()+hh, p.z()-hw },
                    { p.x()+hw, p.y()+hh, p.z()+hw }, { p.x()-hw, p.y()+hh, p.z()+hw },
                };

                VertexRenderStruct mesh;
                mesh.data = CreateBoundsBoxMesh(corners, colorPole);
                mesh.RefreshVBO();
                interactionPositionMeshes.push_back(std::move(mesh));
            }

            ++idx;
        }
    }

    void LocationEditor::drawInteractiveObjectBounds()
    {
        if (interactiveObjectBoundsMeshes.empty() && interactionPositionMeshes.empty()) return;

        loc.renderer.shaderManager.PushShader("defaultColor");
        loc.renderer.SetMatrix();
        for (const auto& mesh : interactiveObjectBoundsMeshes) {
            loc.renderer.DrawVertexRenderStruct(mesh);
        }
        for (const auto& mesh : interactionPositionMeshes) {
            loc.renderer.DrawVertexRenderStruct(mesh);
        }
        loc.renderer.shaderManager.PopShader();
        loc.renderer.SetMatrix();
    }

    void LocationEditor::selectInteractiveObject(int index)
    {
        if (index < 0 || index >= static_cast<int>(loc.interactiveObjects.size())) {
            std::cout << "[IO_EDITOR] Index " << index << " out of range ("
                      << loc.interactiveObjects.size() << " objects)\n";
            return;
        }
        selectedInteractiveObjectIndex = index;
        boundsClickCount = 0;
        buildInteractiveObjectBoundsMeshes();
        std::cout << "[IO_EDITOR] Selected object " << index
                  << " (" << loc.interactiveObjects[index].loadedObject.name << ")\n";
    }

    void LocationEditor::handleInteractiveObjectClick(const Eigen::Vector3f& worldHit, bool ctrlHeld)
    {
        if (selectedInteractiveObjectIndex < 0 ||
            selectedInteractiveObjectIndex >= static_cast<int>(loc.interactiveObjects.size())) {
            std::cout << "[IO_EDITOR] No valid object selected\n";
            return;
        }

        if (ctrlHeld) {
            // Set the interaction position for the selected object (world XZ, Y=0).
            auto& target = loc.interactiveObjects[selectedInteractiveObjectIndex];
            target.interactionPosition = Eigen::Vector3f(worldHit.x(), 0.f, worldHit.z());
            target.hasInteractionPosition = true;
            boundsClickCount = 0; // cancel any in-progress bounds placement
            buildInteractiveObjectBoundsMeshes();
            std::cout << "[IO_EDITOR] Interaction position set on object " << selectedInteractiveObjectIndex
                      << " (" << target.loadedObject.name << ")"
                      << " at (" << worldHit.x() << ", " << worldHit.z() << ")\n";
            return;
        }

        const auto& obj = loc.interactiveObjects[selectedInteractiveObjectIndex];

        // Convert world-space hit to object local space (inverse of scale → rotateY → translate)
        auto worldToLocal = [&](const Eigen::Vector3f& w) -> Eigen::Vector3f {
            Eigen::Vector3f local = w - obj.position;
            if (obj.rotationY != 0.f) {
                const float c = std::cos(-obj.rotationY);
                const float s = std::sin(-obj.rotationY);
                const float nx = local.x() * c - local.z() * s;
                const float nz = local.x() * s + local.z() * c;
                local.x() = nx;
                local.z() = nz;
            }
            if (obj.scale > 1e-6f && obj.scale != 1.f)
                local /= obj.scale;
            return local;
        };

        if (boundsClickCount == 0) {
            boundsClickA = worldHit;
            boundsClickCount = 1;
            std::cout << "[IO_EDITOR] First corner placed at world ("
                      << worldHit.x() << ", " << worldHit.z() << ") — click again for second corner\n";
        } else {
            const Eigen::Vector3f localA = worldToLocal(boundsClickA);
            const Eigen::Vector3f localB = worldToLocal(worldHit);

            auto& target = loc.interactiveObjects[selectedInteractiveObjectIndex];
            target.boundsMin = Eigen::Vector3f(
                min(localA.x(), localB.x()), 0.f, min(localA.z(), localB.z()));
            target.boundsMax = Eigen::Vector3f(
                max(localA.x(), localB.x()), 1.f, max(localA.z(), localB.z()));

            boundsClickCount = 0;
            buildInteractiveObjectBoundsMeshes();

            std::cout << "[IO_EDITOR] Bounds set on object " << selectedInteractiveObjectIndex
                      << " (" << target.loadedObject.name << ")"
                      << "  min=(" << target.boundsMin.x() << ", " << target.boundsMin.z() << ")"
                      << "  max=(" << target.boundsMax.x() << ", " << target.boundsMax.z() << ")\n";
        }
    }

    void LocationEditor::saveInteractiveObjects()
    {
        std::string baseName;
        for (int i = 1; ; ++i) {
            char buf[32];
            snprintf(buf, sizeof(buf), "saved_interactive%03d", i);
            baseName = buf;
            if (!std::filesystem::exists(baseName + ".json")) break;
        }

        using json = nlohmann::json;
        json j;
        j["objects"] = json::array();

        for (const auto& obj : loc.interactiveObjects) {
            json item;
            item["name"]              = obj.loadedObject.name;
            item["texturePath"]       = obj.loadedObject.texturePath;
            if (!obj.loadedObject.textureDarkandsPath.empty())
                item["textureDarkandsPath"] = obj.loadedObject.textureDarkandsPath;
            item["meshPath"]          = obj.loadedObject.meshPath;
            item["rotationX"]         = obj.loadedObject.meshRotationX;
            item["rotationY"]         = obj.loadedObject.meshRotationY;
            item["rotationZ"]         = obj.loadedObject.meshRotationZ;
            item["positionX"]         = obj.jsonPositionX;
            item["positionY"]         = obj.jsonPositionY;
            item["positionZ"]         = obj.jsonPositionZ;
            item["scale"]             = obj.loadedObject.meshScale;
            item["interactionRadius"] = obj.interactionRadius;
            item["approachRadius"]    = obj.approachRadius;
            if (!obj.activateFunctionName.empty())
                item["activateFunction"] = obj.activateFunctionName;
            item["pivotX"] = obj.pivot.x();
            item["pivotY"] = obj.pivot.y();
            item["pivotZ"] = obj.pivot.z();
            item["boundsMinX"] = obj.boundsMin.x();
            item["boundsMinY"] = obj.boundsMin.y();
            item["boundsMinZ"] = obj.boundsMin.z();
            item["boundsMaxX"] = obj.boundsMax.x();
            item["boundsMaxY"] = obj.boundsMax.y();
            item["boundsMaxZ"] = obj.boundsMax.z();
            if (obj.hasInteractionPosition) {
                item["interactionPositionX"] = obj.interactionPosition.x();
                item["interactionPositionY"] = obj.interactionPosition.y();
                item["interactionPositionZ"] = obj.interactionPosition.z();
            }
            j["objects"].push_back(item);
        }

        const std::string filename = baseName + ".json";
        std::ofstream out(filename);
        if (out.is_open()) {
            out << j.dump(4);
            std::cout << "[IO_EDITOR] Saved " << loc.interactiveObjects.size()
                      << " interactive object(s) to " << filename << "\n";
        } else {
            std::cerr << "[IO_EDITOR] Failed to open " << filename << " for writing\n";
        }
    }

    void LocationEditor::saveAll()
    {
        save();
        saveInteractiveObjects();
    }

    void LocationEditor::placeTree()
    {
        if (!loc.player) return;

        static std::mt19937 rng(std::random_device{}());
        std::uniform_real_distribution<float> scaleDist(0.8f, 1.2f);
        std::uniform_real_distribution<float> rotDist(0.0f, 360.0f);

        GameObjectData data;
        data.name        = "editor_tree_" + std::to_string(++editorPlacedObjectCounter);
        data.texturePath = "resources/w/exterior/tree001.png";
        data.meshPath    = "resources/w/exterior/tree003.txt";
        data.rotationX   = 0.0f;
        data.rotationY   = rotDist(rng);
        data.rotationZ   = 0.0f;
        data.positionX   = loc.player->position.x();
        data.positionY   = loc.player->position.y();
        data.positionZ   = loc.player->position.z();
        data.scale       = scaleDist(rng);

        LoadedGameObject obj = GameObjectLoader::buildLoadedObject(data, loc.renderer, CONST_ZIP_FILE);
        obj.mesh.data.Move({ data.positionX, data.positionY, data.positionZ });
        obj.mesh.RefreshVBO();

        loc.gameObjects[data.name] = std::move(obj);
        editorPlacedObjects.push_back(data);

        std::cout << "[GAME_EDITOR] Placed '" << data.name << "' at ("
                  << data.positionX << ", " << data.positionZ
                  << ") scale=" << data.scale << " rotY=" << data.rotationY << "\n";
    }

    void LocationEditor::saveObjects()
    {
        if (editorPlacedObjects.empty()) {
            std::cout << "[GAME_EDITOR] No editor-placed objects to save\n";
            return;
        }

        std::string baseName;
        for (int i = 1; ; ++i) {
            char buf[32];
            snprintf(buf, sizeof(buf), "saved_objects%03d", i);
            baseName = buf;
            if (!std::filesystem::exists(baseName + ".json")) break;
        }

        using json = nlohmann::json;
        json j;
        j["objects"] = json::array();
        for (const auto& d : editorPlacedObjects) {
            json obj;
            obj["name"]        = d.name;
            obj["texturePath"] = d.texturePath;
            obj["meshPath"]    = d.meshPath;
            obj["rotationX"]   = d.rotationX;
            obj["rotationY"]   = d.rotationY;
            obj["rotationZ"]   = d.rotationZ;
            obj["positionX"]   = d.positionX;
            obj["positionY"]   = d.positionY;
            obj["positionZ"]   = d.positionZ;
            obj["scale"]       = d.scale;
            j["objects"].push_back(obj);
        }

        const std::string filename = baseName + ".json";
        std::ofstream out(filename);
        if (out.is_open()) {
            out << j.dump(4);
            std::cout << "[GAME_EDITOR] Saved " << editorPlacedObjects.size()
                      << " object(s) to " << filename << "\n";
        } else {
            std::cerr << "[GAME_EDITOR] Failed to open " << filename << " for writing\n";
        }
    }

} // namespace ZL