#ifndef GAMEMANAGER_H
#define GAMEMANAGER_H

#include <vector>
#include <memory>
#include <QString>
#include "player.h"
#include "unitconfig.h"
#include "buildingconfig.h"
#include "unit.h"
#include "city.h"
#include "matrix2d.h"
#include "terrain.h"
#include "terrainyieldmanager.h"

enum class ActionMode {
    None,
    Move,
    Attack,
    BuildCity,
    BuildFarm
};

struct TileImprovement {
    QString improvementId; // "farm"
    int tileX;
    int tileY;
    int playerId;
    QVector3D worldPos;
};

struct FloatingText {
    QString text;
    QVector3D worldPos;
    float life; // Remaining seconds
    float maxLife;
    QColor color;
};

class GameManager {
public:
    static GameManager& instance();

    void init(const QString &baseDir, Matrix2D<TerrainPoint> *mapPoints, int numPoints05);
    void update(float deltaTime, Matrix2D<TerrainPoint> *mapPoints, int numPoints05);

    PlayerManager& players() { return m_playerManager; }
    UnitConfigManager& unitConfigs() { return m_unitConfigManager; }
    BuildingConfigManager& buildingConfigs() { return m_buildingConfigManager; }
    const BuildingConfigManager& buildingConfigs() const { return m_buildingConfigManager; }

    const std::vector<std::shared_ptr<Unit>>& getUnits() const { return m_units; }
    const std::vector<City>& getCities() const { return m_cities; }
    std::vector<City>& getCitiesMutable() { return m_cities; }
    const std::vector<FloatingText>& getFloatingTexts() const { return m_floatingTexts; }

    Unit* getSelectedUnit();
    const Unit* getSelectedUnit() const;
    void selectUnit(int id);
    void deselectUnit();

    ActionMode currentActionMode() const { return m_actionMode; }
    void setActionMode(ActionMode mode) { m_actionMode = mode; }

    Unit* getUnitAt(int tx, int ty);
    Unit* getUnitById(int id);

    City* getCityAt(int tx, int ty);
    City* getCityById(int id);

    // City View System
    bool isInCityView() const { return m_activeCityViewId != -1; }
    int getActiveCityViewId() const { return m_activeCityViewId; }
    City* getActiveCityView();
    const City* getActiveCityView() const;
    void enterCityView(int cityId);
    void exitCityView();

    CityYieldSummary calculateCityYields(const City &city, Matrix2D<TerrainPoint> *mapPoints, int numPoints05) const;
    void processTickYields(Matrix2D<TerrainPoint> *mapPoints, int numPoints05);

    bool isTileOwned(int tx, int ty, int *outOwnerCityId = nullptr) const;
    bool buyTileForCity(int cityId, int tx, int ty);

    void setCityProject(int cityId, CityProjectType type, const QString &id);
    void cancelCityProject(int cityId);
    void completeCityProject(City &city, Matrix2D<TerrainPoint> *mapPoints, int numPoints05);

    void commandMoveSelected(int targetX, int targetY, Matrix2D<TerrainPoint> *mapPoints, int numPoints05);
    void commandAttack(Unit *target);
    void commandBuildCitySelected(Matrix2D<TerrainPoint> *mapPoints, int numPoints05);
    void commandBuildFarmSelected(Matrix2D<TerrainPoint> *mapPoints, int numPoints05);
    void completeUnitBuilding(Unit &unit, Matrix2D<TerrainPoint> *mapPoints, int numPoints05);

    const std::map<std::pair<int, int>, TileImprovement>& getTileImprovements() const { return m_tileImprovements; }
    const TileImprovement* getImprovementAt(int tx, int ty) const;
    bool hasImprovementAt(int tx, int ty) const;

    float getTickDuration() const { return m_movementTickDuration; }
    void setTickDuration(float d) { m_movementTickDuration = std::max(1.0f, d); }
    float getTickTimer() const { return m_tickTimer; }

    float getSimSpeed() const { return m_simSpeedMultiplier; }
    void setSimSpeed(float s) { m_simSpeedMultiplier = std::max(0.2f, std::min(10.0f, s)); }

    void addFloatingText(const QString &text, const QVector3D &worldPos, const QColor &color, float duration = 1.8f);

    int getNextUnitId() { return ++m_nextUnitId; }
    int getNextCityId() { return ++m_nextCityId; }

    Unit* spawnUnit(const QString &configId, int playerId, int tileX, int tileY,
                    Matrix2D<TerrainPoint> *mapPoints, int numPoints05);

private:
    GameManager();
    ~GameManager() = default;

    PlayerManager m_playerManager;
    UnitConfigManager m_unitConfigManager;
    BuildingConfigManager m_buildingConfigManager;
    std::vector<std::shared_ptr<Unit>> m_units;
    std::vector<City> m_cities;
    std::vector<FloatingText> m_floatingTexts;
    std::map<std::pair<int, int>, TileImprovement> m_tileImprovements;

    int m_selectedUnitId;
    int m_activeCityViewId;
    ActionMode m_actionMode;

    float m_movementTickDuration; // Default 30.0s
    float m_tickTimer;
    float m_simSpeedMultiplier; // 1.0x, 2.0x, etc.

    int m_nextUnitId;
    int m_nextCityId;
    bool m_initialized;
};

#endif // GAMEMANAGER_H