/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef TERRAIN_MGR_H
#define TERRAIN_MGR_H

#include "Define.h"
#include "GridDefines.h"
#include "MapDefines.h"
#include "Position.h"
#include "Timer.h"
#include <atomic>
#include <bitset>
#include <memory>
#include <mutex>
#include <unordered_map>
#include <vector>

class DynamicMapTree;
class GridMap;
class PhaseShift;

class TC_GAME_API TerrainInfo
{
public:
    explicit TerrainInfo(uint32 mapId);
    TerrainInfo(TerrainInfo const&) = delete;
    TerrainInfo(TerrainInfo&&) = delete;
    TerrainInfo& operator=(TerrainInfo const&) = delete;
    TerrainInfo& operator=(TerrainInfo&&) = delete;
    ~TerrainInfo();

    uint32 GetId() const { return _mapId; }
    char const* GetMapName() const;

    void DiscoverGridMapFiles();

    static bool ExistMap(uint32 mapid, int32 gx, int32 gy, bool log = true);
    static bool ExistVMap(uint32 mapid, int32 gx, int32 gy);

    bool HasChildTerrainGridFile(uint32 mapId, int32 gx, int32 gy) const;
    void AddChildTerrain(std::shared_ptr<TerrainInfo> childTerrain);

    void LoadMapAndVMap(int32 gx, int32 gy);
    void LoadMMapInstance(uint32 mapId, uint32 instanceId);

private:
    void LoadMapAndVMapImpl(int32 gx, int32 gy);
    void LoadMMapInstanceImpl(uint32 mapId, uint32 instanceId);
    void LoadMap(int32 gx, int32 gy);
    void LoadVMap(int32 gx, int32 gy);
    void LoadMMap(int32 gx, int32 gy);

public:
    void UnloadMap(int32 gx, int32 gy);
    void UnloadMMapInstance(uint32 mapId, uint32 instanceId);

private:
    void UnloadMapImpl(int32 gx, int32 gy);
    void UnloadMMapInstanceImpl(uint32 mapId, uint32 instanceId);

    GridMap* GetGrid(uint32 mapId, float x, float y, bool loadIfMissing = true);

public:
    void CleanUpGrids(uint32 diff);

    void GetFullTerrainStatusForPosition(PhaseShift const& phaseShift, uint32 mapId, float x, float y, float z, PositionFullTerrainStatus& data, Optional<map_liquidHeaderTypeFlags> reqLiquidType = {}, float collisionHeight = 2.03128f, DynamicMapTree const* dynamicMapTree = nullptr); // DEFAULT_COLLISION_HEIGHT in Object.h
    ZLiquidStatus GetLiquidStatus(PhaseShift const& phaseShift, uint32 mapId, float x, float y, float z, Optional<map_liquidHeaderTypeFlags> ReqLiquidType = {}, LiquidData* data = nullptr, float collisionHeight = 2.03128f); // DEFAULT_COLLISION_HEIGHT in Object.h

    bool GetAreaInfo(PhaseShift const& phaseShift, uint32 mapId, float x, float y, float z, uint32& mogpflags, int32& adtId, int32& rootId, int32& groupId, DynamicMapTree const* dynamicMapTree = nullptr);
    uint32 GetAreaId(PhaseShift const& phaseShift, uint32 mapId, float x, float y, float z, DynamicMapTree const* dynamicMapTree = nullptr);
    uint32 GetAreaId(PhaseShift const& phaseShift, uint32 mapId, Position const& pos, DynamicMapTree const* dynamicMapTree = nullptr) { return GetAreaId(phaseShift, mapId, pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), dynamicMapTree); }
    uint32 GetZoneId(PhaseShift const& phaseShift, uint32 mapId, float x, float y, float z, DynamicMapTree const* dynamicMapTree = nullptr);
    uint32 GetZoneId(PhaseShift const& phaseShift, uint32 mapId, Position const& pos, DynamicMapTree const* dynamicMapTree = nullptr) { return GetZoneId(phaseShift, mapId, pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), dynamicMapTree); }
    void GetZoneAndAreaId(PhaseShift const& phaseShift, uint32 mapId, uint32& zoneid, uint32& areaid, float x, float y, float z, DynamicMapTree const* dynamicMapTree = nullptr);
    void GetZoneAndAreaId(PhaseShift const& phaseShift, uint32 mapId, uint32& zoneid, uint32& areaid, Position const& pos, DynamicMapTree const* dynamicMapTree = nullptr) { GetZoneAndAreaId(phaseShift, mapId, zoneid, areaid, pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), dynamicMapTree); }

    float GetMinHeight(PhaseShift const& phaseShift, uint32 mapId, float x, float y);
    float GetGridHeight(PhaseShift const& phaseShift, uint32 mapId, float x, float y);
    float GetStaticHeight(PhaseShift const& phaseShift, uint32 mapId, float x, float y, float z, bool checkVMap = true, float maxSearchDist = DEFAULT_HEIGHT_SEARCH);
    float GetStaticHeight(PhaseShift const& phaseShift, uint32 mapId, Position const& pos, bool checkVMap = true, float maxSearchDist = DEFAULT_HEIGHT_SEARCH) { return GetStaticHeight(phaseShift, mapId, pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), checkVMap, maxSearchDist); }

    float GetWaterLevel(PhaseShift const& phaseShift, uint32 mapId, float x, float y);
    bool IsInWater(PhaseShift const& phaseShift, uint32 mapId, float x, float y, float z, LiquidData* data = nullptr);
    bool IsUnderWater(PhaseShift const& phaseShift, uint32 mapId, float x, float y, float z);

    float GetWaterOrGroundLevel(PhaseShift const& phaseShift, uint32 mapId, float x, float y, float z, float* ground = nullptr, bool swim = false, float collisionHeight = 2.03128f, DynamicMapTree const* dynamicMapTree = nullptr); // DEFAULT_COLLISION_HEIGHT in Object.h

private:
    static constexpr int32 GetBitsetIndex(int32 gx, int32 gy) { return gx * MAX_NUMBER_OF_GRIDS + gy; }

    uint32 _mapId;

    TerrainInfo* _parentTerrain;
    std::vector<std::shared_ptr<TerrainInfo>> _childTerrain;

    std::mutex _loadMutex;
    std::unique_ptr<GridMap> _gridMap[MAX_NUMBER_OF_GRIDS][MAX_NUMBER_OF_GRIDS];
    std::atomic<uint16> _referenceCountFromMap[MAX_NUMBER_OF_GRIDS][MAX_NUMBER_OF_GRIDS];
    std::bitset<MAX_NUMBER_OF_GRIDS* MAX_NUMBER_OF_GRIDS> _loadedGrids;
    std::bitset<MAX_NUMBER_OF_GRIDS* MAX_NUMBER_OF_GRIDS> _gridFileExists; // cache what grids are available for this map (not including parent/child maps)

    static constexpr Milliseconds CleanupInterval = 1min;

    // global garbage collection timer
    TimeTracker _cleanupTimer;
};

class TC_GAME_API TerrainMgr
{
    TerrainMgr();
    ~TerrainMgr();
public:
    TerrainMgr(TerrainMgr const&) = delete;
    TerrainMgr(TerrainMgr&&) = delete;
    TerrainMgr& operator=(TerrainMgr const&) = delete;
    TerrainMgr& operator=(TerrainMgr&&) = delete;

    static TerrainMgr& Instance();

    void InitializeParentMapData(std::unordered_map<uint32, std::vector<uint32>> const& mapData);

    std::shared_ptr<TerrainInfo> LoadTerrain(uint32 mapId);
    void UnloadAll();

    void Update(uint32 diff);

    uint32 GetAreaId(PhaseShift const& phaseShift, uint32 mapid, float x, float y, float z);
    uint32 GetAreaId(PhaseShift const& phaseShift, uint32 mapid, Position const& pos) { return GetAreaId(phaseShift, mapid, pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ()); }
    uint32 GetAreaId(PhaseShift const& phaseShift, WorldLocation const& loc) { return GetAreaId(phaseShift, loc.GetMapId(), loc); }

    uint32 GetZoneId(PhaseShift const& phaseShift, uint32 mapid, float x, float y, float z);
    uint32 GetZoneId(PhaseShift const& phaseShift, uint32 mapid, Position const& pos) { return GetZoneId(phaseShift, mapid, pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ()); }
    uint32 GetZoneId(PhaseShift const& phaseShift, WorldLocation const& loc) { return GetZoneId(phaseShift, loc.GetMapId(), loc); }

    void GetZoneAndAreaId(PhaseShift const& phaseShift, uint32& zoneid, uint32& areaid, uint32 mapid, float x, float y, float z);
    void GetZoneAndAreaId(PhaseShift const& phaseShift, uint32& zoneid, uint32& areaid, uint32 mapid, Position const& pos) { GetZoneAndAreaId(phaseShift, zoneid, areaid, mapid, pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ()); }
    void GetZoneAndAreaId(PhaseShift const& phaseShift, uint32& zoneid, uint32& areaid, WorldLocation const& loc) { GetZoneAndAreaId(phaseShift, zoneid, areaid, loc.GetMapId(), loc); }

    static bool ExistMapAndVMap(uint32 mapid, float x, float y);

private:
    std::shared_ptr<TerrainInfo> LoadTerrainImpl(uint32 mapId);

    std::unordered_map<uint32, std::weak_ptr<TerrainInfo>> _terrainMaps;

    // parent map links
    std::unordered_map<uint32, std::vector<uint32>> _parentMapData;
};

#define sTerrainMgr TerrainMgr::Instance()

#endif // TERRAIN_MGR_H