#pragma once

#include "entity.h"
#include "cs_proto.pb.h"
#include "GGListener.h"

namespace MetaData
{
    struct Player;
    struct Equip;
    struct Dress;
    struct Skill;
}

enum HumanStatus
{
    HS_PainKiller = 1,
    HS_Fly = 2,
    HS_Jump = 3,
    HS_Hide = 4,
    HS_Accelerate = 5,
    HS_DamageAdd = 6,
    HS_DefAdd = 7,
    HS_RecoverHP = 8,
    HS_ReflectDamage = 9,
    HS_SummonHero = 10,
    HS_AtkAdd = 11,
    HS_End
};

struct xtimer_list;
class CircleCollider;
class AabbCollider;
class Obstacle;
class Loot;
class Human : public Entity
{
 public:
    int socket_handle = 0;
    long ip_saddr = 0;
    int team_id = 0;
    std::string account_id;
    std::string session_id;
    std::string from_appid;
    std::string team_uuid;
    bool auto_fill = false;
    int account_registertime = 0;
    MetaData::Player* meta = nullptr;
    MetaData::Equip* helmet_meta = nullptr;
    MetaData::Equip* chest_meta = nullptr;
    MetaData::Dress* skin_meta = nullptr;
    MetaData::Skill* skill_meta = nullptr;
    MetaData::Dress* skin_jlf_meta = nullptr;
    MetaData::Equip* skin_tank_meta = nullptr;
    HumanAbility buff;

    a8::Vec2 move_dir;
    a8::Vec2 attack_dir;

    std::string name;
    std::string avatar_url;
    float health = 0.0;
    bool downed = false;
    bool disconnected = false;
    int anim_type = 0;
    int anim_seq = 0;
    ActionType_e action_type = AT_None;
    long long action_frameno = 0;
    int action_duration = 0;
    int action_item_id = 0;
    int action_target_id = 0;
    Skin skin_jlf;
    Skin skin_tank;
    int backpack = 0;
    int helmet = 0;
    int chest = 0;
    int energy_shield = 0;
    int max_energy_shield = 0;
    int vip = 0;
    int sdmg = 0;
    bool poisoning = false;
    long long poisoning_time = 0;
    int lethal_weapon = 0;
    long long join_frameno = 0;
    int status = 0;
    float atk_add = 0.0f;
    int emoji1 = 0;
    int emoji2 = 0;
    int parachute = 0;
    bool has_pass = 0;

    Weapon default_weapon;
    Weapon tank_weapon;
    float tank_oil_value = 0.0f;
    float tank_oil_max = 0.0f;
    std::vector<Weapon> weapons;
    Weapon* curr_weapon = nullptr;

    int curr_scope_idx = 0;

    bool need_sync_team_data = false;
    bool need_sync_teammate_data = false;
    bool need_sync_active_player = false;

    PlayerStats stats;

    int pain_killer_frameno = 0;
    int pain_killer_lastingtime = 0;
    xtimer_list* pain_killer_timer = nullptr;

    xtimer_list* downed_timer = nullptr;

    std::set<Human*>* team_members = nullptr;
    std::set<Human*> kill_humans;
    Human* last_tank_attacker = nullptr;
    long long last_tank_attack_idx = 0;
    const BornPoint* born_point = nullptr;

    bool shot_start = false;
    bool shot_hold = false;
    int series_shot_frames = 0;
    float fly_distance = 0.0f;

    long long jump_frameno = 0;

    long long send_msg_times = 0;

    float def = 0.0f;
    std::map<int, int> weapon_configs;
    std::map<int, int> skin_configs;

    Human();
    virtual ~Human() override;
    virtual void Initialize() override;
    virtual float GetSpeed() override;
    virtual float GetSpeed4();
    virtual void FillMFObjectPart(cs::MFObjectPart* part_data) override;
    virtual void FillMFObjectFull(cs::MFObjectFull* full_data) override;
    virtual void FillMFPlayerStats(cs::MFPlayerStats* stats);
    virtual void GetAabbBox(AabbCollider& aabb_box);
    void FillMFTeamData(cs::MFTeamData* team_data);
    void Shot(a8::Vec2& target_dir);
    void TankShot(a8::Vec2& target_dir);
    void RecalcSelfCollider();
    bool IsCollisionInMapService();
    void FindPathInMapService();
    float GetRadius();
    float GetHP();
    float GetMaxHP();
    void UpdatePoisoning();
    void SyncAroundPlayers(const char* file, int line, const char* func);
    void AutoLoadingBullet(bool manual = false);
    void StartAction(ActionType_e action_type,
                     int action_duration,
                     int item_id,
                     int target_id);
    void CancelAction();
    void ResetAction();
    void BeKill(int killer_id, const std::string& killer_name, int weapon_id);
    void DecHP(float dec_hp, int killer_id, const std::string& killer_name, int weapon_id);
    void AddToNewObjects(Entity* entity);
    void AddToPartObjects(Entity* entity);
    void RemovePartObjects(Entity* entity);
    void RemoveObjects(Entity* entity);
    void AddOutObjects(Entity* entity);
    void RemoveOutObjects(Entity* entity);
    bool HasLiveTeammate();
    bool HasNoDownedTeammate();
    void Land();
    void DoJump();
    void DoSkill();
    void DoGetDown();
    void FindLocation();
    void RefreshView();
    void OnGridListChange(std::set<GridCell*>& old_grid_list,
                          std::set<GridCell*>& inc_grid_list,
                          std::set<GridCell*>& dec_grid_list
                          );
    void FillMFActivePlayerData(cs::MFActivePlayerData* player_data);
    void FillMFGasData(cs::MFGasData* gas_data);
    bool CanSee(const Human* hum) const;
    void RecalcAttr();
    void RecalcVolume();
    void RecalcBuff();
    int GetInventory(int slot_id);
    void AddInventory(int slot_id, int num);
    void DecInventory(int slot_id, int num);
    int GetVolume(int slot_id);
    void RecoverHp(int inc_hp);
    void FillBodyState(::google::protobuf::RepeatedPtrField<::cs::MFBodyState>* states);
    void SummonHero();
    void AddObserver(Human* observer);
    void RemoveObserver(Human* observer);
    void SendUpdateMsg();
    template <typename T>
    void SendNotifyMsg(T& msg)
    {
        GGListener::Instance()->SendToClient(socket_handle, 0, msg);
    }
    void SendGameOver();
    void FollowTarget(Human* target);
    void SendDebugMsg(const std::string& debug_msg);
    void SendRollMsg(const std::string& roll_msg);
    void UpdateAction();
    void SendUIUpdate();
    void SendWxVoip();
    int GetWeaponConfigLv(int weapon_id);
    int GetSkinConfigLv(int skin_id);
    void SetSkinInfo(int skin_id);
    const Skin& GetSkin();
    int SkinId();
    int SkinLv();
    void CheckSkinTank();

protected:
    void _UpdateMove(int speed);
    void ProcLootSkin(Loot* entity, MetaData::Equip* item_meta);

private:
    void ClearFrameData();
    void GenBattleReportData(a8::MutableXObject* params);
    void DeadDrop();
    void FillSMGameOver(cs::SMGameOver& msg);
    void SendBattleReport();
    void FindLocationWithTarget(Entity* target);

protected:
    long long last_shot_frameno_ = 0;
    long long last_use_skill_frameno_ = 0;
    long long hide_frameno_ = 0;
    long long accelerate_frameno_ = 0;
    long long damageadd_frameno_ = 0;
    long long defadd_frameno_ = 0;
    long long recover_hp_frameno_ = 0;
    long long reflect_damage_frameno_ = 0;
    long long summon_hero_frameno_ = 0;
    a8::XTimerAttacher skill_xtimer_attacher_;
    bool leave_ = false;
    long long leave_frameno_ = 0;

    std::array<int, IS_END - 1> inventory_ = {};
    std::array<int, IS_END> volume_ = {};
    std::set<Entity*> new_objects;
    std::set<Entity*> part_objects;
    std::set<int> del_objects;
    std::set<int> out_objects;
    std::vector<int> shots_;
    std::vector<int> emotes_;
    std::vector<int> bullets_;
    std::vector<int> smokes_;
    std::vector<int> explosions_;
    std::set<Human*> observers_;
    std::vector<int> chged_tank_bullet_nums_;
    std::vector<int> chged_tank_oil_value_;
    std::vector<int> chged_tank_oil_max_;
    std::vector<int> chged_hps_;
    Human* follow_target_ = nullptr;
    bool follow_synced_active_player = false;

private:
    CircleCollider* self_collider_ = nullptr;
    long long last_sync_gas_frameno = 0;

    bool already_report_battle_ = false;
    bool sent_battlereport_ = false;
    bool sent_game_end_ = false;

    Skin skin;

    friend class FrameMaker;
    friend class FrameEvent;
};