#ifndef TDGAME_TOWER_HPP
#define TDGAME_TOWER_HPP

#include "../grid/mesh.hpp"
#include "enemy.hpp"
#include "customjson.hpp"
#include <string>
#include <vector>
#include <map>
#include <memory>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <limits>

namespace fs = std::filesystem;

// Forward declaration
class Tower;

enum class TargetingPriority {
    FIRST,     // Enemy furthest along the path
    LAST,      // Enemy least far along the path
    CLOSEST,   // Enemy closest to the tower
    STRONGEST, // Enemy with the highest max HP
    WEAKEST    // Enemy with the lowest current HP
};

// Represents a single upgrade level for a tower
struct TowerUpgrade {
    int cost = 50;
    float rangeBonus = 1.0f;
    float damageBonus = 5.0f;
    float fireRateBonus = 0.2f;
};

// Holds the prototype data for a type of tower, loaded from JSON.
struct TowerPrototype {
    std::string typeId;
    std::string name;
    std::shared_ptr<Mesh> mesh;

    int baseCost = 100;
    float baseRange = 10.0f;
    float baseDamage = 10.0f;
    float baseFireRate = 1.0f; // shots per second

    TargetingPriority targetingPriority = TargetingPriority::FIRST;
    std::string projectileTypeId; // For a future projectile system
    std::vector<TowerUpgrade> upgrades;
};

// Represents a single active tower instance in the game.
class Tower {
private:
    int _level = 1;
    float _fireCooldown = 0.0f;
    Enemy* _target = nullptr; // Raw pointer to the target, validated each frame

public:
    int instanceId;
    std::string typeId;
    std::shared_ptr<Mesh> mesh;
    Vector3f position;

    // Current stats (including upgrades)
    float range;
    float damage;
    float fireRate;
    int cost;

    TargetingPriority targetingPriority;

    Tower(int instId, const TowerPrototype& proto, const Vector3f& pos)
        : instanceId(instId),
          typeId(proto.typeId),
          position(pos),
          range(proto.baseRange),
          damage(proto.baseDamage),
          fireRate(proto.baseFireRate),
          cost(proto.baseCost),
          targetingPriority(proto.targetingPriority)
    {
        if (proto.mesh) {
            mesh = std::make_shared<Mesh>(*proto.mesh); // Deep copy for individual manipulation
            mesh->setSubId(instId);
            mesh->translate(position);
        }
    }

    // Main logic loop for targeting and firing
    void update(float deltaTime, const std::vector<std::unique_ptr<Enemy>>& enemies) {
        _fireCooldown -= deltaTime;

        bool targetIsValid = false;
        if (_target != nullptr) {
            if (_target->isAlive() && (_target->position - position).norm() <= range) {
                targetIsValid = true;
            }
        }

        if (!targetIsValid) {
            _target = nullptr;
            findTarget(enemies);
        }

        if (_target != nullptr && _fireCooldown <= 0.0f) {
            // "Fire" at the target. A real implementation would create a projectile.
            _target->takeDamage(damage);

            // Reset cooldown
            _fireCooldown = 1.0f / fireRate;
        }
    }

    // Finds a new target based on the tower's targeting priority
    void findTarget(const std::vector<std::unique_ptr<Enemy>>& enemies) {
        _target = nullptr;
        Enemy* bestTarget = nullptr;
        float bestMetric = -1.0f; // For FIRST, STRONGEST (higher is better)
        
        if (targetingPriority == TargetingPriority::CLOSEST || targetingPriority == TargetingPriority::WEAKEST || targetingPriority == TargetingPriority::LAST) {
            bestMetric = std::numeric_limits<float>::max(); // For priorities where lower is better
        }

        for (const auto& enemyPtr : enemies) {
            if (!enemyPtr->isAlive()) continue;

            float distance = (enemyPtr->position - this->position).norm();
            if (distance > this->range) continue;

            switch (targetingPriority) {
                case TargetingPriority::FIRST:
                    if (distance < (bestMetric == -1.0f ? std::numeric_limits<float>::max() : bestMetric)) {
                        bestMetric = distance;
                        bestTarget = enemyPtr.get();
                    }
                    break;
                case TargetingPriority::LAST:
                     if (distance < bestMetric) {
                        bestMetric = distance;
                        bestTarget = enemyPtr.get();
                    }
                    break;
                case TargetingPriority::CLOSEST:
                    if (distance < bestMetric) {
                        bestMetric = distance;
                        bestTarget = enemyPtr.get();
                    }
                    break;
                case TargetingPriority::STRONGEST:
                    if (enemyPtr->maxHp > bestMetric) {
                        bestMetric = enemyPtr->maxHp;
                        bestTarget = enemyPtr.get();
                    }
                    break;
                case TargetingPriority::WEAKEST:
                    if (enemyPtr->hp < bestMetric) {
                        bestMetric = enemyPtr->hp;
                        bestTarget = enemyPtr.get();
                    }
                    break;
            }
        }
        _target = bestTarget;
    }
    
    // Applies the next available upgrade from the prototype
    bool upgrade(const TowerPrototype& proto) {
        // Upgrades are 0-indexed for level 2, 3, etc.
        // For level 'L', we need upgrade at index 'L-1'.
        if (_level - 1 < proto.upgrades.size()) {
            const auto& up = proto.upgrades[_level - 1];
            
            this->cost += up.cost;
            this->range += up.rangeBonus;
            this->damage += up.damageBonus;
            this->fireRate += up.fireRateBonus;
            _level++;
            return true;
        }
        return false; // Max level reached
    }

    int getLevel() const { return _level; }
    int getSellPrice() const { return static_cast<int>(cost * 0.75f); }
    const Enemy* getTarget() const { return _target; }
};


// Manages storage and retrieval of tower types from JSON definitions.
class TowerRegistry {
private:
    std::map<std::string, TowerPrototype> _prototypes;
    int _nextInstanceId = 0;

    TowerRegistry() = default;

    template<typename T>
    T get_value(const std::map<std::string, customJson::Node>& obj, const std::string& key, T default_val) {
        if (!obj.count(key) || obj.at(key).is_null()) return default_val;
        const auto& node = obj.at(key);
        if constexpr (std::is_same_v<T, bool>) return node.as_bool();
        if constexpr (std::is_same_v<T, double> || std::is_same_v<T, float> || std::is_same_v<T, int>) return static_cast<T>(node.as_double());
        if constexpr (std::is_same_v<T, std::string>) return node.as_string();
        return default_val;
    };

    void parseTowerJson(const std::map<std::string, customJson::Node>& j) {
        TowerPrototype p;
        p.typeId = get_value(j, "id", std::string("unknown"));
        p.name = get_value(j, "name", std::string("Unnamed Tower"));
        p.baseCost = get_value<int>(j, "cost", 100);
        p.baseRange = get_value<float>(j, "range", 10.0f);
        p.baseDamage = get_value<float>(j, "damage", 10.0f);
        p.baseFireRate = get_value<float>(j, "fire_rate", 1.0f);
        p.projectileTypeId = get_value(j, "projectile_id", std::string(""));

        std::string priorityStr = get_value(j, "targeting", std::string("first"));
        if (priorityStr == "last") p.targetingPriority = TargetingPriority::LAST;
        else if (priorityStr == "closest") p.targetingPriority = TargetingPriority::CLOSEST;
        else if (priorityStr == "strongest") p.targetingPriority = TargetingPriority::STRONGEST;
        else if (priorityStr == "weakest") p.targetingPriority = TargetingPriority::WEAKEST;
        else p.targetingPriority = TargetingPriority::FIRST;
        
        if (j.count("upgrades") && !j.at("upgrades").is_null()) {
            for (const auto& up_node : j.at("upgrades").as_array()) {
                const auto& up_obj = up_node.as_object();
                TowerUpgrade up;
                up.cost = get_value<int>(up_obj, "cost", 50);
                up.rangeBonus = get_value<float>(up_obj, "range_bonus", 1.0f);
                up.damageBonus = get_value<float>(up_obj, "damage_bonus", 5.0f);
                up.fireRateBonus = get_value<float>(up_obj, "fire_rate_bonus", 0.2f);
                p.upgrades.push_back(up);
            }
        }
        
        std::string mesh_path = get_value(j, "mesh_path", std::string(""));
        if (!mesh_path.empty()) {
            p.mesh = std::make_shared<Mesh>(0, std::vector<Vector3f>{}, std::vector<std::vector<int>>{}, std::vector<Color>{});
            if (!p.mesh->load(mesh_path)) {
                std::cerr << "Warning: Failed to load mesh '" << mesh_path << "' for tower '" << p.typeId << "'." << std::endl;
                p.mesh = nullptr;
            }
        }

        if (_prototypes.count(p.typeId)) {
            std::cerr << "Warning: Duplicate tower ID '" << p.typeId << "' found. Overwriting." << std::endl;
        }
        _prototypes[p.typeId] = p;
    }
    
    void loadTowerFile(const std::string& filepath) {
        std::ifstream f(filepath);
        if (!f.is_open()) return;
        
        std::stringstream buffer;
        buffer << f.rdbuf();
        
        try {
            customJson::Node root = customJson::parse(buffer.str());
            if (const auto* arr = std::get_if<std::vector<customJson::Node>>(&root.value)) {
                for (const auto& item : *arr) {
                    parseTowerJson(item.as_object());
                }
            } else if (const auto* obj = std::get_if<std::map<std::string, customJson::Node>>(&root.value)) {
                parseTowerJson(*obj);
            }
        } catch (const std::exception& e) {
            std::cerr << "JSON Parse error in " << filepath << ": " << e.what() << std::endl;
        }
    }

public:
    static TowerRegistry& getInstance() {
        static TowerRegistry instance;
        return instance;
    }

    TowerRegistry(const TowerRegistry&) = delete;
    void operator=(const TowerRegistry&) = delete;

    void loadFromDirectory(const std::string& path) {
        if (!fs::exists(path)) {
            std::cerr << "TowerRegistry: Directory " << path << " does not exist." << std::endl;
            return;
        }
        for (const auto& entry : fs::directory_iterator(path)) {
            if (entry.path().extension() == ".json") {
                loadTowerFile(entry.path().string());
            }
        }
        std::cout << "TowerRegistry: Loaded " << _prototypes.size() << " tower definitions." << std::endl;
    }

    std::unique_ptr<Tower> createTower(const std::string& typeId, const Vector3f& position) {
        if (_prototypes.count(typeId) == 0) {
            std::cerr << "Error: Attempted to create unknown tower type: " << typeId << std::endl;
            return nullptr;
        }
        
        const auto& proto = _prototypes.at(typeId);
        return std::make_unique<Tower>(_nextInstanceId++, proto, position);
    }
    
    const TowerPrototype* getPrototype(const std::string& typeId) const {
        auto it = _prototypes.find(typeId);
        if (it != _prototypes.end()) {
            return &it->second;
        }
        return nullptr;
    }
};

#endif