#include "precompile.h"

#include <a8/mutable_xobject.h>

#include "framemaker.h"
#include "human.h"
#include "room.h"
#include "typeconvert.h"
#include "metamgr.h"
#include "car.h"
#include "app.h"
#include "perfmonitor.h"

void FrameMaker::Debug_FullObject(Human* hum)
{
    #if 0
    if (!hum->GetFrameData().new_objects.empty()) {
        a8::MutableXObject* out_data = a8::MutableXObject::NewArray();
        for (auto& pair : hum->GetFrameData().new_objects) {
            a8::MutableXObject* xobj = a8::MutableXObject::NewObject();
            xobj->SetVal("uniid", pair.first);
            if (pair.second.Get()) {
                xobj->SetVal("matched", 1);
                xobj->SetVal("type", pair.second.Get()->GetEntityType());
                xobj->SetVal("pos", a8::Format("%d,%d",
                                               {pair.second.Get()->GetPos().x,
                                                pair.second.Get()->GetPos().y}));
            } else {
                xobj->SetVal("matched", 0);
                xobj->SetVal("type", 0);
                xobj->SetVal("pos", a8::Format("%d,%d",
                                               {0,
                                                0}));
            }
            out_data->Push(*xobj);
        }
        hum->TraverseObservers
            (
             [&out_data] (Human* hum, bool& stop)
             {
                 if (hum->IsPlayer()) {
                     hum->SendDebugMsg(a8::Format("view_debug frameno:%d server_full_obj:%s",
                                                  {
                                                   hum->room->GetFrameNo() / 2,
                                                   out_data->ToJsonStr()
                                                  }));
                 }
             });
        delete out_data;
    }
    #endif
}

void FrameMaker::Debug_OutObject(Human* hum)
{
    #if 0
    if (!hum->GetFrameData().out_objects.empty()) {
        a8::MutableXObject* out_data = a8::MutableXObject::NewArray();
        for (auto& itr : hum->GetFrameData().out_objects) {
            int uniid = itr;
            a8::MutableXObject* xobj = a8::MutableXObject::NewObject();
            xobj->SetVal("uniid", uniid);
            Entity* entity = hum->room->GetEntityByUniId(uniid);
            if (entity) {
                xobj->SetVal("matched", 1);
                xobj->SetVal("pos", a8::Format("%d,%d", {entity->GetPos().x, entity->GetPos().y}));
            } else {
                xobj->SetVal("matched", 0);
                xobj->SetVal("pos", a8::Format("%d,%d", {0, 0}));
            }
            out_data->Push(*xobj);
        }
        hum->TraverseObservers
            (
             [&out_data] (Human* hum, bool& stop)
             {
                 if (hum->IsPlayer()) {
                     hum->SendDebugMsg(a8::Format("view_debug frameno:%d server_out_obj:%s",
                                                  {
                                                   hum->room->GetFrameNo() / 2,
                                                   out_data->ToJsonStr()
                                                  }));
                 }
             });
        delete out_data;
    }
    #endif
}

cs::SMUpdate* FrameMaker::MakeUpdateMsg(Human* hum)
{
    FrameData* framedata = &hum->GetFrameData();
    cs::SMUpdate* msg = new cs::SMUpdate;
    Room* room = hum->room;

    PreProcess(msg, room, hum, framedata);
    SerializeLootObjects(msg, room, hum, framedata);
    SerializeMapBlockObjects(msg, room, hum, framedata);
    SerializeNewObjects(msg, room, hum, framedata);
    SerializePartObjects(msg, room, hum, framedata);
    SerializeDelObjects(msg, room, hum, framedata);
    SerializeOutObjects(msg, room, hum, framedata);
    SerializeShots(msg, room, hum, framedata);
    SerializeEmotes(msg, room, hum, framedata);
    SerializeBullets(msg, room, hum, framedata);
    SerializeSmokes(msg, room, hum, framedata);
    SerializePlaySkills(msg, room, hum, framedata);
    SerializeExplosions(msg, room, hum, framedata);
    SerializeChgedBuffs(msg, room, hum, framedata);
    SerializeChgedBulletNums(msg, room, hum, framedata);
    SerializeChgedHps(msg, room, hum, framedata);
    SerializeChgedSkillCds(msg, room, hum, framedata);
    SerializeChgedSkillCurrTimes(msg, room, hum, framedata);
    SerializeChgedItems(msg, room, hum, framedata);
    SerializeChgedWeaponAmmo(msg, room, hum, framedata);
    SerializeDeadAliveObjs(msg, room, hum, framedata);
    SerializeChgedCars(msg, room, hum, framedata);
    SerializeChgedProps(msg, room, hum, framedata);
    SerializeDelBullets(msg, room, hum, framedata);
    PostProcess(msg, room, hum, framedata);

    return msg;
}

void FrameMaker::PreProcess(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    {
        msg->set_frameno(hum->room->GetFrameNo() / 2);
        if (hum->room->GetGasData().gas_mode == GasJump) {
            cs::MFPlane* p = msg->mutable_plane();
            TypeConvert::ToPb(hum->room->plane.start_point, p->mutable_start_point());
            TypeConvert::ToPb(hum->room->plane.end_point, p->mutable_end_point());
            TypeConvert::ToPb(hum->room->plane.curr_pos, p->mutable_pos());
        }
    }
    {
        size_t chg_prop_size = framedata->chged_bullet_nums_.size() +
            framedata->chged_hps_.size() * 2 +
            framedata->chged_skillcds_.size() +
            framedata->chged_skill_curr_times_.size() +
            framedata->chged_items_.size() +
            framedata->chged_weapon_ammo_.size() +
            framedata->chged_cars_.size() +
            framedata->chged_props_.size();
        if (chg_prop_size > 0) {
            msg->mutable_chged_property_list()->Reserve(chg_prop_size);
        }
    }
}

void FrameMaker::PostProcess(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    if (room->frame_event.airdrops_.size() > 0) {
        *msg->mutable_airdrop() = room->frame_event.airdrops_.Get(0);
    }
    if (room->frame_event.airraids_.size() > 0) {
        *msg->mutable_airraid() = room->frame_event.airraids_.Get(0);
    }
    if (room->GetGasData().gas_mode == GasMoving) {
        msg->set_gas_progress(room->GetGasData().gas_progress);
        TypeConvert::ToPb(room->GetGasData().pos_old, msg->mutable_gas_pos_old());
    }
    if (room->GetFrameNo() - room->AliveCountChgFrameNo() <= 4 ||
        room->GetFrameNo() - hum->join_frameno <= 2) {
        msg->set_alive_count(room->AliveCount());
    }
}

void FrameMaker::SerializeLootObjects(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{

}

void FrameMaker::SerializeMapBlockObjects(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{

    for (auto itr = framedata->block_objects.begin(); itr != framedata->block_objects.end(); ) {
        if (framedata->new_objects.size() >= 200) {
            break;
        }
        framedata->new_objects[itr->first] = itr->second;
        itr = framedata->block_objects.erase(itr);
    }
}

void FrameMaker::SerializeNewObjects(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    if (!framedata->new_objects.empty()) {
#ifdef DEBUG
        Debug_FullObject(hum);
#endif
        msg->mutable_full_objects()->Reserve(framedata->new_objects.size());
        if (framedata->new_objects.size() > PerfMonitor::Instance()->max_full_objects_num) {
            PerfMonitor::Instance()->max_full_objects_num = framedata->new_objects.size();
        }
        for (auto& pair : framedata->new_objects) {
            Entity* e = pair.second.Get();
            if (!e) {
                continue;
            }
            if (e != hum &&
                e->GetEntityType() == ET_Player &&
                ((Human*)e)->HasBuffEffect(kBET_Fly)){
                continue;
            }
            if ((hum->IsPlayer() || hum->HasObserver()) && e->CanSeeMe(hum)) {
                e->FillMFObjectFull(room, (Human*)hum, msg->add_full_objects());
            }
#ifdef DEBUG
            if (App::Instance()->HasFlag(2) && e->GetEntityType() == ET_Player) {
                hum->room->BroadcastDebugMsg(a8::Format("投放 %d pos:%d,%d 出现",
                                                        {
                                                         e->GetUniId(),
                                                         e->GetPos().x,
                                                         e->GetPos().y,
                                                        }));
            }
#endif
        }
    }
}

void FrameMaker::SerializePartObjects(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    if (!framedata->part_objects.empty()) {
        msg->mutable_part_objects()->Reserve(framedata->part_objects.size());
        if (framedata->part_objects.size() > PerfMonitor::Instance()->max_part_objects_num) {
            PerfMonitor::Instance()->max_part_objects_num = framedata->part_objects.size();
        }
        int deleted_uniid = 0;
        for (auto& pair : framedata->part_objects) {
            Entity* entity = pair.second.object.Get();
            if (!entity) {
#ifdef DEBUG
                abort();
#endif
                deleted_uniid = pair.first;
                continue;
            }
            if (entity->IsDead(room) &&
                hum->room->GetFrameNo() - entity->GetDeadFrameNo(room) > 10) {
                continue;
            } else {
                if (room->GetGasData().gas_mode == GasJump &&
                    entity != hum &&
                    entity->GetEntityType() == ET_Player &&
                    ((Human*)entity)->HasBuffEffect(kBET_Fly)) {
                    continue;
                }
            }
#if 0
            if (((Human*)hum)->GetPos().ManhattanDistance(entity->GetPos()) > VIEW_RANGE + 300)  {
                continue;
            }
#endif
            entity->FillMFObjectPart(room, (Human*)hum, msg->add_part_objects());
        }
        if (deleted_uniid > 0) {
            framedata->part_objects.erase(deleted_uniid);
        }
    }
}

void FrameMaker::SerializeDelObjects(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    if (!framedata->del_objects.empty()) {
        msg->mutable_del_objids()->Reserve(framedata->del_objects.size());
        for (auto& itr : framedata->del_objects) {
            msg->add_del_objids(itr);
#ifdef DEBUG
            if (App::Instance()->HasFlag(2)) {
                room->BroadcastDebugMsg(a8::Format("投放 删除对象%d",
                                                   {
                                                    itr
                                                   }));
            }
#endif
        }
    }
}

void FrameMaker::SerializeOutObjects(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    if (!framedata->out_objects.empty()) {
        msg->mutable_out_objids()->Reserve(framedata->out_objects.size());
#ifdef DEBUG
        Debug_OutObject(hum);
#endif
        for (auto& itr : framedata->out_objects) {
            msg->add_out_objids(itr);
#ifdef DEBUG
            if (App::Instance()->HasFlag(2)) {
                room->BroadcastDebugMsg(a8::Format("投放 移除视野对象%d",
                                                   {
                                                    itr
                                                   }));
            }
#endif
        }
    }
}

void FrameMaker::SerializeShots(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    if (!framedata->shots_.empty()) {
        msg->mutable_shots()->Reserve(framedata->shots_.size());
        for (size_t idx : framedata->shots_) {
            if (idx < room->frame_event.shots_.size()) {
                auto& tuple = room->frame_event.shots_[idx];
                if (std::get<0>(tuple).Get() && hum->CanSee(std::get<0>(tuple).Get())) {
                    *msg->add_shots() = std::get<1>(tuple);
                } else {
#ifdef DEBUG1
                    abort();
#endif
                }
            }
        }
    }
}

void FrameMaker::SerializeEmotes(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    for (size_t idx : framedata->emotes_) {
        msg->mutable_emotes()->Reserve(framedata->emotes_.size());
        if (idx < room->frame_event.emotes_.size()) {
            auto& tuple = room->frame_event.emotes_[idx];
            if (std::get<0>(tuple).Get() && hum->CanSee(std::get<0>(tuple).Get())) {
                *msg->add_emotes() = std::get<1>(tuple);
            }
        }
    }
}

void FrameMaker::SerializeBullets(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    if (!framedata->bullets_.empty()) {
        msg->mutable_bullets()->Reserve(framedata->bullets_.size());
        if (framedata->bullets_.size() > PerfMonitor::Instance()->max_bullet_num) {
            PerfMonitor::Instance()->max_bullet_num = framedata->bullets_.size();
        }
        for (size_t idx : framedata->bullets_) {
            if (idx < room->frame_event.bullets_.size()) {
                auto& tuple = room->frame_event.bullets_[idx];
                if (std::get<0>(tuple).Get() && hum->CanSee(std::get<0>(tuple).Get())) {
                    *msg->add_bullets() = std::get<1>(tuple);
                }
            }
        }
    }
}

void FrameMaker::SerializeSmokes(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    for (size_t idx : framedata->smokes_) {
        msg->mutable_smokes()->Reserve(framedata->smokes_.size());
        if (idx < room->frame_event.smokes_.size()) {
            auto& tuple = room->frame_event.smokes_[idx];
            if (std::get<0>(tuple).Get() && hum->CanSee(std::get<0>(tuple).Get())) {
                *msg->add_smokes() = std::get<1>(tuple);
            }
        }
    }
}

void FrameMaker::SerializePlaySkills(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    for (size_t idx : framedata->play_skills_) {
        msg->mutable_play_skill_list()->Reserve(framedata->play_skills_.size());
        if (idx < room->frame_event.play_skills_.size()) {
            auto& tuple = room->frame_event.play_skills_[idx];
            if (std::get<0>(tuple).Get() && hum->CanSee(std::get<0>(tuple).Get())) {
                *msg->add_play_skill_list() = std::get<1>(tuple);
            }
        }
    }
}

void FrameMaker::SerializeExplosions(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    for (size_t idx : framedata->explosions_) {
        msg->mutable_explosions()->Reserve(framedata->explosions_.size());
        if (idx < room->frame_event.explosions_.size()) {
            auto& tuple = room->frame_event.explosions_[idx];
            *msg->add_explosions() = std::get<1>(tuple);
#ifdef DEBUG1
            a8::XPrintf("AddExplosion %d, %s pos=%d,%d effect:%d\n",
                        {
                         hum->GetUniId(),
                         hum->name,
                         std::get<1>(tuple).pos().x(),
                         std::get<1>(tuple).pos().y(),
                         std::get<1>(tuple).effect()
                        });
#endif
        }
    }
}

void FrameMaker::SerializeChgedBuffs(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    if (!framedata->chged_buffs_.empty()) {
        msg->mutable_chged_buff_list()->Reserve(framedata->chged_buffs_.size());
        for (size_t idx : framedata->chged_buffs_) {
            if (idx < room->frame_event.chged_buffs_.size()) {
                auto p = msg->add_chged_buff_list();
                *p = std::get<1>(room->frame_event.chged_buffs_[idx]);
            }
        }
    }
}

void FrameMaker::SerializeChgedBulletNums(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    if (!framedata->chged_bullet_nums_.empty()) {
        for (size_t idx : framedata->chged_bullet_nums_) {
            if (idx < room->frame_event.chged_bullet_nums_.size()) {
                CreatureWeakPtr& target = room->frame_event.chged_bullet_nums_[idx];
                if (target.Get()->GetCurrWeapon()) {
                    auto p = msg->add_chged_property_list();
                    p->set_obj_id(target.Get()->GetUniId());
                    p->set_property_type(kPropBulletNum);
                    p->set_value(target.Get()->GetCurrWeapon()->ammo);
                }
            }
        }
    }
}

void FrameMaker::SerializeChgedHps(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    for (size_t idx : framedata->chged_hps_) {
        if (idx < room->frame_event.chged_hps_.size()) {
            CreatureWeakPtr& target = room->frame_event.chged_hps_[idx];
            if (target.Get() && hum->CanSee(target.Get())) {
                {
                    auto p = msg->add_chged_property_list();
                    p->set_obj_id(target.Get()->GetUniId());
                    p->set_property_type(kPropHp);
                    p->set_value(target.Get()->GetHP());
                }
                {
                    auto p = msg->add_chged_property_list();
                    p->set_obj_id(target.Get()->GetUniId());
                    p->set_property_type(kPropMaxHp);
                    p->set_value(target.Get()->GetMaxHP());
                }
            }
        }
    }
}

void FrameMaker::SerializeChgedSkillCds(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    if (!framedata->chged_skillcds_.empty()) {
        for (size_t idx : framedata->chged_skillcds_) {
            if (idx < room->frame_event.chged_skillcds_.size()) {
                auto tuple = room->frame_event.chged_skillcds_[idx];
                CreatureWeakPtr target = std::get<0>(tuple);
                int skill_id = std::get<1>(tuple);
                int left_time = std::get<2>(tuple);
                if (target.Get()) {
                    auto p = msg->add_chged_property_list();
                    p->set_obj_id(target.Get()->GetUniId());
                    p->set_property_type(kPropSkillLeftTime);
                    p->set_property_subtype(skill_id);
                    p->set_value(left_time);
                }
            }
        }
    }
}

void FrameMaker::SerializeChgedSkillCurrTimes(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    for (size_t idx : framedata->chged_skill_curr_times_) {
        if (idx < room->frame_event.chged_skill_curr_times_.size()) {
            auto tuple = room->frame_event.chged_skill_curr_times_[idx];
            CreatureWeakPtr& target = std::get<0>(tuple);
            int skill_id = std::get<1>(tuple);
            int curr_times = std::get<2>(tuple);
            if (target.Get()) {
                auto p = msg->add_chged_property_list();
                p->set_obj_id(target.Get()->GetUniId());
                p->set_property_type(kPropSkillCurrTimes);
                p->set_property_subtype(skill_id);
                p->set_value(curr_times);
            }
        }
    }
}

void FrameMaker::SerializeChgedItems(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    for (size_t idx : framedata->chged_items_) {
        if (idx < room->frame_event.chged_items_.size()) {
            auto& tuple = room->frame_event.chged_items_[idx];
            {
                auto p = msg->add_chged_property_list();
                p->set_obj_id((std::get<0>(tuple)).Get()->GetUniId());
                p->set_property_type(kPropItem);
                p->set_property_subtype(std::get<1>(tuple));
                p->set_value(std::get<2>(tuple));
            }
        }
    }
}

void FrameMaker::SerializeChgedWeaponAmmo(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    for (size_t idx : framedata->chged_weapon_ammo_) {
        if (idx < room->frame_event.chged_weapon_ammo_.size()) {
            auto& tuple = room->frame_event.chged_weapon_ammo_[idx];
            {
                auto p = msg->add_chged_property_list();
                p->set_obj_id((std::get<0>(tuple)).Get()->GetUniId());
                p->set_property_type(kPropWeaponAmmo);
                p->set_property_subtype(std::get<1>(tuple));
                p->set_value(std::get<2>(tuple));
            }
        }
    }
}

void FrameMaker::SerializeDeadAliveObjs(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    if (!framedata->dead_alive_objs_.empty()) {
        msg->mutable_dead_alive_objs()->Reserve(framedata->dead_alive_objs_.size());
        for (size_t idx : framedata->dead_alive_objs_) {
            if (idx < room->frame_event.dead_alive_objs_.size()) {
                auto p = msg->add_dead_alive_objs();
                p->add_values(std::get<0>(room->frame_event.dead_alive_objs_[idx]));
                p->add_values(std::get<1>(room->frame_event.dead_alive_objs_[idx]));
                p->add_values(std::get<2>(room->frame_event.dead_alive_objs_[idx]));
            }
        }
    }
}

void FrameMaker::SerializeChgedCars(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    for (size_t idx : framedata->chged_cars_) {
        if (idx < room->frame_event.chged_cars_.size()) {
            CreatureWeakPtr& target = room->frame_event.chged_cars_[idx];
            if (target.Get() && target.Get()->IsHuman() && hum->CanSee(target.Get())) {
                auto p = msg->add_chged_property_list();
                p->set_obj_id(target.Get()->GetUniId());
                p->set_property_type(kPropCar);
                if (target.Get()->AsHuman()->GetCar()) {
                    p->set_property_subtype(target.Get()->AsHuman()->GetCar()->meta->i->id());
                    p->set_value(target.Get()->AsHuman()->GetSeat());
                } else {
                    p->set_property_subtype(0);
                    p->set_value(0);
                }
            }
        }
    }
}

void FrameMaker::SerializeChgedProps(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    if (!framedata->chged_props_.empty()) {
        msg->mutable_chged_property_list()->Reserve(framedata->chged_props_.size());
        for (size_t idx : framedata->chged_props_) {
            if (idx < room->frame_event.chged_props_.size()) {
                auto& p = room->frame_event.chged_props_[idx];
                auto& target = std::get<0>(p);
                if (target.Get()) {
                    *msg->add_chged_property_list() = std::get<1>(p);
                }
            }
        }
    }
}

void FrameMaker::SerializeDelBullets(cs::SMUpdate* msg, Room* room, Human* hum, FrameData* framedata)
{
    if (!framedata->del_bullets_.empty()) {
        msg->mutable_del_bullets()->Reserve(framedata->del_bullets_.size());
        for (size_t idx : framedata->del_bullets_) {
            if (idx < room->frame_event.del_bullets_.size()) {
                int bullet_uniid = room->frame_event.del_bullets_[idx];
                msg->add_del_bullets(bullet_uniid);
            }
        }
    }
}