#include "GameMap.h"
#include "Asset/AssetManager.h"
#include "EngineFrame/Scene/Scene.h"
#include "EngineFrame/Component/Animation.h"
#include "Actor/Map/GameMapCamera.h"
#include "Actor/Object/CharacterObject.h"

GameMap::GameMap()
{
    _LayerMap["contact"] = new GameMapLayer();
    _LayerMap["distantback"] = new GameMapLayer();
    _LayerMap["middleback"] = new GameMapLayer();
    _LayerMap["bottom"] = new GameMapLayer();
    _LayerMap["closeback"] = new GameMapLayer();
    _LayerMap["normal"] = new GameMapLayer();
    _LayerMap["close"] = new GameMapLayer();
    _LayerMap["cover"] = new GameMapLayer();
    _LayerMap["max"] = new GameMapLayer();

    // 设置图层渲染顺序
    _LayerMap["contact"]->SetRenderZOrder(10000);
    _LayerMap["distantback"]->SetRenderZOrder(50000);
    _LayerMap["middleback"]->SetRenderZOrder(100000);
    _LayerMap["bottom"]->SetRenderZOrder(150000);
    _LayerMap["closeback"]->SetRenderZOrder(200000);
    _LayerMap["normal"]->SetRenderZOrder(250000);
    _LayerMap["close"]->SetRenderZOrder(300000);
    _LayerMap["cover"]->SetRenderZOrder(350000);
    _LayerMap["max"]->SetRenderZOrder(400000);
}

GameMap::~GameMap()
{
}

void GameMap::InitConfiguration(std::string mapName)
{
    ScriptData Data = AssetManager::GetInstance().GetScriptInfo(mapName);
    _MapInfo["wide_mode_camer_vertical_correction"] = 0;
    _MapInfo["background_pos"] = 0;
    _MapPath = mapName;
    _MapDir = mapName.substr(0, mapName.find_last_of("/") + 1);
    while (!Data.IsEnd())
    {
        std::string Segment = Data.Get();
        if (Segment == "[background pos]")
        {
            _MapInfo["background_pos"] = std::stoi(Data.Get());
        }
        else if (Segment == "[map name]")
        {
            _MapInfo["name"] = Data.Get();
        }
        else if (Segment == "[wide mode camera vertical correction]")
        {
            _MapInfo["wide_mode_camer_vertical_correction"] = std::stoi(Data.Get());
        }
        else if (Segment == "[tile]")
        {
            std::vector<std::string> tileArry;
            while (true)
            {
                auto tiledata = Data.Get();
                if (tiledata == "[/tile]")
                    break;
                tileArry.push_back(_MapDir + Tool_toLowerCase(tiledata));
            }
            _MapInfo["tile"] = tileArry;
        }
        else if (Segment == "[extended tile]")
        {
            std::vector<std::string> tileArry;
            while (true)
            {
                auto tiledata = Data.Get();
                if (tiledata == "[/extended tile]")
                    break;
                tileArry.push_back(_MapDir + Tool_toLowerCase(tiledata));
            }
            _MapInfo["extended_tile"] = tileArry;
        }
        else if (Segment == "[far sight scroll]" || Segment == "[middle sight scroll]" || Segment == "[near sight scroll]")
        {
            _MapInfo[Segment.substr(1, Segment.length() - 2)] = std::stoi(Data.Get());
        }
        else if (Segment == "[background animation]")
        {
            std::vector<BackGroundAni> Arr;
            while (true)
            {
                std::string aniData = Data.Get();
                if (aniData == "[/background animation]")
                    break;
                if (aniData == "[ani info]")
                {
                    BackGroundAni ani;
                    Data.Get();
                    ani.filename = _MapDir + Tool_toLowerCase(Data.Get());
                    Data.Get();
                    ani.layer = Data.Get();
                    Data.Get();
                    ani.order = Data.Get();
                    Arr.push_back(ani);
                }
            }
            _MapInfo["background_animation"] = Arr;
        }
        else if (Segment == "[sound]")
        {
            std::vector<std::string> soundArry;
            while (true)
            {
                std::string sounddata = Data.Get();
                if (sounddata == "[/sound]")
                    break;
                soundArry.push_back(sounddata);
            }
            _MapInfo["sound"] = soundArry;
        }
        else if (Segment == "[animation]")
        {
            std::vector<MapAni> aniArry;
            while (true)
            {
                std::string aniData = Data.Get();
                if (aniData == "[/animation]")
                    break;
                MapAni info;
                info.filename = Tool_RegRealPath(_MapDir + Tool_toLowerCase(aniData));
                info.layer = Data.Get();
                info.XPos = std::stoi(Data.Get());
                info.YPos = std::stoi(Data.Get());
                info.ZPos = std::stoi(Data.Get());
                aniArry.push_back(info);
            }
            _MapInfo["animation"] = aniArry;
        }
        else if (Segment == "[NPC]")
        {
            std::vector<MapNpc> npcArry;
            while (true)
            {
                std::string npcData = Data.Get();
                if (npcData == "[/NPC]")
                    break;
                MapNpc info;
                info.id = std::stoi(npcData);
                info.direction = Data.Get();
                info.XPos = std::stoi(Data.Get());
                info.YPos = std::stoi(Data.Get());
                info.ZPos = std::stoi(Data.Get());
                npcArry.push_back(info);
            }
            _MapInfo["NPC"] = npcArry;
        }
        else if (Segment == "[town movable area]")
        {
            std::vector<int> town_movable_area;
            std::vector<MapMoveArea> town_movable_area_info;
            while (true)
            {
                std::string areadata = Data.Get();
                if (areadata == "[/town movable area]")
                    break;
                town_movable_area.push_back(std::stoi(areadata));
                town_movable_area.push_back(std::stoi(areadata));
                town_movable_area.push_back(std::stoi(areadata));
                town_movable_area.push_back(std::stoi(areadata));
                MapMoveArea T;
                T.town = std::stoi(areadata);
                T.area = std::stoi(areadata);
                town_movable_area_info.push_back(T);
            }
            _MapInfo["town_movable_area"] = town_movable_area;
            _MapInfo["town_movable_area_info"] = town_movable_area_info;
        }
        else if (Segment == "[virtual movable area]")
        {
            std::vector<int> virtual_movable_area;
            while (true)
            {
                std::string areadata = Data.Get();
                if (areadata == "[/virtual movable area]")
                    break;
                virtual_movable_area.push_back(std::stoi(areadata));
                virtual_movable_area.push_back(std::stoi(Data.Get()));
                virtual_movable_area.push_back(std::stoi(Data.Get()));
                virtual_movable_area.push_back(std::stoi(Data.Get()));
            }
            _MapInfo["virtual_movable_area"] = virtual_movable_area;
        }
    }
}

void GameMap::InitTile()
{
    if (!_MapInfo.count("tile"))
        return;
    int NormalTileCount = 0;
    std::vector<std::string> tileArr = std::get<std::vector<std::string>>(_MapInfo["tile"]);
    if (tileArr.size() > 0)
    {
        NormalTileCount = tileArr.size();
        _MapLength = NormalTileCount * 224;
        for (int i = 0; i < NormalTileCount; i++)
        {
            std::string path = tileArr[i];
            RefPtr<Tile> tile = new Tile(path);
            tile->SetPos(VecFPos{i * 224, -200 - std::get<int>(_MapInfo["background_pos"])});
            _LayerMap["bottom"]->AddComponent(tile);
        }
        _MapHeight = 560;
    }
    if (_MapInfo.count("extended_tile"))
    {
        std::vector<std::string> extileArr = std::get<std::vector<std::string>>(_MapInfo["extended_tile"]);
        if (extileArr.size() > 0)
        {
            int ExTileCount = extileArr.size();
            int Buffer = (ExTileCount / NormalTileCount);
            _MapHeight += (Buffer < 1 ? 1 : Buffer) * 40;
            for (int i = 0; i < ExTileCount; i++)
            {
                std::string path = extileArr[i];
                RefPtr<Tile> tile = new Tile(path);
                int xbuf = i % NormalTileCount * 224;
                int ybuf = 560 - 200 - std::get<int>(_MapInfo["background_pos"]) + 40 * (i / NormalTileCount);
                tile->SetPos(VecFPos{xbuf, ybuf});
                _LayerMap["bottom"]->AddComponent(tile);
            }
        }
    }
}

void GameMap::InitBackgroundAnimation()
{
    float Rate = _MapInfo.count("far_sight_scroll") ? std::get<int>(_MapInfo["far_sight_scroll"]) / 100.0f : 1.0f;
    (void)Rate;
    // TODO 摄像机
    if (_MapInfo.count("background_animation"))
    {
        std::vector<BackGroundAni> aniArr = std::get<std::vector<BackGroundAni>>(_MapInfo["background_animation"]);
        for (auto &ani : aniArr)
        {
            std::string path = ani.filename;
            std::vector<RefPtr<Animation>> AniList;
            RefPtr<Animation> AniObj = new Animation(path);
            int width = AniObj->GetSize().width;
            AniList.push_back(AniObj);
            for (int i = 0; i < (_MapLength * Rate) / width; i++)
            {
                RefPtr<Animation> AniObj = new Animation(path);
                AniList.push_back(AniObj);
            }
            for (int i = 0; i < (int)AniList.size(); i++)
            {
                AniList[i]->SetPos(VecFPos{i * width, -120});
                AniList[i]->SetRenderZOrder(-1000000);
                std::string layer = ani.layer;
                layer = layer.substr(1, layer.length() - 2);
                if (_LayerMap.count(layer))
                {
                    _LayerMap[layer]->AddChild(AniList[i]);
                }
                else
                {
                }
            }
        }
    }
}

void GameMap::InitMapAnimation()
{
    if (_MapInfo.count("animation"))
    {
        std::vector<MapAni> aniArr = std::get<std::vector<MapAni>>(_MapInfo["animation"]);
        for (auto &ani : aniArr)
        {
            std::string path = ani.filename;
            RefPtr<Animation> AniObj = new Animation(path);
            AniObj->SetPos(VecFPos{ani.XPos, ani.YPos - ani.ZPos});
            AniObj->SetRenderZOrder(ani.YPos);
            std::string layer = ani.layer;
            layer = layer.substr(1, layer.length() - 2);
            if (_LayerMap.count(layer))
            {
                _LayerMap[layer]->AddChild(AniObj);
            }
        }
    }
}

void GameMap::LoadMap(std::string mapName)
{
    // 读取脚本配置
    InitConfiguration(mapName);
    // 初始化地板
    InitTile();
    // 初始化背景动画
    InitBackgroundAnimation();
    // 初始化场景Ani
    InitMapAnimation();

    RefPtr<CharacterObject> obj = new CharacterObject();
    obj->SetPosition({620, 200, 0});
    obj->Construction(0);
    _LayerMap["normal"]->AddObject(obj);
}

void GameMap::Enter(Scene *scene)
{
    scene->AddChild(_LayerMap["contact"]);
    scene->AddChild(_LayerMap["distantback"]);
    scene->AddChild(_LayerMap["middleback"]);
    scene->AddChild(_LayerMap["bottom"]);
    scene->AddChild(_LayerMap["closeback"]);
    scene->AddChild(_LayerMap["normal"]);
    scene->AddChild(_LayerMap["close"]);
    scene->AddChild(_LayerMap["cover"]);
    scene->AddChild(_LayerMap["max"]);

    // TODO
    int HSU = 230;
    _LayerMap["contact"]->SetPos(VecFPos{0, HSU});
    _LayerMap["distantback"]->SetPos(VecFPos{0, HSU});
    _LayerMap["middleback"]->SetPos(VecFPos{0, HSU});
    _LayerMap["bottom"]->SetPos(VecFPos{0, HSU});
    _LayerMap["closeback"]->SetPos(VecFPos{0, HSU});
    _LayerMap["normal"]->SetPos(VecFPos{0, HSU});
    _LayerMap["close"]->SetPos(VecFPos{0, HSU});
    _LayerMap["cover"]->SetPos(VecFPos{0, HSU});
    _LayerMap["max"]->SetPos(VecFPos{0, HSU});
}

void GameMap::HandleEvents(SDL_Event *e)
{
}

void GameMap::Update(float deltaTime)
{
    // this->_Camera->Update(deltaTime);

    // if (this->_Camera)
    // {
    //     int CamearXpos = this->_Camera->X;
    //     int CamearYpos = this->_Camera->Y;
    //     int CamearZpos = this->_Camera->Z;

    //     SDL_Log("Camera Pos: %d, %d", CamearXpos, CamearYpos);
    //     // 遍历
    //     for (auto &pair : _LayerMap)
    //     {
    //         // pair.first 是 key（std::string）
    //         std::string key = pair.first;
    //         // pair.second 是 value（RefPtr<GameMapLayer>）
    //         RefPtr<GameMapLayer> &value = pair.second;

    //         if (key == "distantback")
    //         {
    //             value->SetPos(VecPos{(-CamearXpos + 553), (-CamearYpos + CamearZpos + 300 + 120 + 80)});
    //         }
    //         else
    //         {
    //             value->SetPos(VecPos{(-CamearXpos + 553), (-CamearYpos + CamearZpos + 300 + 120 + 80)});
    //         }
    //     }
    // }
}