#include "precompile.h"

#include "frameevent.h"
#include "human.h"
#include "bullet.h"
#include "typeconvert.h"
#include "buff.h"
#include "effect.h"
#include "human.h"
#include "room.h"
#include "car.h"
#include "frameeventdata.h"

#include "mt/Equip.h"

void FrameEvent::AddAirDrop(int appear_time, int box_id, const glm::vec3& box_pos)
{
    cs::MFAirDrop* airdrop = room->frame_event_data->airdrops_.Add();
    airdrop->set_appear_time(appear_time);
    airdrop->set_box_id(box_id);
    TypeConvert::ToPb(box_pos, airdrop->mutable_pos());
}

void FrameEvent::AddAirRaid(int appear_time, const glm::vec3& raid_pos, float raid_rad, int continue_time)
{
    cs::MFAirRaid* airraid = room->frame_event_data->airraids_.Add();
    airraid->set_appear_time(appear_time);
    airraid->set_rad(raid_rad);
    airraid->set_continue_time(continue_time);
    TypeConvert::ToPb(raid_pos, airraid->mutable_pos());
}

void FrameEvent::AddEmote(CreatureWeakPtr& sender, int emote_id)
{
    {
        auto& tuple = a8::FastAppend(room->frame_event_data->emotes_);
        std::get<0>(tuple) = sender;
        auto& p = std::get<1>(tuple);

        p.set_emote_id(emote_id);
        p.set_player_id(sender.Get()->GetUniId());
    }
    {
        int emote_idx = room->frame_event_data->emotes_.size() - 1;
        sender.Get()->TraverseAllLayerHumanList
            (
             [emote_idx] (Human* hum, bool& stop)
             {
                hum->GetFrameData().emotes_.push_back(emote_idx);
             });
    }
}

void FrameEvent::AddShot(CreatureWeakPtr& sender)
{
    {
        auto& tuple = a8::FastAppend(room->frame_event_data->shots_);
        std::get<0>(tuple) = sender;
        auto& p = std::get<1>(tuple);

        p.set_player_id(sender.Get()->GetUniId());
        if (sender.Get()->second_weapon.meta) {
            sender.Get()->second_weapon.ToPB(sender.Get(), p.mutable_weapon());
        } else {
            sender.Get()->GetCurrWeapon()->ToPB(sender.Get(), p.mutable_weapon());
        }
        if (sender.Get()->IsCar()) {
            p.set_hole(sender.Get()->shot_hole);
        }
        if (sender.Get()->aiming) {
            p.set_aiming(1);
        }
    }
    {
        int shot_idx = room->frame_event_data->shots_.size() - 1;
        sender.Get()->TraverseAllLayerHumanList
            (
             [shot_idx] (Human* hum, bool& stop)
             {
                hum->GetFrameData().shots_.push_back(shot_idx);
             });
    }
}

void FrameEvent::AddBullet(int bullet_uniid,
                           CreatureWeakPtr& sender,
                           const mt::Equip* weapon_meta,
                           int weapon_lv,
                           const glm::vec3& born_pos,
                           const glm::vec3& dir,
                           float fly_distance,
                           int trace_target_id,
                           int hand,
                           std::shared_ptr<std::set<int>> reporter_list)
{
    {
        auto& tuple = a8::FastAppend(room->frame_event_data->bullets_);
        std::get<0>(tuple) = sender;
        auto& p = std::get<1>(tuple);

        p.set_player_id(sender.Get()->GetUniId());
        p.set_bullet_uniid(bullet_uniid);
        p.set_bullet_id(weapon_meta->use_bullet());
        TypeConvert::ToPb(born_pos, p.mutable_pos());
        TypeConvert::ToPb(dir, p.mutable_dir());
        p.set_gun_id(weapon_meta->id());
        p.set_gun_lv(weapon_lv);
        p.set_fly_distance(fly_distance);
        if (trace_target_id) {
            p.set_trace_target_uniid(trace_target_id);
        }
        p.set_hand(hand);
        if (reporter_list) {
            for (int reporter : *reporter_list.get()) {
                p.add_reporter_list(reporter);
            }
        }
    }
    {
        int bullet_idx = room->frame_event_data->bullets_.size() - 1;
        sender.Get()->TraverseAllLayerHumanList
            (
             [bullet_idx, &sender] (Human* hum, bool& stop)
             {
#ifdef DEBUG1
                 // 999
                 if (!hum->InPartObjects(sender.Get())) {
                     A8_ABORT();
                 }
#endif
                hum->GetFrameData().bullets_.push_back(bullet_idx);
             });
    }
}

void FrameEvent::RemoveBullet(glm::vec3 pos, int bullet_uniid)
{
    room->frame_event_data->del_bullets_.push_back(bullet_uniid);
    {
        std::set<GridCell*> grid_list;
        room->grid_service->GetAllCellsByXy
            (
             room,
             pos.x,
             pos.y,
             grid_list
             );

        int bullet_idx = room->frame_event_data->del_bullets_.size() - 1;
        room->grid_service->TraverseAllLayerHumanList
            (
             room->GetRoomIdx(),
             grid_list,
             [bullet_idx] (Human* hum, bool& stop)
             {
                 hum->GetFrameData().del_bullets_.push_back(bullet_idx);
             });
    }
}

void FrameEvent::AddExplosion(Bullet* bullet, int item_id, Position bomb_pos)
{
    AddExplosionEx(bullet->sender, item_id, bomb_pos, 0);
}

void FrameEvent::AddExplosionEx(CreatureWeakPtr& sender, int item_id, Position bomb_pos, int effect)
{
    #if 0
    if (!sender.Get()) {
        return;
    }
    #endif
    {
        auto& tuple = a8::FastAppend(room->frame_event_data->explosions_);
        if (sender.Get()) {
            std::get<0>(tuple).Attach(sender.Get());
        }
        auto& p = std::get<1>(tuple);

        p.set_item_id(item_id);
        TypeConvert::ToPb(bomb_pos, p.mutable_pos());
        #if 0
        p.set_player_id(sender.Get()->GetUniId());
        #endif
        p.set_effect(effect);
    }
    {
        std::set<GridCell*> grid_list;
        room->grid_service->GetAllCellsByXy
            (
             room,
             bomb_pos.GetX(),
             bomb_pos.GetZ(),
             grid_list
             );

        int explosion_idx = room->frame_event_data->explosions_.size() - 1;
        room->grid_service->TraverseAllLayerHumanList
            (
             room->GetRoomIdx(),
             grid_list,
             [explosion_idx] (Human* hum, bool& stop)
             {
                hum->GetFrameData().explosions_.push_back(explosion_idx);
             });
    }
}

void FrameEvent::AddBulletNumChg(CreatureWeakPtr& sender)
{
    room->frame_event_data->chged_bullet_nums_.push_back(sender);
    int idx = room->frame_event_data->chged_bullet_nums_.size() - 1;
    if (sender.Get()->IsHuman()) {
        sender.Get()->AsHuman()->GetFrameData().chged_bullet_nums_.push_back(idx);
    } else {
        sender.Get()->TraverseAllLayerHumanList
            (
             [idx] (Human* hum, bool& stop)
             {
                 hum->GetFrameData().chged_bullet_nums_.push_back(idx);
             });
    }
}

void FrameEvent::AddPlaySkill(CreatureWeakPtr& sender, int skill_id)
{
    if (!sender.Get()) {
        return;
    }
    {
        auto& tuple = a8::FastAppend(room->frame_event_data->play_skills_);
        std::get<0>(tuple).Attach(sender.Get());
        auto& p = std::get<1>(tuple);
        p.set_obj_uniid(sender.Get()->GetUniId());
        p.set_skill_id(skill_id);
    }
    {
        int idx = room->frame_event_data->play_skills_.size() - 1;
        sender.Get()->TraverseAllLayerHumanList
            (
             [idx] (Human* hum, bool& stop)
             {
                 hum->GetFrameData().play_skills_.push_back(idx);
             });
    }
}

void FrameEvent::AddHpChg(CreatureWeakPtr& sender)
{
    room->frame_event_data->chged_hps_.push_back(sender);
    int idx = room->frame_event_data->chged_hps_.size() - 1;
    sender.Get()->TraverseAllLayerHumanList
        (
         [idx] (Human* hum, bool& stop)
         {
            hum->GetFrameData().chged_hps_.push_back(idx);
         });
}

void FrameEvent::AddWeaponAmmoChg(CreatureWeakPtr& sender)
{
    if (sender.Get()->GetCurrWeapon()) {
        room->frame_event_data->chged_weapon_ammo_.push_back
            (
             std::make_tuple(sender,
                             sender.Get()->GetCurrWeapon()->weapon_idx,
                             sender.Get()->GetCurrWeapon()->ammo,
                             sender.Get()->GetCurrWeapon()->GetClipVolume(sender.Get())
                             )
             );
        int idx = room->frame_event_data->chged_weapon_ammo_.size() - 1;
        if (sender.Get()->IsHuman()) {
            sender.Get()->AsHuman()->GetFrameData().chged_weapon_ammo_.push_back(idx);
        } else {
            sender.Get()->TraverseAllLayerHumanList
                (
                 [idx] (Human* hum, bool& stop)
                 {
                     hum->GetFrameData().chged_weapon_ammo_.push_back(idx);
                 });
        }
    }
}

void FrameEvent::AddBuff(CreatureWeakPtr& sender, Buff* buff)
{
    if (!buff->IsValid()) {
        return;
    }
    {
        cs::MFBuffChg chged_buff_pb;
        chged_buff_pb.set_obj_id(sender.Get()->GetUniId());
        chged_buff_pb.set_chg(0);
        buff->FillMFBuff(chged_buff_pb.mutable_buff());
        room->frame_event_data->chged_buffs_.push_back(std::make_tuple(sender, chged_buff_pb));
    }
    {
        int idx = room->frame_event_data->chged_buffs_.size() - 1;
        sender.Get()->TraverseAllLayerHumanList
            (
             [idx] (Human* hum, bool& stop)
             {
                 hum->GetFrameData().chged_buffs_.push_back(idx);
             });
    }
}

void FrameEvent::RemoveBuff(CreatureWeakPtr& sender, Buff* buff)
{
    if (!buff->IsValid()) {
        return;
    }
    {
        cs::MFBuffChg chged_buff_pb;
        chged_buff_pb.set_obj_id(sender.Get()->GetUniId());
        chged_buff_pb.set_chg(1);
        buff->FillMFBuff(chged_buff_pb.mutable_buff());
        #if 0
        chged_buff_pb.mutable_buff()->set_buff_id(buff_id);
        #endif
        room->frame_event_data->chged_buffs_.push_back(std::make_tuple(sender, chged_buff_pb));
    }
    {
        int idx = room->frame_event_data->chged_buffs_.size() - 1;
        sender.Get()->TraverseAllLayerHumanList
            (
             [idx] (Human* hum, bool& stop)
             {
                hum->GetFrameData().chged_buffs_.push_back(idx);
             });
    }
}

void FrameEvent::AddEffect(CreatureWeakPtr& sender, Effect* effect)
{
    {
        cs::MFEffectChg chged_effect_pb;
        chged_effect_pb.set_obj_id(sender.Get()->GetUniId());
        chged_effect_pb.set_chg(0);
        effect->FillMFEffect(chged_effect_pb.mutable_effect());
        room->frame_event_data->chged_effects_.push_back(std::make_tuple(sender, chged_effect_pb));
    }
    {
        int idx = room->frame_event_data->chged_effects_.size() - 1;
        sender.Get()->TraverseAllLayerHumanList
            (
             [idx] (Human* hum, bool& stop)
             {
                 hum->GetFrameData().chged_effects_.push_back(idx);
             });
    }
}

void FrameEvent::RemoveEffect(CreatureWeakPtr& sender, Effect* effect)
{
    {
        cs::MFEffectChg chged_effect_pb;
        chged_effect_pb.set_obj_id(sender.Get()->GetUniId());
        chged_effect_pb.set_chg(1);
        effect->FillMFEffect(chged_effect_pb.mutable_effect());
        room->frame_event_data->chged_effects_.push_back(std::make_tuple(sender, chged_effect_pb));
    }
    {
        int idx = room->frame_event_data->chged_effects_.size() - 1;
        sender.Get()->TraverseAllLayerHumanList
            (
             [idx] (Human* hum, bool& stop)
             {
                hum->GetFrameData().chged_effects_.push_back(idx);
             });
    }
}

void FrameEvent::AddSkillCdChg(CreatureWeakPtr sender, int skill_id, int left_time)
{
    if (sender.Get()) {
        if (sender.Get()->IsHuman()) {
            room->frame_event_data->chged_skillcds_.push_back(std::make_tuple(sender, skill_id, left_time));
            int idx = room->frame_event_data->chged_skillcds_.size() - 1;
            ((Human*)sender.Get())->GetFrameData().chged_skillcds_.push_back(idx);
        } else if (sender.Get()->IsCar() && sender.Get()->AsCar()->GetDriver()) {
            Car* car = sender.Get()->AsCar();
            room->frame_event_data->chged_skillcds_.push_back
                (std::make_tuple(car->GetWeakPtrRef(), skill_id, left_time));
            int idx = room->frame_event_data->chged_skillcds_.size() - 1;
            car->GetDriver()->GetFrameData().chged_skillcds_.push_back(idx);
        }
    }
}

void FrameEvent::AddSkillCurrTimesChg(CreatureWeakPtr sender, int skill_id, int curr_times)
{
    if (sender.Get() && sender.Get()->IsHuman()) {
        room->frame_event_data->chged_skill_curr_times_.push_back(std::make_tuple(sender, skill_id, curr_times));
        int idx = room->frame_event_data->chged_skill_curr_times_.size() - 1;
        ((Human*)sender.Get())->GetFrameData().chged_skill_curr_times_.push_back(idx);
    }
}

void FrameEvent::AddItemChg(CreatureWeakPtr& sender, int item_id, int item_num)
{
    if (sender.Get()->IsHuman()) {
        room->frame_event_data->chged_items_.push_back(std::make_tuple(sender, item_id, item_num));
        int idx = room->frame_event_data->chged_items_.size() - 1;
        ((Human*)sender.Get())->GetFrameData().chged_items_.push_back(idx);
    }
}

void FrameEvent::AddDead(CreatureWeakPtr& sender, int revive_time)
{
    if (sender.Get()) {
        {
            room->frame_event_data->dead_alive_objs_.push_back(
                                       std::make_tuple(
                                                       sender.Get()->GetUniId(),
                                                       revive_time,
                                                       0
                                                       )
                                       );
        }
        {
            int dead_idx = room->frame_event_data->dead_alive_objs_.size() - 1;
            sender.Get()->TraverseAllLayerHumanList
                (
                 [dead_idx] (Human* hum, bool& stop)
                 {
                     hum->GetFrameData().dead_alive_objs_.push_back(dead_idx);
                 });
        }
    }
}

void FrameEvent::AddRevive(CreatureWeakPtr& sender)
{
    if (sender.Get()) {
        {
            room->frame_event_data->dead_alive_objs_.push_back(
                                       std::make_tuple(
                                                       sender.Get()->GetUniId(),
                                                       0,
                                                       1
                                                       )
                                       );
        }
        {
            int revive_idx = room->frame_event_data->dead_alive_objs_.size() - 1;
            sender.Get()->TraverseAllLayerHumanList
                (
                 [revive_idx] (Human* hum, bool& stop)
                 {
                     hum->GetFrameData().dead_alive_objs_.push_back(revive_idx);
                 });
        }
    }
}

void FrameEvent::AddCarChg(CreatureWeakPtr& sender)
{
    room->frame_event_data->chged_cars_.push_back(sender);
    int idx = room->frame_event_data->chged_cars_.size() - 1;
    sender.Get()->TraverseAllLayerHumanList
        (
         [idx] (Human* hum, bool& stop)
         {
            hum->GetFrameData().chged_cars_.push_back(idx);
         });
}

void FrameEvent::AddPropChg(CreatureWeakPtr& sender, int type, int subtype, float value, bool only_self)
{
    if (!sender.Get()) {
        return;
    }
    auto& p = a8::FastAppend(room->frame_event_data->chged_props_);
    std::get<0>(p) = sender;
    std::get<1>(p).set_obj_id(sender.Get()->GetUniId());
    std::get<1>(p).set_property_type(type);
    std::get<1>(p).set_property_subtype(subtype);
    std::get<1>(p).set_value(value);
    int idx = room->frame_event_data->chged_props_.size() - 1;
    if (only_self) {
        if (sender.Get()->IsHuman()) {
            sender.Get()->AsHuman()->GetFrameData().chged_props_.push_back(idx);
        } else if (sender.Get()->IsCar() && sender.Get()->AsCar()->GetDriver()) {
            sender.Get()->AsCar()->GetDriver()->GetFrameData().chged_props_.push_back(idx);
        }
    } else {
        sender.Get()->TraverseAllLayerHumanList
            (
             [idx] (Human* hum, bool& stop)
             {
                 hum->GetFrameData().chged_props_.push_back(idx);
             });
    }
}

void FrameEvent::AddPropChgEx(CreatureWeakPtr& sender, int type, int subtype,
                              float value, float value2, float value3, bool only_self)
{
    if (!sender.Get()) {
        return;
    }
    auto& p = a8::FastAppend(room->frame_event_data->chged_props_);
    std::get<0>(p) = sender;
    std::get<1>(p).set_obj_id(sender.Get()->GetUniId());
    std::get<1>(p).set_property_type(type);
    std::get<1>(p).set_property_subtype(subtype);
    std::get<1>(p).set_value(value);
    std::get<1>(p).set_value2(value2);
    std::get<1>(p).set_value3(value3);
    int idx = room->frame_event_data->chged_props_.size() - 1;
    if (only_self) {
        if (sender.Get()->IsHuman()) {
            sender.Get()->AsHuman()->GetFrameData().chged_props_.push_back(idx);
        } else if (sender.Get()->IsCar() && sender.Get()->AsCar()->GetDriver()) {
            sender.Get()->AsCar()->GetDriver()->GetFrameData().chged_props_.push_back(idx);
        }
    } else {
        sender.Get()->TraverseAllLayerHumanList
            (
             [idx] (Human* hum, bool& stop)
             {
                 hum->GetFrameData().chged_props_.push_back(idx);
             });
    }
}

void FrameEvent::AddEnterGame(CreatureWeakPtr& sender)
{
    room->frame_event_data->enter_game_players_.push_back(sender);
}

void FrameEvent::AddExitGame(CreatureWeakPtr& sender)
{
    room->frame_event_data->exit_game_players_.push_back(sender.Get()->GetUniId());
}

void FrameEvent::Clear()
{
    if (!room->frame_event_data->explosions_.empty()) {
        room->frame_event_data->explosions_.clear();
    }
    if (!room->frame_event_data->smokes_.empty()) {
        room->frame_event_data->smokes_.clear();
    }
    if (!room->frame_event_data->play_skills_.empty()) {
        room->frame_event_data->play_skills_.clear();
    }
    if (!room->frame_event_data->emotes_.empty()) {
        room->frame_event_data->emotes_.clear();
    }
    if (!room->frame_event_data->bullets_.empty()) {
        room->frame_event_data->bullets_.clear();
    }
    if (!room->frame_event_data->shots_.empty()) {
        room->frame_event_data->shots_.clear();
    }
    if (room->frame_event_data->airdrops_.size() > 0) {
        room->frame_event_data->airdrops_.Clear();
    }
    if (room->frame_event_data->airraids_.size() > 0) {
        room->frame_event_data->airraids_.Clear();
    }
    if (!room->frame_event_data->chged_bullet_nums_.empty()) {
        room->frame_event_data->chged_bullet_nums_.clear();
    }
    if (!room->frame_event_data->chged_buffs_.empty()) {
        room->frame_event_data->chged_buffs_.clear();
    }
    if (!room->frame_event_data->chged_hps_.empty()) {
        room->frame_event_data->chged_hps_.clear();
    }
    if (!room->frame_event_data->chged_skillcds_.empty()) {
        room->frame_event_data->chged_skillcds_.clear();
    }
    if (!room->frame_event_data->chged_skill_curr_times_.empty()) {
        room->frame_event_data->chged_skill_curr_times_.clear();
    }
    if (!room->frame_event_data->chged_items_.empty()) {
        room->frame_event_data->chged_items_.clear();
    }
    if (!room->frame_event_data->chged_weapon_ammo_.empty()) {
        room->frame_event_data->chged_weapon_ammo_.clear();
    }
    if (!room->frame_event_data->dead_alive_objs_.empty()) {
        room->frame_event_data->dead_alive_objs_.clear();
    }
    if (!room->frame_event_data->chged_cars_.empty()) {
        room->frame_event_data->chged_cars_.clear();
    }
    if (!room->frame_event_data->chged_props_.empty()) {
        room->frame_event_data->chged_props_.clear();
    }
    if (!room->frame_event_data->del_bullets_.empty()) {
        room->frame_event_data->del_bullets_.clear();
    }
    if (!room->frame_event_data->enter_game_players_.empty()) {
        room->frame_event_data->enter_game_players_.clear();
    }
    if (!room->frame_event_data->exit_game_players_.empty()) {
        room->frame_event_data->exit_game_players_.clear();
    }
}