using System.Collections;
using System.Dynamic;
using CSNetwork.GPDataType;
using Cysharp.Threading.Tasks;
using UnityEngine;

namespace BrewMonster.Scripts
{
    public class CECHPWorkStand : CECHPWork
    {
        protected bool m_bMeetSlide; // true, meet slide
        protected int m_iPoseAction; // pose action
        protected bool m_bSession; // doing session pose
        protected bool m_bWaterStop; // stop moving down in water
        protected bool m_bMoving; // moving flag
        protected bool m_bStopSlide; // stop sliding flag
        protected int m_iCurAction; // current playing action
        //protected int m_oldAction;     // cache old played action

        public CECHPWorkStand(CECHPWorkMan pWorkMan) : base(Host_work_ID.WORK_STAND, pWorkMan)
        {
            m_dwMask = Work_mask.MASK_STAND;
            m_dwTransMask = Work_mask.MASK_MOVETOPOS | Work_mask.MASK_FLYOFF | Work_mask.MASK_FREEFALL |
                            Work_mask.MASK_TRACEOBJECT |
                            Work_mask.MASK_SIT | Work_mask.MASK_SPELLOBJECT | Work_mask.MASK_FOLLOW |
                            Work_mask.MASK_CONCENTRATE | Work_mask.MASK_USEITEM;
            Reset();
        }

        // Reset work
        public override void Reset()
        {
            base.Reset();

            m_bMeetSlide = false;
            m_iPoseAction = (int)PLAYER_ACTION_TYPE.ACT_STAND;
            m_bSession = false;
            m_bWaterStop = false;
            m_bMoving = false;
            m_bStopSlide = false;
            m_iCurAction = (int)PLAYER_ACTION_TYPE.ACT_STAND;
        }

        // Copy work data
        public override bool CopyData(CECHPWork pWork)
        {
            if (!base.CopyData(pWork))
                return false;

            CECHPWorkStand pSrc = (CECHPWorkStand)pWork;

            m_bMeetSlide = pSrc.m_bMeetSlide;
            m_iPoseAction = pSrc.m_iPoseAction;
            m_bSession = pSrc.m_bSession;
            m_bWaterStop = pSrc.m_bWaterStop;
            m_bMoving = pSrc.m_bMoving;
            m_bStopSlide = pSrc.m_bStopSlide;
            m_iCurAction = pSrc.m_iCurAction;

            return true;
        }

        public async void SetPoseAction(int iAction, bool bSession)
        {
            m_iPoseAction = iAction;
            m_bSession = bSession;
            m_pHost.ClearAnimation();
            m_pHost.PlayAction(m_iPoseAction, false);

            if (!bSession && iAction != (int)PLAYER_ACTION_TYPE.ACT_EXP_KISS)
            {
                await UniTask.Delay(3000);
                m_iPoseAction = 0;
                // m_pHost.PlayAction(m_pHost.GetMoveStandAction(false, false), true, 300, true);
            }
        }

        protected override void OnFirstTick()
        {
            m_pHost.m_iMoveMode = (int)Move_Mode.MOVE_STAND;
            // Velocity/acceleration reset are skipped here due to partial host API availability in C#
            // If needed, add host velocity reset when fields are available
            m_pHost.m_vAccel.Clear();

            if (m_pHost.m_iMoveEnv == CECPlayer.Move_environment.MOVEENV_AIR)
                m_pHost.m_vVelocity.x = m_pHost.m_vVelocity.z = 0.0f;
            else if (m_pHost.m_iMoveEnv == CECPlayer.Move_environment.MOVEENV_WATER)
                m_pHost.m_vVelocity.x = m_pHost.m_vVelocity.z = 0.0f;
            else
                m_pHost.m_vVelocity.Clear();

            // if (m_pHost.m_pMoveTargetGFX) m_pHost.m_pMoveTargetGFX.Stop();
        }

        // Should player start move?
        int ShouldMove()
        {
            int iMoveReason = 0;

            if (m_pHost.IsJumping())
            {
                iMoveReason = 1;
            }
            else if (!m_pHost.m_GndInfo.bOnGround)
            {
                if (m_pHost.m_iMoveEnv != CECPlayer.Move_environment.MOVEENV_AIR &&
                    m_pHost.m_iMoveEnv != CECPlayer.Move_environment.MOVEENV_WATER)
                    iMoveReason = 2;
            }

            return iMoveReason;
        }

        // On work shift
        public override void OnWorkShift()
        {
            m_bWaterStop = false;
            m_bMoving = false;
            m_bMeetSlide = false;
            m_bStopSlide = false;
        }

        // Work is cancel
        public override void Cancel()
        {
            m_iPoseAction = (int)PLAYER_ACTION_TYPE.ACT_STAND;
            m_bSession = false;
            m_pHost.m_bPrepareFight = false;
            base.Cancel();
        }

        // Doing session pose?
        public bool DoingSessionPose()
        {
            return (m_iPoseAction != (int)PLAYER_ACTION_TYPE.ACT_STAND && m_bSession);
        }

        // Tick routine
        public override bool Tick(float dwDeltaTime)
        {
            base.Tick(dwDeltaTime);
            int iMoveReason = ShouldMove();
            if (iMoveReason != 0)
            {
                if (iMoveReason == 1)
                {
                    var pWork = (CECHPWorkMove)m_pWorkMan.CreateWork(Host_work_ID.WORK_MOVETOPOS);
                    if (pWork != null)
                    {
                        pWork.SetDestination(CECHPWorkMove.DestTypes.DEST_STANDJUMP, GPDataTypeHelper.g_vOrigin);
                        m_pWorkMan.SetPostTickCommand(new CECHPWorkPostTickRunWorkCommand(
                            pWork, false, CECHPWorkMan.Work_priority.PRIORITY_1, true, dwDeltaTime));
                    }
                }
                else if (iMoveReason == 2)
                {
                    var pWork = (CECHPWorkFall)m_pWorkMan.CreateWork(Host_work_ID.WORK_FREEFALL);
                    if (pWork != null)
                    {
                        pWork.SetFallType(CECHPWorkFall.Fall_type.TYPE_FREEFALL);
                        m_pWorkMan.SetPostTickCommand(new CECHPWorkPostTickRunWorkCommand(pWork));
                    }
                }
                else
                {
                    // ASSERT(0);
                }

                return true;
            }

            // Play appropriate actions
            if (m_iPoseAction == (int)PLAYER_ACTION_TYPE.ACT_STAND)
            {
                bool bFight = m_pHost.IsFighting() || m_pHost.m_bPrepareFight;
                m_iCurAction = m_pHost.GetMoveStandAction(false, bFight);
            }

            float fDeltaTime = dwDeltaTime /** 0.001f*/;

            if (!m_pHost.IsRooting())
            {
                if (m_pHost.m_iMoveEnv == CECPlayer.Move_environment.MOVEENV_GROUND)
                    Tick_Walk(fDeltaTime);
                else    // AIR or WATER
                    Tick_FlySwim(fDeltaTime);
            }

            if (m_iPoseAction == (int)PLAYER_ACTION_TYPE.ACT_STAND)
            {
                m_pHost.PlayAction(m_iCurAction, false, 300);
                //m_oldAction = m_iCurAction;
            }

            // Force to update object's direction and up
            // m_pHost.m_vecGroundNormal = m_pHost.m_vecGroundNormalSet;
            // m_pHost.StopModelMove(m_pHost.GetDir(), m_pHost.GetUp(), 0);

            return true;
        }

        // Tick routine of walking on ground
        bool Tick_Walk(float fDeltaTime)
        {
            A3DVECTOR3 vCurPos = m_pHost.GetPos();
            CDR_INFO cdr = m_pHost.m_CDRInfo;

            if (m_pHost.m_iMoveMode == (int)Move_Mode.MOVE_SLIDE)
            {
                if (m_bStopSlide)
                    return true;

                m_iCurAction = (int)PLAYER_ACTION_TYPE.ACT_JUMP_LOOP;

                m_bMeetSlide = true;
                m_bMoving = true;

                vCurPos = m_pHost.m_MoveCtrl.GroundMove(GPDataTypeHelper.g_vOrigin, 0.0f, fDeltaTime);
                m_pHost.SetPos(EC_Utility.ToVector3(vCurPos));

                if (m_pHost.m_MoveCtrl.MoveBlocked() >= 3)
                {
                    m_bStopSlide = true;
                    m_bMoving = false;
                    m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), m_pHost.GetGroundSpeed(),
                        (int)GPMoveMode.GP_MOVE_SLIDE);
                }
                else
                {
                    m_pHost.m_MoveCtrl.SendMoveCmd(vCurPos, 2, GPDataTypeHelper.g_vOrigin, cdr.vAbsVelocity,
                        (int)GPMoveMode.GP_MOVE_SLIDE);
                }
            }
            else if (m_bMeetSlide)
            {
                m_bMeetSlide = false;
                m_bMoving = false;
                m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), m_pHost.GetGroundSpeed(),
                    (int)GPMoveMode.GP_MOVE_SLIDE);
            }

            return true;
        }

        // Tick routine of flying or swimming
        bool Tick_FlySwim(float fDeltaTime)
        {
            m_bMoving = false;

            if (m_pHost.m_iMoveEnv == CECPlayer.Move_environment.MOVEENV_WATER && !m_bWaterStop)
            {
                // Handle floating at water surface after falling into water
                A3DVECTOR3 vCurPos = m_pHost.GetPos();
                ON_AIR_CDR_INFO cdr = m_pHost.m_AirCDRInfo;
                float fSpeed = m_pHost.GetSwimSpeedSev();

                if (m_pHost.m_GndInfo.fWaterHei - vCurPos.y < cdr.vExtent.y + m_pHost.m_MoveConst.fWaterSurf)
                {
                    m_bMoving = true;

                    vCurPos = m_pHost.m_MoveCtrl.AirWaterMove(-GPDataTypeHelper.g_vAxisY, fSpeed, fDeltaTime, false, false);
                    m_pHost.SetPos(EC_Utility.ToVector3(vCurPos));

                    if (m_pHost.m_MoveCtrl.MoveBlocked() >= 3 ||
                        m_pHost.m_GndInfo.fWaterHei - vCurPos.y >= cdr.vExtent.y + m_pHost.m_MoveConst.fWaterSurf)
                    {
                        m_bWaterStop = true;
                        m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), fSpeed, (int)GPMoveMode.GP_MOVE_WATER | (int)GPMoveMode.GP_MOVE_RUN);
                    }
                    else
                        m_pHost.m_MoveCtrl.SendMoveCmd(vCurPos, 2, GPDataTypeHelper.g_vOrigin, -GPDataTypeHelper.g_vAxisY * fSpeed, (int)GPMoveMode.GP_MOVE_WATER | (int)GPMoveMode.GP_MOVE_RUN);
                }
            }

            return true;
        }

        //	Get stop sliding flag
        public bool GetStopSlideFlag()
        {
            return m_bStopSlide;
        }
    }
}