#include "precompile.h"

#include <a8/stringlist.h>
#include <a8/csvreader.h>

#include "framework/cpp/utils.h"

#include "metamgr.h"
#include "app.h"

#define METAMGR_READ(field_name, def_val) MetaMgr::Instance()->field_name = \
        a8::XValue(MetaMgr::Instance()->GetSysParamAsString(#field_name, #def_val));

#define METAMGR_READ_STR(field_name, def_val) MetaMgr::Instance()->field_name = \
        a8::XValue(MetaMgr::Instance()->GetSysParamAsString(#field_name, def_val)).GetString();

class MetaDataLoader
{
public:
    std::list<metatable::Parameter> parameter_meta_list;
    std::list<MetaData::Parameter> parameter_list;
    std::list<metatable::Map> map_meta_list;
    std::list<MetaData::Map> map_list;
    std::list<metatable::SafeArea> safearea_meta_list;
    std::list<MetaData::SafeArea> safearea_list;
    std::list<metatable::Item> item_meta_list;
    std::list<MetaData::Item> item_list;
    std::list<metatable::Equip> equip_meta_list;
    std::list<MetaData::Equip> equip_list;
    std::list<metatable::Player> player_meta_list;
    std::list<MetaData::Player> player_list;
    std::list<metatable::MapThing> mapthing_meta_list;
    std::list<MetaData::MapThing> mapthing_list;
    std::list<metatable::BuildingJson> building_meta_list;
    std::list<MetaData::Building> building_list;
    std::list<metatable::Drop> drop_meta_list;
    std::list<MetaData::Drop> drop_list;
    std::list<metatable::AirDrop> airdrop_meta_list;
    std::list<MetaData::AirDrop> airdrop_list;
    std::list<metatable::AirLine> airline_meta_list;
    std::list<MetaData::AirLine> airline_list;
    std::list<metatable::Dress> dress_meta_list;
    std::list<MetaData::Dress> dress_list;
    std::list<metatable::Skill> skill_meta_list;
    std::list<MetaData::Skill> skill_list;
    std::list<metatable::Buff> buff_meta_list;
    std::list<MetaData::Buff> buff_list;
    std::list<metatable::Attr> attr_meta_list;
    std::list<MetaData::Attr> attr_list;
    std::list<metatable::RankReward> rankreward_meta_list;
    std::list<MetaData::RankReward> rankreward_list;
    std::list<metatable::EquipUpgrade> equipupgrade_meta_list;
    std::list<MetaData::EquipUpgrade> equipupgrade_list;
    std::list<metatable::KillReward> killreward_meta_list;
    std::list<MetaData::KillReward> killreward_list;
    std::list<metatable::RankPoint> rankpoint_meta_list;
    std::list<MetaData::RankPoint> rankpoint_list;
    std::list<metatable::KillPoint> killpoint_meta_list;
    std::list<MetaData::KillPoint> killpoint_list;
    std::list<metatable::Robot> robot_meta_list;
    std::vector<MetaData::Robot> robot_list;
    std::list<metatable::AI> ai_meta_list;
    std::list<MetaData::AI> ai_list;

    std::map<std::string, MetaData::Parameter*> parameter_hash;
    std::map<int, MetaData::Map*> gamemap_hash;
    std::map<int, MetaData::SafeArea*> safearea_hash;
    std::map<int, MetaData::Item*> item_hash;
    std::map<int, MetaData::Equip*> equip_hash;
    std::map<int, MetaData::Equip*> equip_slot_hash;
    std::map<int, MetaData::Player*> player_hash;
    std::map<int, MetaData::MapThing*> mapthing_hash;
    std::map<int, MetaData::Building*> building_hash;
    std::map<int, MetaData::Drop*> drop_hash;
    std::map<std::string, std::list<metatable::MapTplThingJson>> maptpl_meta_hash;
    std::map<std::string, std::vector<MetaData::MapTplThing>> maptpl_hash;
    std::map<int, MetaData::Dress*> dress_hash;
    std::vector<MetaData::Dress*> dress_vec;
    std::map<int, MetaData::Skill*> skill_hash;
    std::map<int, MetaData::Buff*> buff_hash;
    std::map<int, MetaData::Attr*> attr_id_hash;
    std::map<std::string, MetaData::Attr*> attr_name_hash;
    std::map<int, MetaData::RankReward*> rankreward_hash;
    std::map<int, MetaData::KillReward*> killreward_hash;
    std::map<int, MetaData::RankPoint*> rankpoint_hash;
    std::map<int, MetaData::KillPoint*> killpoint_hash;
    std::map<int, MetaData::EquipUpgrade*> equipupgrade_hash;
    std::map<int, MetaData::Robot*> robot_hash;
    std::map<int, std::vector<MetaData::AirLine*>> airline_hash;
    std::map<int, MetaData::AI*> ai_hash;

    void Load()
    {
        if (!f8::IsOnlineEnv()) {
            if (f8::IsTestEnv()) {
                res_path = a8::Format("/root/pub/%d/%d/conf_test/game%d/gameserver.test/res/",
                                      {
                                       GAME_ID,
                                       App::Instance()->instance_id,
                                       GAME_ID
                                      });
            } else {
                res_path = a8::Format("/root/pub/%d/%d/conf_test/game%d/gameserver.dev/res/",
                                      {
                                       GAME_ID,
                                       App::Instance()->instance_id,
                                       GAME_ID
                                      });
            }
        } else {
            res_path = "../res/";
        }

        f8::ReadCsvMetaFile(res_path + "parameter@parameter.csv", parameter_meta_list);
        f8::ReadCsvMetaFile(res_path + "map@map.csv", map_meta_list);
        f8::ReadCsvMetaFile(res_path + "safearea@safearea.csv", safearea_meta_list);
        f8::ReadCsvMetaFile(res_path + "item@item.csv", item_meta_list);
        f8::ReadCsvMetaFile(res_path + "equip@equip.csv", equip_meta_list);
        f8::ReadCsvMetaFile(res_path + "player@player.csv", player_meta_list);
        f8::ReadCsvMetaFile(res_path + "player@player.csv", player_meta_list);
        f8::ReadCsvMetaFile(res_path + "mapThing@mapThing.csv", mapthing_meta_list);
        f8::ReadCsvMetaFile(res_path + "drop@drop.csv", drop_meta_list);
        f8::ReadCsvMetaFile(res_path + "airdrop@airdrop.csv", airdrop_meta_list);
        f8::ReadCsvMetaFile(res_path + "airline@airline.csv", airline_meta_list);
        f8::ReadJsonMetaFile(res_path + "maps.json", building_meta_list);
        f8::ReadCsvMetaFile(res_path + "dress@dress.csv", dress_meta_list);
        f8::ReadCsvMetaFile(res_path + "skill@skill.csv", skill_meta_list);
        f8::ReadCsvMetaFile(res_path + "buff@buff.csv", buff_meta_list);
        f8::ReadCsvMetaFile(res_path + "attr@attr.csv", attr_meta_list);
        f8::ReadCsvMetaFile(res_path + "rankReward@rankReward.csv", rankreward_meta_list);
        f8::ReadCsvMetaFile(res_path + "killReward@killReward.csv", killreward_meta_list);
        f8::ReadCsvMetaFile(res_path + "killPoint@killPoint.csv", killpoint_meta_list);
        f8::ReadCsvMetaFile(res_path + "rankPoint@rankPoint.csv", rankpoint_meta_list);
        f8::ReadCsvMetaFile(res_path + "equipUpgrade@equipUpgrade.csv", equipupgrade_meta_list);
        f8::ReadCsvMetaFile(res_path + "robot@robot.csv", robot_meta_list);
        f8::ReadCsvMetaFile(res_path + "ai@ai.csv", ai_meta_list);
        BindToMetaData();
        #if 1
        {
            MetaMgr::Instance()->gas_inactive_time = MetaMgr::Instance()->GetSysParamAsInt("gas_inactive_time");

            MetaMgr::Instance()->newbie_gas_inactive_time = MetaMgr::Instance()->GetSysParamAsInt("newbie_gas_inactive_time", 5);
            MetaMgr::Instance()->midbrid_gas_inactive_time = MetaMgr::Instance()->GetSysParamAsInt("midbrid_gas_inactive_time", 15);
            MetaMgr::Instance()->common_gas_inactive_time = MetaMgr::Instance()->GetSysParamAsInt("common_gas_inactive_time", 15);
            MetaMgr::Instance()->newbie_born_point = MetaMgr::Instance()->GetSysParamAsString("newbie_born_point");
            {
                std::vector<std::string> strings;
                std::string tmpstr = MetaMgr::Instance()->GetSysParamAsString("newbie_drop");
                a8::Split(tmpstr, strings, ':');
                for (const std::string& str : strings) {
                    int drop_id = a8::XValue(str);
                    MetaMgr::Instance()->newbie_drop.push_back(drop_id);
                }
            }
            {
                std::vector<std::string> strings;
                std::string tmpstr = MetaMgr::Instance()->GetSysParamAsString("newbie_airdrop");
                a8::Split(tmpstr, strings, ':');
                for (const std::string& str : strings) {
                    int drop_id = a8::XValue(str);
                    MetaMgr::Instance()->newbie_airdrop.push_back(drop_id);
                }
            }
            MetaMgr::Instance()->newbie_first_robot_distance =
                MetaMgr::Instance()->GetSysParamAsInt("newbie_first_robot_distance", 500);
            {
                std::vector<std::string> strings;
                std::string tmpstr = MetaMgr::Instance()->GetSysParamAsString("newbie_buff_list");
                a8::Split(tmpstr, strings, ':');
                for (const std::string& str : strings) {
                    int drop_id = a8::XValue(str);
                    MetaMgr::Instance()->newbie_buff_list.push_back(drop_id);
                }
            }

            MetaMgr::Instance()->jump_time = MetaMgr::Instance()->GetSysParamAsFloat("jump_time");
            MetaMgr::Instance()->K = MetaMgr::Instance()->GetSysParamAsFloat("K");
            MetaMgr::Instance()->kill_param = MetaMgr::Instance()->GetSysParamAsFloat("kill_parameter");
            MetaMgr::Instance()->rank_param = MetaMgr::Instance()->GetSysParamAsFloat("rank_parameter");
            MetaMgr::Instance()->fighting_mode = MetaMgr::Instance()->GetSysParamAsInt("fighting_mode", 1);
            MetaMgr::Instance()->tank_damage1 = MetaMgr::Instance()->GetSysParamAsInt("tank_damage1");
            MetaMgr::Instance()->tank_damage2 = MetaMgr::Instance()->GetSysParamAsInt("tank_damage2");
            MetaMgr::Instance()->tank_damage_interval = MetaMgr::Instance()->GetSysParamAsFloat("tank_damage_interval", 1);
            MetaMgr::Instance()->average_oil = MetaMgr::Instance()->GetSysParamAsInt("average_oil");
            MetaMgr::Instance()->max_oil = MetaMgr::Instance()->GetSysParamAsInt("max_oil");
            MetaMgr::Instance()->horse_shoot_x = MetaMgr::Instance()->GetSysParamAsInt("horse_shoot_x");
            MetaMgr::Instance()->horse_shoot_y = MetaMgr::Instance()->GetSysParamAsInt("horse_shoot_y");
            MetaMgr::Instance()->max_mount_horse_distance = MetaMgr::Instance()->GetSysParamAsFloat("max_mount_horse_distance", 100);
            MetaMgr::Instance()->newbie_game_times = MetaMgr::Instance()->GetSysParamAsInt("newbie_game_times", 5);
            MetaMgr::Instance()->niube_win_times = MetaMgr::Instance()->GetSysParamAsInt("niube_win_times", 1);
            MetaMgr::Instance()->newbie_fill_interval = MetaMgr::Instance()->GetSysParamAsInt("newbie_fill_interval", 5000);
            MetaMgr::Instance()->other_fill_interval = MetaMgr::Instance()->GetSysParamAsInt("other_fill_interval", 2000);
            MetaMgr::Instance()->map_cell_width = MetaMgr::Instance()->GetSysParamAsInt("map_cell_width", 64 * 8);
            METAMGR_READ(zbmode_gas_inactive_time, 25);
            METAMGR_READ(zbmode_game_duration, 300);
            METAMGR_READ(zbmode_player_num, 15);
            {
                METAMGR_READ(newbie_first_robot_ammo, 3);
                METAMGR_READ(newbie_first_robot_appeartime, 8);
                METAMGR_READ(newbie_airdrop_appeartime, 6);

                METAMGR_READ(level0room_shua_robot_min_time, 5);
                METAMGR_READ(level0room_shua_robot_max_time, 7);
                METAMGR_READ(level0room_shua_robot_min_num, 1);
                METAMGR_READ(level0room_shua_robot_max_num, 3);
                METAMGR_READ(level0room_die_robot_min_time, 10);
                METAMGR_READ(level0room_die_robot_max_time, 20);
                METAMGR_READ(level0room_die_robot_min_num, 1);
                METAMGR_READ(level0room_die_robot_max_num, 3);
                METAMGR_READ(level0room_robot_water, 3);
                METAMGR_READ(level0room_robot_protect_time, 60);
                METAMGR_READ(level0room_robot_autodie_time, 10);
                METAMGR_READ(level0room_robot_autodie_distance, 500);
                {
                    METAMGR_READ_STR(level0room_spec_things, "");
                    std::vector<std::string> tmpstrings;
                    a8::Split(MetaMgr::Instance()->level0room_spec_things, tmpstrings, ':');
                    for (auto& str : tmpstrings) {
                        if (!str.empty()) {
                            MetaMgr::Instance()->level0room_spec_things_set.insert
                                (
                                 a8::XValue(str).GetInt()
                                 );
                        }
                    }
                }
                {
                    METAMGR_READ_STR(level0room_spec_airdrop, "");
                    std::vector<std::string> tmpstrings;
                    a8::Split(MetaMgr::Instance()->level0room_spec_airdrop, tmpstrings, ':');
                    for (auto& str : tmpstrings) {
                        if (!str.empty()) {
                            MetaMgr::Instance()->level0room_spec_airdrops.push_back
                                (
                                 a8::XValue(str).GetInt()
                                 );
                        }
                    }
                }
                {
                    METAMGR_READ_STR(a_room_ai, "");
                    std::vector<std::string> tmpstrings;
                    a8::Split(MetaMgr::Instance()->a_room_ai, tmpstrings, '|');
                    int i = 1;
                    for (auto& str : tmpstrings) {
                        int weight = a8::XValue(str).GetInt();
                        MetaMgr::Instance()->a_room_ai_weights_space += weight;
                        MetaMgr::Instance()->a_room_ai_weights.push_back
                            (
                             std::make_tuple
                             (
                              i,
                              MetaMgr::Instance()->a_room_ai_weights_space
                              )
                             );
                        ++i;
                    }
                    if (MetaMgr::Instance()->a_room_ai_weights.size() != MAX_AI_LEVEL) {
                        abort();
                    }
                    if (MetaMgr::Instance()->a_room_ai_weights_space <= 0) {
                        abort();
                    }
                }
                {
                    METAMGR_READ_STR(b_room_ai, "");
                    std::vector<std::string> tmpstrings;
                    a8::Split(MetaMgr::Instance()->b_room_ai, tmpstrings, '|');
                    int i = 1;
                    for (auto& str : tmpstrings) {
                        int weight = a8::XValue(str).GetInt();
                        MetaMgr::Instance()->b_room_ai_weights_space += weight;
                        MetaMgr::Instance()->b_room_ai_weights.push_back
                            (
                             std::make_tuple
                             (
                              i,
                              MetaMgr::Instance()->b_room_ai_weights_space
                              )
                             );
                        ++i;
                    }
                    if (MetaMgr::Instance()->b_room_ai_weights.size() != MAX_AI_LEVEL) {
                        abort();
                    }
                    if (MetaMgr::Instance()->b_room_ai_weights_space <= 0) {
                        abort();
                    }
                }
                {
                    METAMGR_READ_STR(c_room_ai, "");
                    std::vector<std::string> tmpstrings;
                    a8::Split(MetaMgr::Instance()->c_room_ai, tmpstrings, '|');
                    int i = 1;
                    for (auto& str : tmpstrings) {
                        int weight = a8::XValue(str).GetInt();
                        MetaMgr::Instance()->c_room_ai_weights_space += weight;
                        MetaMgr::Instance()->c_room_ai_weights.push_back
                            (
                             std::make_tuple
                             (
                              i,
                              MetaMgr::Instance()->c_room_ai_weights_space
                              )
                             );
                        ++i;
                    }
                    if (MetaMgr::Instance()->c_room_ai_weights.size() != MAX_AI_LEVEL) {
                        abort();
                    }
                    if (MetaMgr::Instance()->c_room_ai_weights_space <= 0) {
                        abort();
                    }
                }

                METAMGR_READ(level1room_shua_robot_min_time, 5);
                METAMGR_READ(level1room_shua_robot_max_time, 7);
                METAMGR_READ(level1room_shua_robot_min_num, 2);
                METAMGR_READ(level1room_shua_robot_max_num, 5);
                METAMGR_READ(level1room_die_robot_min_time, 10);
                METAMGR_READ(level1room_die_robot_max_time, 14);
                METAMGR_READ(level1room_die_robot_min_num, 1);
                METAMGR_READ(level1room_die_robot_max_num, 3);
                METAMGR_READ(level1room_robot_water, 8);
                METAMGR_READ(level1room_robot_autodie_time, 10);
                METAMGR_READ(level1room_robot_autodie_distance, 500);
                METAMGR_READ_STR(level1room_born_point, "");

                METAMGR_READ(refresh_robot_min_num, 5);
                METAMGR_READ(refresh_robot_max_num, 10);
                METAMGR_READ(refresh_robot_min_time, 5);
                METAMGR_READ(refresh_robot_max_time, 10);
            }
            if (MetaMgr::Instance()->K < 0.01f) {
                abort();
            }
        }
        {
            MetaMgr::Instance()->human_meta = MetaMgr::Instance()->GetPlayer(40001);
            if (!MetaMgr::Instance()->human_meta) {
                abort();
            }
            MetaMgr::Instance()->android_meta = MetaMgr::Instance()->GetPlayer(40002);
            if (!MetaMgr::Instance()->android_meta) {
                abort();
            }
        }
        #endif
        Check();
    }

private:

    void Check()
    {

        {
            if (MetaMgr::Instance()->level0room_shua_robot_min_time >
                MetaMgr::Instance()->level0room_shua_robot_max_time) {
                abort();
            }
            if (MetaMgr::Instance()->level0room_shua_robot_min_num >
                MetaMgr::Instance()->level0room_shua_robot_max_num) {
                abort();
            }
            if (MetaMgr::Instance()->level0room_die_robot_min_time >
                MetaMgr::Instance()->level0room_die_robot_max_time) {
                abort();
            }
            if (MetaMgr::Instance()->level0room_die_robot_min_num >
                MetaMgr::Instance()->level0room_die_robot_max_num) {
                abort();
            }
        }

        {
            if (MetaMgr::Instance()->level1room_shua_robot_min_time >
                MetaMgr::Instance()->level1room_shua_robot_max_time) {
                abort();
            }
            if (MetaMgr::Instance()->level1room_shua_robot_min_num >
                MetaMgr::Instance()->level1room_shua_robot_max_num) {
                abort();
            }
            if (MetaMgr::Instance()->level1room_die_robot_min_time >
                MetaMgr::Instance()->level1room_die_robot_max_time) {
                abort();
            }
            if (MetaMgr::Instance()->level1room_die_robot_min_num >
                MetaMgr::Instance()->level1room_die_robot_max_num) {
                abort();
            }
        }

        {
            if (MetaMgr::Instance()->refresh_robot_min_num >
                MetaMgr::Instance()->refresh_robot_max_num) {
                abort();
            }
            if (MetaMgr::Instance()->refresh_robot_min_time >
                MetaMgr::Instance()->refresh_robot_max_time) {
                abort();
            }
        }
    }

    void BindToMetaData()
    {

        for (auto& meta : parameter_meta_list) {
            MetaData::Parameter& item = a8::FastAppend(parameter_list);
            item.i = &meta;
            item.Init();
            parameter_hash[item.i->param_name()] = &item;
        }

        {
            for (auto& meta : map_meta_list) {
                MetaData::Map& item = a8::FastAppend(map_list);
                item.i = &meta;
                item.Init();
                gamemap_hash[item.i->map_id()] = &item;
#if 1
                {
                    for (auto& tuple : item.template_list) {
                        auto itr = maptpl_meta_hash.find(std::get<0>(tuple));
                        if (itr == maptpl_meta_hash.end()) {
                            maptpl_meta_hash[std::get<0>(tuple)] = std::list<metatable::MapTplThingJson>();
                            itr = maptpl_meta_hash.find(std::get<0>(tuple));
                        } else {
                            itr->second.clear();
                        }
                        f8::ReadJsonMetaFile(res_path + std::get<0>(tuple) + ".json", itr->second);
                    }
                }
#endif
            }
            for (auto& pair : maptpl_meta_hash) {
                std::vector<MetaData::MapTplThing> things;
                for (auto& itr : pair.second) {
                    auto& thing = a8::FastAppend(things);
                    thing.i = &itr;
                    thing.Init();
                }
                maptpl_hash[pair.first] = things;
            }
        }

        for (auto& meta : safearea_meta_list) {
            MetaData::SafeArea& item = a8::FastAppend(safearea_list);
            item.i = &meta;
            if (App::Instance()->HasFlag(7)) {
                meta.set_wait_time(3);
                meta.set_shrink_speed(500);
            }
            safearea_hash[item.i->id()] = &item;
        }

        for (auto& meta : item_meta_list) {
            MetaData::Item& item = a8::FastAppend(item_list);
            item.i = &meta;
            item_hash[item.i->id()] = &item;
        }

        for (auto& meta : equip_meta_list) {
            if (meta.inventory_slot().empty()) {
                meta.set__inventory_slot(-1);
            } else {
                meta.set__inventory_slot(a8::XValue(meta.inventory_slot()));
            }
            MetaData::Equip& item = a8::FastAppend(equip_list);
            item.i = &meta;
            item.Init();
            equip_hash[item.i->id()] = &item;
            if (meta._inventory_slot() > -1) {
                equip_slot_hash[meta._inventory_slot()] = &item;
            }
        }

        for (auto& meta : player_meta_list) {
            MetaData::Player& item = a8::FastAppend(player_list);
            item.i = &meta;
            item.Init();
            player_hash[item.i->id()] = &item;
        }

        for (auto& meta : mapthing_meta_list) {
            MetaData::MapThing& item = a8::FastAppend(mapthing_list);
            item.i = &meta;
            mapthing_hash[item.i->thing_id()] = &item;
        }

        for (auto& meta : drop_meta_list) {
            MetaData::Drop& item = a8::FastAppend(drop_list);
            item.i = &meta;
            item.Init();
            drop_hash[item.i->drop_id()] = &item;
        }

        for (auto& meta : airdrop_meta_list) {
            MetaData::AirDrop& item = a8::FastAppend(airdrop_list);
            item.i = &meta;
        }

        for (auto& meta : airline_meta_list) {
            MetaData::AirLine& item = a8::FastAppend(airline_list);
            item.i = &meta;
            item.Init();
            {
                auto itr = airline_hash.find(item.i->map_id());
                if (itr != airline_hash.end()) {
                    itr->second.push_back(&item);
                } else {
                    airline_hash[item.i->map_id()] = std::vector<MetaData::AirLine*>({&item});
                }
            }
        }

        {
            for (auto& meta : building_meta_list) {
                MetaData::Building& item = a8::FastAppend(building_list);
                item.i = &meta;
                item.Init();
                building_hash[item.i->mapid()] = &item;
            }
        }

        for (auto& meta : dress_meta_list) {
            MetaData::Dress& item = a8::FastAppend(dress_list);
            item.i = &meta;
            dress_hash[item.i->id()] = &item;
            dress_vec.push_back(&item);
        }

        for (auto& meta : attr_meta_list) {
            MetaData::Attr& item = a8::FastAppend(attr_list);
            item.i = &meta;
            attr_id_hash[item.i->attr_id()] = &item;
            attr_name_hash[item.i->attr_ename()] = &item;
        }

        for (auto& meta : buff_meta_list) {
            if (!IsValidBuffEffect(meta.buff_effect())) {
                abort();
            }
            MetaData::Buff& item = a8::FastAppend(buff_list);
            item.i = &meta;
            item.Init();
            buff_hash[item.i->buff_id()] = &item;
        }

        for (auto& meta : skill_meta_list) {
            MetaData::Skill& item = a8::FastAppend(skill_list);
            item.i = &meta;
            item.Init();
            skill_hash[item.i->skill_id()] = &item;
        }

       for (auto& meta : rankreward_meta_list) {
            MetaData::RankReward& item = a8::FastAppend(rankreward_list);
            item.i = &meta;
            item.Init();
            rankreward_hash[item.i->rank()] = &item;
        }

       for (auto& meta : killreward_meta_list) {
           MetaData::KillReward& item = a8::FastAppend(killreward_list);
           item.i = &meta;
           killreward_hash[item.i->kill_num()] = &item;
       }

       for (auto& meta : killpoint_meta_list) {
           MetaData::KillPoint& item = a8::FastAppend(killpoint_list);
           item.i = &meta;
           killpoint_hash[item.i->kill_num()] = &item;
       }

       for (auto& meta : rankpoint_meta_list) {
           MetaData::RankPoint& item = a8::FastAppend(rankpoint_list);
           item.i = &meta;
           rankpoint_hash[item.i->rank()] = &item;
       }

       for (auto& meta : equipupgrade_meta_list) {
           MetaData::EquipUpgrade& item = a8::FastAppend(equipupgrade_list);
           item.i = &meta;
           item.Init();
           equipupgrade_hash[meta.id()] = &item;
       }

       for (auto& meta : robot_meta_list) {
           MetaData::Robot& item = a8::FastAppend(robot_list);
           item.i = &meta;
           item.Init();
           robot_hash[meta.id()] = &item;
       }

       for (auto& meta : ai_meta_list) {
           MetaData::AI& item = a8::FastAppend(ai_list);
           item.i = &meta;
           item.Init();
           ai_hash[meta.ai_level()] = &item;
       }
       for (int i = 1; i <= MAX_AI_LEVEL; ++i) {
           if (ai_hash.find(i) == ai_hash.end()) {
               abort();
           }
       }
    }

private:
    std::string res_path;
};

void MetaMgr::Init()
{
    loader_ = new MetaDataLoader();
    loader_->Load();
}

void MetaMgr::UnInit()
{
    delete loader_;
    loader_ = nullptr;
}

void MetaMgr::Reload()
{
    delete loader_;
    loader_ = nullptr;

    loader_ = new MetaDataLoader();
    loader_->Load();
}

int MetaMgr::GetSysParamAsInt(const std::string& param_name, int def_val)
{
    auto itr = loader_->parameter_hash.find(param_name);
    return itr != loader_->parameter_hash.end() ? itr->second->int_val: def_val;
}

double MetaMgr::GetSysParamAsFloat(const std::string& param_name, double def_val)
{
    auto itr = loader_->parameter_hash.find(param_name);
    return itr != loader_->parameter_hash.end() ? itr->second->float_val: def_val;
}

std::string MetaMgr::GetSysParamAsString(const std::string& param_name, const char* def_val)
{
    auto itr = loader_->parameter_hash.find(param_name);
    return itr != loader_->parameter_hash.end() ? itr->second->str_val: def_val;
}

MetaData::Map* MetaMgr::GetMap(int map_id)
{
    auto itr = loader_->gamemap_hash.find(map_id);
    return itr != loader_->gamemap_hash.end() ? itr->second : nullptr;
}

MetaData::MapThing* MetaMgr::GetMapThing(int mapthing_id)
{
    auto itr = loader_->mapthing_hash.find(mapthing_id);
    return itr != loader_->mapthing_hash.end() ? itr->second : nullptr;
}

MetaData::Player* MetaMgr::GetPlayer(int id)
{
    auto itr = loader_->player_hash.find(id);
    return itr != loader_->player_hash.end() ? itr->second : nullptr;
}

MetaData::Equip* MetaMgr::GetEquip(int id)
{
    auto itr = loader_->equip_hash.find(id);
    return itr != loader_->equip_hash.end() ? itr->second : nullptr;
}

MetaData::Equip* MetaMgr::GetEquipBySlotId(int slot_id)
{
    auto itr = loader_->equip_slot_hash.find(slot_id);
    return itr != loader_->equip_slot_hash.end() ? itr->second : nullptr;
}

MetaData::EquipUpgrade* MetaMgr::GetEquipUpgrade(int equip_id)
{
    auto itr = loader_->equipupgrade_hash.find(equip_id);
    return itr != loader_->equipupgrade_hash.end() ? itr->second : nullptr;
}

MetaData::Building* MetaMgr::GetBuilding(int building_id)
{
    auto itr = loader_->building_hash.find(building_id);
    return itr != loader_->building_hash.end() ? itr->second : nullptr;
}

MetaData::Drop* MetaMgr::GetDrop(int drop_id)
{
    auto itr = loader_->drop_hash.find(drop_id);
    return itr != loader_->drop_hash.end() ? itr->second : nullptr;
}

MetaData::SafeArea* MetaMgr::GetSafeArea(int area_id)
{
    auto itr = loader_->safearea_hash.find(area_id);
    return itr != loader_->safearea_hash.end() ? itr->second : nullptr;
}

std::vector<MetaData::MapTplThing>* MetaMgr::GetMapTplThing(std::string& map_name)
{
    auto itr = loader_->maptpl_hash.find(map_name);
    return itr != loader_->maptpl_hash.end() ? &itr->second : nullptr;
}

std::list<MetaData::AirDrop>& MetaMgr::GetAirDrops()
{
    return loader_->airdrop_list;
}

MetaData::AirLine* MetaMgr::RandAirLine(int map_id)
{
    auto itr = loader_->airline_hash.find(map_id);
    if (itr != loader_->airline_hash.end()) {
        return !itr->second.empty() ? itr->second.at(rand() % itr->second.size()) : nullptr;
    } else {
        return nullptr;
    }
}

MetaData::Skill* MetaMgr::GetSkill(int skill_id)
{
    auto itr = loader_->skill_hash.find(skill_id);
    return itr != loader_->skill_hash.end() ? itr->second : nullptr;
}

MetaData::Buff* MetaMgr::GetBuff(int buff_id)
{
    auto itr = loader_->buff_hash.find(buff_id);
    return itr != loader_->buff_hash.end() ? itr->second : nullptr;
}

MetaData::Attr* MetaMgr::GetAttrById(int attr_id)
{
    auto itr = loader_->attr_id_hash.find(attr_id);
    return itr != loader_->attr_id_hash.end() ? itr->second : nullptr;
}

MetaData::Attr* MetaMgr::GetAttrByName(const std::string& attr_name)
{
    auto itr = loader_->attr_name_hash.find(attr_name);
    return itr != loader_->attr_name_hash.end() ? itr->second : nullptr;
}

MetaData::Dress* MetaMgr::GetDress(int dress_id)
{
    auto itr = loader_->dress_hash.find(dress_id);
    return itr != loader_->dress_hash.end() ? itr->second : nullptr;
}

MetaData::RankReward* MetaMgr::GetRankReward(int rank)
{
    auto itr = loader_->rankreward_hash.find(rank);
    return itr != loader_->rankreward_hash.end() ? itr->second : nullptr;
}

MetaData::Dress* MetaMgr::RandDress()
{
    if (loader_->dress_vec.empty()) {
        return nullptr;
    }
    return loader_->dress_vec[rand() % loader_->dress_vec.size()];
}

float MetaMgr::GetRankRewardParam(int rank)
{
    auto itr = loader_->rankreward_hash.find(rank);
    return itr != loader_->rankreward_hash.end() ? itr->second->i->parameter() : 0.0f;
}

float MetaMgr::GetKillRewardParam(int kill_num)
{
    auto itr = loader_->killreward_hash.find(kill_num);
    return itr != loader_->killreward_hash.end() ? itr->second->i->parameter() : 0.0f;
}

int MetaMgr::GetRankPointParam1(int rank)
{
    auto itr = loader_->rankpoint_hash.find(rank);
    return itr != loader_->rankpoint_hash.end() ? itr->second->i->parameter() : 0;
}

int MetaMgr::GetRankPointParam2(int rank)
{
    auto itr = loader_->rankpoint_hash.find(rank);
    return itr != loader_->rankpoint_hash.end() ? itr->second->i->parameter2() : 0;
}

int MetaMgr::GetRankPointParam3(int rank)
{
    auto itr = loader_->rankpoint_hash.find(rank);
    return itr != loader_->rankpoint_hash.end() ? itr->second->i->parameter3() : 0;
}

int MetaMgr::GetKillPointParam1(int kill_num)
{
    auto itr = loader_->killpoint_hash.find(kill_num);
    return itr != loader_->killpoint_hash.end() ? itr->second->i->parameter() : 0;
}

int MetaMgr::GetKillPointParam2(int kill_num)
{
    auto itr = loader_->killpoint_hash.find(kill_num);
    return itr != loader_->killpoint_hash.end() ? itr->second->i->parameter2() : 0;
}

MetaData::Robot* MetaMgr::RandRobot(std::set<int>& refreshed_robot_set)
{
    int try_count = 0;
    while (true) {
        MetaData::Robot& tmp_robot_meta = loader_->robot_list[rand() % loader_->robot_list.size()];
        if (refreshed_robot_set.find(tmp_robot_meta.i->id()) == refreshed_robot_set.end()) {
            return &tmp_robot_meta;
        }
        ++try_count;
        if (try_count > 3000) {
            return nullptr;
        }
    }
}

MetaData::AI* MetaMgr::GetAI(int ai_level)
{
    auto itr = loader_->ai_hash.find(ai_level);
    return itr != loader_->ai_hash.end() ? itr->second : nullptr;
}