using BrewMonster.Network;
using BrewMonster.Scripts;
using BrewMonster.Scripts.Pet;
using BrewMonster.UI;
using CSNetwork;
using CSNetwork.GPDataType;
using System;
using System.Runtime.InteropServices;
using BrewMonster.Assets.PerfectWorld.Scripts.Players;
using UnityEngine;
using static BrewMonster.Scripts.Pet.CECPetData;

namespace BrewMonster
{
    public partial class CECHostPlayer
    {
        private void OnMsgPlayerFly(ECMSG Msg)
        {
            if (Convert.ToInt32(Msg.dwParam2) == CommandID.OBJECT_TAKEOFF)
            {
                if ((m_dwStates & PlayerNPCState.GP_STATE_FLY) == 0)
                {
                    m_dwStates |= PlayerNPCState.GP_STATE_FLY;
                    m_bRushFly = false;

                    CECHPWorkFly pWork = (CECHPWorkFly)m_pWorkMan.CreateWork(CECHPWork.Host_work_ID.WORK_FLYOFF);
                    if (m_pWorkMan.IsFreeFalling())
                    {
                        pWork.m_bContinueFly = true;
                        m_pWorkMan.StartWork_p1(pWork);
                    }
                    else
                    {
                        pWork.m_bContinueFly = false;
                        m_pWorkMan.StartWork_p2(pWork);
                    }
                }
            }
            else if (Convert.ToInt32(Msg.dwParam2) == CommandID.OBJECT_LANDING)
            {
                if ((m_dwStates & PlayerNPCState.GP_STATE_FLY) != 0)
                {
                    m_dwStates &= ~(uint)PlayerNPCState.GP_STATE_FLY;

                    if (IsDead() || m_bCandHangerOn || IsHangerOn())
                        ShowWing(false);
                    else
                    {
                        CECHPWorkFall pWork =
                            (CECHPWorkFall)m_pWorkMan.CreateWork(CECHPWork.Host_work_ID.WORK_FREEFALL);
                        pWork.SetFallType(CECHPWorkFall.Fall_type.TYPE_FLYFALL);
                        m_pWorkMan.StartWork_p1(pWork);
                    }

                    //	Below two lines will fix the "host stand in air" bug.
                    m_iMoveEnv = Move_environment.MOVEENV_GROUND;
                    m_CDRInfo.vTPNormal.Clear();
                }
            }
            else //	HOST_RUSH_FLY
            {
                cmd_host_rush_fly pCmd = GPDataTypeHelper.FromBytes<cmd_host_rush_fly>((byte[])Msg.dwParam1);
                m_bRushFly = pCmd.is_active != 0 ? true : false;
            }
        }

        void OnMsgHstPetOpt(ECMSG Msg)
        {
            CECGameRun pGameRun = EC_Game.GetGameRun();
            int header = Convert.ToInt32(Msg.dwParam2);
            switch (header)
            {
                case CommandID.GAIN_PET:
                {
                    cmd_gain_pet pCmd = GPDataTypeHelper.FromBytes<cmd_gain_pet>((byte[])Msg.dwParam1);
                    m_pPetCorral.AddPet(pCmd.slot_index, pCmd.data);

                    //	Print a notify
                    CECPetData pPet = m_pPetCorral.GetPetData(pCmd.slot_index);
                    if (pPet != null)
                    {
                        if (pPet.IsFollowPet() || pPet.IsCombatPet() || pPet.IsEvolutionPet())
                        {
                            // TO DO: fix later
                            //pGameRun.AddFixedMessage(FIXMSG_PET_HATCH, pPet.GetName());
                        }
                        else if (pPet.IsSummonPet())
                        {
                            // TO DO: fix later
                            //pGameRun.AddFixedMessage(FIXMSG_SUMMON_PET_APPEAR, pPet.GetName());
                        }
                    }

                    break;
                }

                case CommandID.FREE_PET:
                {
                    cmd_free_pet pCmd = GPDataTypeHelper.FromBytes<cmd_free_pet>((byte[])Msg.dwParam1);

                    //	Print a notify
                    CECPetData pPet = m_pPetCorral.GetPetData(pCmd.slot_index);
                    if (pPet != null)
                    {
                        if (pPet.IsFollowPet() || pPet.IsCombatPet() || pPet.IsEvolutionPet())
                        {
                            // TO DO: fix later
                            //pGameRun.AddFixedMessage(FIXMSG_PET_FREE, pPet.GetName());
                        }
                        else if (pPet.IsSummonPet())
                        {
                            // TO DO: fix later
                            //pGameRun.AddFixedMessage(FIXMSG_SUMMON_PET_DISAPPEAR, pPet.GetName());
                        }
                    }

                    //	Remove pet from corral
                    m_pPetCorral.FreePet(pCmd.slot_index, pCmd.pet_id);
                    //	Update pet shortcuts
                    UpdateFreedPetSC(pCmd.slot_index);

                    break;
                }
                case CommandID.SUMMON_PET:
                {
                    cmd_summon_pet pCmd = GPDataTypeHelper.FromBytes<cmd_summon_pet>((byte[])Msg.dwParam1);
                    CECPetData pPet = m_pPetCorral.GetPetData(pCmd.slot_index);
                    //ASSERT(pPet && pPet.GetTemplateID() == pCmd.pet_tid);
                    m_pPetCorral.SetActivePetIndex(pCmd.slot_index);
                    m_pPetCorral.SetActivePetNPCID(pCmd.pet_pid);
                    m_pPetCorral.SetActivePetLifetime(pCmd.life_time);

                    if (EC_Game.GetConfigs().GetGameSettings().bPetAutoSkill)
                    {
                        for (int i = 0; i < pPet.GetSkillNum(SKILLTYPE.EM_SKILL_DEFAULT); i++)
                        {
                            PETSKILL? pSkill = pPet.GetSkill(SKILLTYPE.EM_SKILL_DEFAULT, i);
                            if (pSkill != null && EC_Game.IsPetAutoSkill(pSkill.Value.idSkill))
                                pPet.AddAutoSkill(pSkill.Value.idSkill);
                        }
                    }

                    // TO DO: fix later
                    //OnPetSays(pCmd.pet_tid, pCmd.pet_pid, CECPetWords::TW_SUMMON);
                    //if (pPet.IsCombatPet() || pPet.IsSummonPet() || pPet.IsEvolutionPet())
                    //    CDlgQuickBarPet::ResetAutoCastSkill();
                    break;
                }
                case CommandID.RECALL_PET:
                {
                    cmd_recall_pet pCmd = GPDataTypeHelper.FromBytes<cmd_recall_pet>((byte[])Msg.dwParam1);
                    //ASSERT(pCmd.slot_index == m_pPetCorral.GetActivePetIndex());

                    int tid = pCmd.pet_id;
                    int nid = m_pPetCorral.GetActivePetNPCID();

                    //	�����л�˵
                    switch (pCmd.reason)
                    {
                        case (char)PET_RECALL_REASON.PET_RECALL_DEFAULT:
                            //OnPetSays(tid, nid, CECPetWords::TW_RECALL);
                            break;

                        case (char)PET_RECALL_REASON.PET_RECALL_DEATH:
                            //OnPetSays(tid, nid, CECPetWords::TW_DEAD);
                            break;

                        case (char)PET_RECALL_REASON.PET_RECALL_LIFE_EXHAUST:
                            //OnPetSays(tid, nid, CECPetWords::TW_DISAPPEAR);
                            break;

                        case (char)PET_RECALL_REASON.PET_RECALL_SACRIFICE:
                            //OnPetSays(tid, nid, CECPetWords::TW_SACRIFICE);
                            break;
                    }

                    CECPetData pPet = m_pPetCorral.GetActivePet();
                    if (pPet != null)
                        pPet.OnPetDead();

                    m_pPetCorral.SetActivePetIndex(-1);
                    m_pPetCorral.SetActivePetNPCID(0);
                    m_bPetInSanctuary = false;
                    break;
                }
                case CommandID.PLAYER_START_PET_OP:
                {
                    cmd_player_start_pet_op pCmd =
                        GPDataTypeHelper.FromBytes<cmd_player_start_pet_op>((byte[])Msg.dwParam1);
                    int iDoWhat;
                    if (pCmd.op == 0)
                        iDoWhat = (int)CECHPWorkConcentrate.eDO_PET.DO_SUMMONPET;
                    else if (pCmd.op == 1)
                        iDoWhat = (int)CECHPWorkConcentrate.eDO_PET.DO_RECALLPET;
                    else if (pCmd.op == 2)
                        iDoWhat = (int)CECHPWorkConcentrate.eDO_PET.DO_BANISHPET;
                    else if (pCmd.op == 3)
                        iDoWhat = (int)CECHPWorkConcentrate.eDO_PET.DO_RESTOREPET;
                    else
                        iDoWhat = (int)CECHPWorkConcentrate.eDO_PET.DO_UNKNOWN;

                    m_PetOptCnt.SetPeriod(pCmd.delay * 50);
                    m_PetOptCnt.Reset();

                    CECHPWorkConcentrate pWork =
                        (CECHPWorkConcentrate)m_pWorkMan.CreateWork(CECHPWork.Host_work_ID.WORK_CONCENTRATE);
                    pWork.SetDoWhat(iDoWhat);
                    m_pWorkMan.StartWork_p1(pWork);
                    break;
                }
                case CommandID.PLAYER_STOP_PET_OP:
                {
                    if (IsOperatingPet() != 0)
                        m_pWorkMan.FinishRunningWork(CECHPWork.Host_work_ID.WORK_CONCENTRATE);

                    break;
                }
                case CommandID.PET_RECEIVE_EXP:
                {
                    cmd_pet_receive_exp pCmd = GPDataTypeHelper.FromBytes<cmd_pet_receive_exp>((byte[])Msg.dwParam1);
                    CECPetData pPet = m_pPetCorral.GetPetData(pCmd.slot_index);
                    if (pPet != null)
                    {
                        //ASSERT(pPet.GetTemplateID() == pCmd.pet_id);
                        pPet.AddExp(pCmd.exp);
                    }

                    break;
                }
                case CommandID.PET_LEVELUP:
                {
                    cmd_pet_levelup pCmd = GPDataTypeHelper.FromBytes<cmd_pet_levelup>((byte[])Msg.dwParam1);
                    CECPetData pPet = m_pPetCorral.GetPetData(pCmd.slot_index);
                    if (pPet != null)
                    {
                        //ASSERT(pPet.GetTemplateID() == pCmd.pet_id);
                        pPet.LevelUp(pCmd.level, pCmd.exp);
                    }

                    //pGameRun.AddFixedMessage(FIXMSG_PET_LEVELUP, pCmd.level);
                    break;
                }
                case CommandID.PET_ROOM:
                {
                    cmd_pet_room pCmd = GPDataTypeHelper.FromBytes<cmd_pet_room>((byte[])Msg.dwParam1);
                    m_pPetCorral.UpdatePets(pCmd, (byte[])Msg.dwParam1);

                    CECGameUIMan pGameUI = EC_Game.GetGameRun().GetUIManager().GetInGameUIMan();

                    //if (pGameUI.GetDialog("Win_Teach").IsShow())
                    //    {
                    //        //pGameUI.UpdateTeach();
                    //    }

                    break;
                }
                case CommandID.PET_ROOM_CAPACITY:
                {
                    cmd_pet_room_capacity pCmd =
                        GPDataTypeHelper.FromBytes<cmd_pet_room_capacity>((byte[])Msg.dwParam1);
                    m_pPetCorral.MagnifyPetSlots((int)pCmd.capacity);

                    if (m_pPetCorral.HasInit())
                    {
                        //pGameRun.AddFixedMessage(FIXMSG_PET_ROOM_SIZE, pCmd.capacity);
                    }
                    else
                        m_pPetCorral.SetHasInit(true);

                    break;
                }
                case CommandID.PET_HONOR_POINT:
                {
                    cmd_pet_honor_point pCmd = GPDataTypeHelper.FromBytes<cmd_pet_honor_point>((byte[])Msg.dwParam1);
                    CECPetData pPet = m_pPetCorral.GetPetData(pCmd.index);
                    if (pPet != null)
                        pPet.SetIntimacy(pCmd.cur_honor_point);

                    break;
                }
                case CommandID.PET_HUNGER_GAUGE:
                {
                    cmd_pet_hunger_gauge pCmd = GPDataTypeHelper.FromBytes<cmd_pet_hunger_gauge>((byte[])Msg.dwParam1);
                    CECPetData pPet = m_pPetCorral.GetPetData(pCmd.index);
                    if (pPet != null)
                        pPet.SetHunger(pCmd.cur_hunge_gauge);

                    break;
                }
                case CommandID.PET_DEAD:
                {
                    cmd_pet_dead pCmd = GPDataTypeHelper.FromBytes<cmd_pet_dead>((byte[])Msg.dwParam1);
                    CECPetData pPet = m_pPetCorral.GetPetData((int)pCmd.pet_index);
                    if (pPet != null)
                    {
                        pPet.SetHPFactor(0.0f);
                        pPet.SetHP(0);
                        pPet.OnPetDead();
                    }

                    //pGameRun.AddFixedMessage(FIXMSG_PET_DEAD);
                    break;
                }
                case CommandID.PET_REVIVE:
                {
                    cmd_pet_revive pCmd = GPDataTypeHelper.FromBytes<cmd_pet_revive>((byte[])Msg.dwParam1);
                    CECPetData pPet = m_pPetCorral.GetPetData((int)pCmd.pet_index);
                    if (pPet != null)
                        pPet.SetHPFactor(pCmd.hp_factor);

                    break;
                }
                case CommandID.PET_HP_NOTIFY:
                {
                    cmd_pet_hp_notify pCmd = GPDataTypeHelper.FromBytes<cmd_pet_hp_notify>((byte[])Msg.dwParam1);
                    CECPetData pPet = m_pPetCorral.GetPetData((int)pCmd.pet_index);
                    if (pPet != null)
                    {
                        int lastHP = pPet.GetHP();

                        pPet.SetHPFactor(pCmd.hp_factor);
                        pPet.SetHP(pCmd.cur_hp);

                        pPet.SetMPFactor(pCmd.mp_factor);
                        pPet.SetMP(pCmd.cur_mp);

                        //	If HP is too low, popup a warning on pet's head
                        int iLimit = (int)(pPet.CalcMaxHP() * 0.3f);
                        if (pCmd.cur_hp < lastHP && lastHP != 0 && pCmd.cur_hp < iLimit)
                        {
                            CECNPC pNPC = EC_Game.GetGameRun().GetWorld().GetNPCMan()
                                .GetNPC(m_pPetCorral.GetActivePetNPCID());
                            if (pNPC && pNPC.GetMasterID() == GetCharacterID())
                            {
                                //pNPC.BubbleText(CECNPC::BUBBLE_HPWARN, 0); 
                            }
                        }
                    }

                    break;
                }
                case CommandID.PET_AI_STATE:
                {
                    cmd_pet_ai_state pCmd = GPDataTypeHelper.FromBytes<cmd_pet_ai_state>((byte[])Msg.dwParam1);

                    //	�����л�˵
                    CECPetData pPetData = m_pPetCorral.GetActivePet();
                    if (pPetData != null)
                    {
                        int tid = pPetData.GetTemplateID();
                        int nid = m_pPetCorral.GetActivePetNPCID();
                        if (m_pPetCorral.GetMoveMode() != pCmd.move)
                        {
                            switch (pCmd.move)
                            {
                                case (byte)CECPetCorral.ePet_MovingMode.MOVE_FOLLOW:
                                {
                                    //OnPetSays(tid, nid, CECPetWords::TW_FOLLOW);
                                    break;
                                }
                                case (byte)CECPetCorral.ePet_MovingMode.MOVE_STAND:
                                {
                                    //OnPetSays(tid, nid, CECPetWords::TW_STOP);
                                    break;
                                }
                            }
                        }

                        if (m_pPetCorral.GetAttackMode() != pCmd.attack)
                        {
                            switch (pCmd.attack)
                            {
                                case (byte)CECPetCorral.ePet_AttackingMode.ATK_DEFENSE:
                                    //OnPetSays(tid, nid, CECPetWords::TW_DEFENSIVE);
                                    break;

                                case (byte)CECPetCorral.ePet_AttackingMode.ATK_POSITIVE:
                                    //OnPetSays(tid, nid, CECPetWords::TW_OFFENSIVE);
                                    break;

                                case (byte)CECPetCorral.ePet_AttackingMode.ATK_PASSIVE:
                                    //OnPetSays(tid, nid, CECPetWords::TW_PASSIVE);
                                    break;
                            }
                        }
                    }

                    m_pPetCorral.SetMoveMode(pCmd.move);
                    m_pPetCorral.SetAttackMode(pCmd.attack);
                    break;
                }
                case CommandID.PET_SET_COOLDOWN:
                {
                    cmd_pet_set_cooldown pCmd = GPDataTypeHelper.FromBytes<cmd_pet_set_cooldown>((byte[])Msg.dwParam1);
                    CECPetData pPet = m_pPetCorral.GetPetData(pCmd.pet_index);
                    if (pPet != null)
                        pPet.SetSkillCoolTime(pCmd.cooldown_index, pCmd.cooldown_time);

                    break;
                }

                case CommandID.SUMMON_PLANT_PET:
                {
                    int size = Marshal.SizeOf<cmd_summon_plant_pet>();
                    if (((byte[])Msg.dwParam1).Length >= size)
                    {
                        cmd_summon_plant_pet pCmd =
                            GPDataTypeHelper.FromBytes<cmd_summon_plant_pet>((byte[])Msg.dwParam1);
                        m_pPetCorral.PlantPetEnter(pCmd);
                    }

                    break;
                }

                case CommandID.PLANT_PET_DISAPPEAR:
                {
                    int size = Marshal.SizeOf<cmd_plant_pet_disapper>();
                    if (((byte[])Msg.dwParam1).Length >= size)
                    {
                        cmd_plant_pet_disapper pCmd =
                            GPDataTypeHelper.FromBytes<cmd_plant_pet_disapper>((byte[])Msg.dwParam1);
                        m_pPetCorral.PlantPetDisappear(pCmd);
                    }

                    break;
                }

                case CommandID.PLANT_PET_HP_NOTIFY:
                {
                    int size = Marshal.SizeOf<cmd_plant_pet_hp_notify>();
                    if (((byte[])Msg.dwParam1).Length >= size)
                    {
                        cmd_plant_pet_hp_notify pCmd =
                            GPDataTypeHelper.FromBytes<cmd_plant_pet_hp_notify>((byte[])Msg.dwParam1);
                        m_pPetCorral.PlantPetInfo(pCmd);
                    }

                    break;
                }

                case CommandID.PET_PROPERTY:
                {
                    cmd_pet_property pCmd = GPDataTypeHelper.FromBytes<cmd_pet_property>((byte[])Msg.dwParam1);
                    CECPetData pPet = m_pPetCorral.GetPetData(pCmd.pet_index);
                    if (pPet != null)
                    {
                        pPet.SetExtendProps(pCmd.prop);
                    }

                    break;
                }
                case CommandID.PET_REBUILD_INHERIT_START:
                case CommandID.PET_REBUILD_INHERIT_INFO:
                case CommandID.PET_REBUILD_INHERIT_END:
                case CommandID.PET_EVOLUTION_DONE:
                case CommandID.PET_REBUILD_NATURE_START:
                case CommandID.PET_REBUILD_NATURE_INFO:
                case CommandID.PET_REBUILD_NATURE_END:
                {
                    CECGameUIMan pGameUI = EC_Game.GetGameRun().GetUIManager().GetInGameUIMan();
                    if (pGameUI != null)
                    {
                        //((CDlgPreviewPetRebuild*)pGameUI.GetDialog("Win_PreviewPet")).OnServerNotify(Msg.dwParam2, (void*)Msg.dwParam1);
                    }

                    break;
                }

                default:
                    break;
            }
        }

        /*	Is host operating pet ?
                   return value:

                   0: host doesn't operating pet.
                   1: host is summoning pet.
                   2: host is recalling pet.
                   3: host is banishing pet.
               */
        public int IsOperatingPet()
        {
            CECHPWorkConcentrate pWork =
                (m_pWorkMan.GetRunningWork(CECHPWork.Host_work_ID.WORK_CONCENTRATE)) as CECHPWorkConcentrate;
            if (pWork != null)
            {
                if (pWork.GetDoWhat() == (int)CECHPWorkConcentrate.eDO_PET.DO_SUMMONPET)
                    return 1;
                else if (pWork.GetDoWhat() == (int)CECHPWorkConcentrate.eDO_PET.DO_RECALLPET)
                    return 2;
                else if (pWork.GetDoWhat() == (int)CECHPWorkConcentrate.eDO_PET.DO_BANISHPET)
                    return 3;
                else if (pWork.GetDoWhat() == (int)CECHPWorkConcentrate.eDO_PET.DO_RESTOREPET)
                    return 4;
            }

            return 0;
        }

        //	Summon pet
        public bool SummonPet(int iPetIdx)
        {
            if (m_pActionSwitcher != null)
                m_pActionSwitcher.PostMessge((int)EMsgActionSwitcher.MSG_MOUNTPET);

            CECGameRun pGameRun = EC_Game.GetGameRun();

            CECPetData pPet = m_pPetCorral.GetPetData(iPetIdx);
            if (pPet == null)
                return false;

            if (!CanDo(ActionCanDo.CANDO_SUMMONPET))
                return false;

            //	Couldn't summon daed pet
            if (pPet.IsDead())
            {
                //pGameRun.AddFixedMessage(FIXMSG_PET_DEAD);
                Debug.LogError("FIXMSG_PET_DEAD");
                return false;
            }

            //	If host could't stop naturally, cancel summoning
            if (!NaturallyStopMoving())
                return false;

            //	¼ì²éµ±Ç°ÊÇ·ñ½ûÖ¹ÕÙ»½Æï³è
            if (pPet.IsMountPet() && m_playerLimits[(int)PLAYER_LIMIT.PLAYER_LIMIT_NOMOUNT])
                return false;

            if (m_ReincarnationCount != 0)
            {
                int iLevelRequired = pPet.GetLevel() - 35 - m_ReincarnationCount * 5;
                if (m_BasicProps.iLevel < iLevelRequired)
                {
                    CECGameUIMan pGameUI = EC_Game.GetGameRun().GetUIManager().GetInGameUIMan();
                    if (pGameUI != null)
                    {
                        // TO DO: fix later
                        //string strText = "";
                        //strText.Format(pGameUI.GetStringFromTable(10787), iLevelRequired);
                        //pGameUI.MessageBox("", strText, MB_OK, A3DCOLORRGBA(255, 255, 255, 160));
                    }

                    return false;
                }
            }

            UnityGameSession.c2s_CmdPetSummon(iPetIdx);

            return true;
        }
        public CECPetCorral GetPetCorral()
        {
            return m_pPetCorral;
        }
    }
}