using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using vnxbqy.UI;

public class ClientCrossServerOneVsOneStage : DungeonStage
{

    static readonly Vector3 leftBornPoint = new Vector3(4.9f, 0.2f, 3.5f);
    static readonly Vector3 rightBornPoint = new Vector3(20f, 0.2f, 18.8f);

    static readonly Vector3 initPoint = new Vector3(30f, 0.2f, 30f);

    static FightInfo fightInfo;
    static PKStageType pkStageType;
    static GA_PlayerClient.PlayerInfo playerInfo;
    static GA_PVPClientPlayer opponentPlayer;
    static uint roundWiner = 0;

    PKStage currentStage;

    public override void Initialize()
    {
        base.Initialize();
        fightInfo = default(FightInfo);
        fightInfo.roundWinnerIds = new List<uint>();
        currentStage = null;

        GA_PVPClientPlayer.OnPVPResult += OnClientPVPResult;
        DTC0403_tagPlayerLoginLoadOK.mapInitOkEvent += OnReconnected;
    }

    public override void UnInitialize()
    {
        fightInfo = default(FightInfo);
        roundWiner = 0;
        currentStage = null;
        if (opponentPlayer != null)
        {
            opponentPlayer.Destroy();
            opponentPlayer = null;
        }

        if (ClientCrossServerOneVsOne.isClientCrossServerOneVsOne)
        {
            ClientCrossServerOneVsOne.StopClientCrossServerOneVsOne();
        }

        DTC0403_tagPlayerLoginLoadOK.mapInitOkEvent -= OnReconnected;
        GA_PVPClientPlayer.OnPVPResult -= OnClientPVPResult;
        base.UnInitialize();
    }

    protected override void OnStageLoadFinish()
    {
        base.OnStageLoadFinish();

        if (opponentPlayer != null)
        {
            opponentPlayer.Destroy();
            opponentPlayer = null;
        }

        var job = CrossServerLogin.Instance.oneVsOnePlayerData.opponentJob;
        var playerName = CrossServerLogin.Instance.oneVsOnePlayerData.opponentName;
        var level = CrossServerLogin.Instance.oneVsOnePlayerData.opponentLevel;
        var maxHp = CrossServerLogin.Instance.oneVsOnePlayerData.opponentMaxHp;
        var scoreClass = CrossServerOneVsOnePlayerInfo.Instance.DanLV;
        playerInfo = ClientCrossServerOneVsOne.GetRandomOpponentPlayerInfo(scoreClass, job, playerName, level, maxHp);
        // opponentPlayer = GAMgr.Instance.ReqClntPlayer<GA_PVPClientPlayer>(playerInfo, E_ActorGroup.Enemy);
        PersonalEnemy.Create(30000, ClientCrossServerOneVsOne.myPlace == 1 ? rightBornPoint : leftBornPoint, playerInfo);
        PersonalEnemy.OnPlayerAppear += OnPlayerAppear;
        SnxxzGame.Instance.StartCoroutine(WaitForPlayerCreate());

        PlayerDatas.Instance.hero.Pos = ClientCrossServerOneVsOne.myPlace == 1 ? leftBornPoint : rightBornPoint;
        CameraController.Instance.Apply();
    }

    private void OnPlayerAppear(GA_PVPClientPlayer player)
    {
        PersonalEnemy.OnPlayerAppear -= OnPlayerAppear;
        opponentPlayer = player;
        if (recordPosition != initPoint)
        {
            opponentPlayer.Pos = recordPosition;
            recordPosition = initPoint;
        }
    }

    private IEnumerator WaitForPlayerCreate()
    {
        while (opponentPlayer == null)
        {
            yield return null;
        }

        if (pkStageType != PKStageType.Fight)
        {
            opponentPlayer.Pos = ClientCrossServerOneVsOne.myPlace == 1 ? rightBornPoint : leftBornPoint;
            currentStage = new WaitStartStage();
            currentStage.Begin();
        }
    }

    protected override void OnUpdate()
    {
        base.OnUpdate();

        if (currentStage != null)
        {
            currentStage.Update();
            if (currentStage.completed)
            {
                currentStage.End();
                switch (pkStageType)
                {
                    case PKStageType.WaitStart:
                        currentStage = new FightStage();
                        break;
                    case PKStageType.Fight:
                        if (fightInfo.isOver)
                        {
                            currentStage = new FightOverStage();
                        }
                        else
                        {
                            currentStage = new RoundPrepareState();
                        }
                        break;
                    case PKStageType.RoundPrepare:
                        currentStage = new FightStage();
                        break;
                    case PKStageType.FightOver:
                        currentStage = null;
                        break;
                    default:
                        break;
                }

                if (currentStage != null)
                {
                    currentStage.Begin();
                }
            }
        }
    }

    private Vector3 recordPosition = initPoint;

    private void OnReconnected()
    {
        var sendInfo = new CA231_tagCMClientStartCustomScene();
        GameNetSystem.Instance.SendInfo(sendInfo);

        if (PlayerDatas.Instance.hero != null)
        {
            PlayerDatas.Instance.hero.Behaviour.StartHandupAI();
        }

        if (!opponentPlayer.ActorInfo.serverDie)
        {
            recordPosition = opponentPlayer.Pos;
            PersonalEnemy.ReleasePlayer(opponentPlayer);
            opponentPlayer = null;

            PersonalEnemy.Create(30000, recordPosition, playerInfo);
            PersonalEnemy.OnPlayerAppear += OnPlayerAppear;
        }
    }

    private void OnClientPVPResult(bool win)
    {
        roundWiner = win ? PlayerDatas.Instance.baseData.PlayerID : ClientCrossServerOneVsOne.OPPONENT_PLAYERID;
    }

    public abstract class PKStage
    {
        public float timer { get; protected set; }
        public float duration { get; protected set; }
        public bool completed { get; protected set; }

        public abstract void Begin();
        public abstract void Update();
        public abstract void End();
    }

    public class WaitStartStage : PKStage
    {
        public override void Begin()
        {
            pkStageType = PKStageType.WaitStart;
            duration = 3f;
            Debug.LogFormat("进入阶段：{0}", pkStageType);
            // opponentPlayer.ActorInfo.ResetHp((int)playerInfo.maxHp, -1, (int)playerInfo.maxHp, -1);
            opponentPlayer.ActorInfo.serverDie = false;
            opponentPlayer.IdleImmediate();
            // opponentPlayer.SkillMgr.ResetAllCD();
            GA_PVPClientPlayer.AutoAI(false);

            PlayerDatas.Instance.baseData.HP = PlayerDatas.Instance.extersion.MaxHP;
            var maxHp = PlayerDatas.Instance.extersion.MaxHP;
            PlayerDatas.Instance.hero.ActorInfo.ResetHp((long)maxHp, (long)maxHp);
            PlayerDatas.Instance.FightRefreshPlayerHp(maxHp);
            PlayerDatas.Instance.hero.IdleImmediate();
            PlayerDatas.Instance.hero.Behaviour.StopHandupAI(true);
            PlayerDatas.Instance.hero.StopPathFind();
            PlayerDatas.Instance.hero.SkillMgr.ResetAllCD();

            opponentPlayer.Pos = ClientCrossServerOneVsOne.myPlace == 1 ? rightBornPoint : leftBornPoint;
            PlayerDatas.Instance.hero.Pos = ClientCrossServerOneVsOne.myPlace == 1 ? leftBornPoint : rightBornPoint;
            ClientCrossServerOneVsOne.JiaWaitFight((int)duration);
        }

        public override void End()
        {
            fightInfo.roundCount++;
            ClientCrossServerOneVsOne.JiaFightBegin();
            ClientCrossServerOneVsOne.JiaRoundBegin(fightInfo.roundCount, fightInfo.roundWinnerIds.ToArray());
        }

        public override void Update()
        {
            timer += Time.deltaTime;
            completed = timer >= duration && opponentPlayer != null;
        }
    }

    public class FightStage : PKStage
    {
        bool figthCompleted = false;
        float restTime = 2f;
        float restTimeTimer = 0f;

        public override void Begin()
        {
            pkStageType = PKStageType.Fight;
            duration = 60f;
            roundWiner = 0;
            figthCompleted = false;
            restTimeTimer = 0f;

            opponentPlayer.Pos = ClientCrossServerOneVsOne.myPlace == 1 ? rightBornPoint : leftBornPoint;
            PlayerDatas.Instance.hero.Behaviour.StartHandupAI();
            GA_PVPClientPlayer.AutoAI(true);
            opponentPlayer.SelectTarget = PlayerDatas.Instance.hero;
            PlayerDatas.Instance.hero.SelectTarget = opponentPlayer;

            Debug.LogFormat("进入阶段：{0}", pkStageType);
        }

        public override void End()
        {
            fightInfo.roundWinnerIds.Add(roundWiner);//记录获胜者的id
            if (fightInfo.roundCount >= 2)
            {
                if (fightInfo.roundCount == 2)
                {
                    if (fightInfo.roundWinnerIds[0] == fightInfo.roundWinnerIds[1])
                    {
                        fightInfo.isOver = true;
                    }
                }
                else
                {
                    fightInfo.isOver = true;
                }
            }

            if (fightInfo.isOver)
            {
                PersonalEnemy.ReleasePlayer(opponentPlayer);
                opponentPlayer.Destroy();
            }

            ClientCrossServerOneVsOne.JiaRoundEnd(fightInfo.isOver, fightInfo.roundCount, fightInfo.roundWinnerIds.ToArray());
        }

        public override void Update()
        {
            timer += Time.deltaTime;
            if (!figthCompleted)
            {
                if (roundWiner != 0)
                {
                    figthCompleted = true;
                    PlayerDatas.Instance.hero.Behaviour.StopHandupAI(true);
                    PlayerDatas.Instance.hero.StopPathFind();
                    GA_PVPClientPlayer.AutoAI(false);
                }
                else if (timer >= duration)
                {
                    figthCompleted = true;
                    PlayerDatas.Instance.hero.Behaviour.StopHandupAI(true);
                    PlayerDatas.Instance.hero.StopPathFind();
                    GA_PVPClientPlayer.AutoAI(false);
                    if (PlayerDatas.Instance.hero.ActorInfo.RealHp >= opponentPlayer.ActorInfo.RealHp)
                    {
                        roundWiner = PlayerDatas.Instance.baseData.PlayerID;
                    }
                    else
                    {
                        roundWiner = ClientCrossServerOneVsOne.OPPONENT_PLAYERID;
                    }
                }
                else
                {
                    figthCompleted = false;
                }
            }

            if (figthCompleted)
            {
                restTimeTimer += Time.deltaTime;
                completed = restTimeTimer >= restTime;
            }
        }

    }

    public class RoundPrepareState : PKStage
    {
        public override void Begin()
        {
            pkStageType = PKStageType.RoundPrepare;
            GA_PVPClientPlayer.AutoAI(false);
            duration = 3f;
            Debug.LogFormat("进入阶段：{0}", pkStageType);

            if (fightInfo.roundWinnerIds[fightInfo.roundWinnerIds.Count - 1] == PlayerDatas.Instance.baseData.PlayerID)
            {
                if (!opponentPlayer.ActorInfo.serverDie)
                {
                    PersonalEnemy.ReleasePlayer(opponentPlayer);
                    opponentPlayer = null;
                }
                playerInfo.hp = playerInfo.maxHp;
                PersonalEnemy.Create(30000, ClientCrossServerOneVsOne.myPlace == 1 ? rightBornPoint : leftBornPoint, playerInfo);
                PersonalEnemy.OnPlayerAppear += OnPlayerAppear;
                SnxxzGame.Instance.StartCoroutine(WaitForPlayerCreate());

                // PlayerDatas.Instance.hero.SelectTarget = opponentPlayer;
                // opponentPlayer.ActorInfo.ResetHp((int)playerInfo.maxHp, -1, (int)playerInfo.maxHp, -1);
                // opponentPlayer.ActorInfo.serverDie = false;
                // opponentPlayer.IdleImmediate();
                // opponentPlayer.SkillMgr.ResetAllCD();

                if (PlayerDatas.Instance.hero.ActorInfo.RealHp <= 0)
                {
                    PlayerDatas.Instance.baseData.HP = 1;
                    PlayerDatas.Instance.hero.ActorInfo.ResetHp(1, (long)PlayerDatas.Instance.extersion.MaxHP);
                    PlayerDatas.Instance.FightRefreshPlayerHp(1);
                    PlayerDatas.Instance.hero.IdleImmediate();
                }
            }
            else
            {
                PlayerDatas.Instance.baseData.HP = PlayerDatas.Instance.extersion.MaxHP;
                var maxHp = PlayerDatas.Instance.extersion.MaxHP;
                PlayerDatas.Instance.hero.ActorInfo.ResetHp((long)maxHp, (long)maxHp);
                PlayerDatas.Instance.FightRefreshPlayerHp(maxHp);
                PlayerDatas.Instance.hero.IdleImmediate();
                PlayerDatas.Instance.hero.SkillMgr.ResetAllCD();

                if (opponentPlayer.ActorInfo.RealHp <= 0)
                {
                    opponentPlayer = null;
                    // opponentPlayer.ActorInfo.ResetHp(1, -1, (int)playerInfo.maxHp, -1);
                    // opponentPlayer.ActorInfo.serverDie = false;
                    // opponentPlayer.IdleImmediate();
                    playerInfo.hp = 1;
                    PersonalEnemy.Create(30000, ClientCrossServerOneVsOne.myPlace == 1 ? rightBornPoint : leftBornPoint, playerInfo);
                    PersonalEnemy.OnPlayerAppear += OnPlayerAppear;
                    SnxxzGame.Instance.StartCoroutine(WaitForPlayerCreate());
                }
            }

            PlayerDatas.Instance.hero.Pos = ClientCrossServerOneVsOne.myPlace == 1 ? leftBornPoint : rightBornPoint;
        
        }

        private void OnPlayerAppear(GA_PVPClientPlayer player)
        {
            PersonalEnemy.OnPlayerAppear -= OnPlayerAppear;
            opponentPlayer = player;
            opponentPlayer.Pos = ClientCrossServerOneVsOne.myPlace == 1 ? rightBornPoint : leftBornPoint;
        }

        private IEnumerator WaitForPlayerCreate()
        {
            while (opponentPlayer == null)
            {
                yield return null;
            }

            opponentPlayer.Pos = ClientCrossServerOneVsOne.myPlace == 1 ? rightBornPoint : leftBornPoint;
            opponentPlayer.ActorInfo.ResetHp((long)playerInfo.maxHp, (long)playerInfo.maxHp);
        }

        public override void End()
        {
            fightInfo.roundCount++;
            ClientCrossServerOneVsOne.JiaRoundBegin(fightInfo.roundCount, fightInfo.roundWinnerIds.ToArray());
        }

        public override void Update()
        {
            timer += Time.deltaTime;
            completed = timer >= duration && opponentPlayer != null;
        }
    }

    public class FightOverStage : PKStage
    {
        public override void Begin()
        {
            pkStageType = PKStageType.FightOver;
            duration = 10f;
            Debug.LogFormat("进入阶段：{0}", pkStageType);
            ClientCrossServerOneVsOne.ReportDungeonResult(new ClientCrossServerOneVsOne.FightResultSupplement()
            {
                endTime = TimeUtility.ServerNow,
                overType = 0,
                winPlayerId = (int)fightInfo.roundWinnerIds[fightInfo.roundWinnerIds.Count - 1],
                roundCount = fightInfo.roundCount,
                roundWinnerId = fightInfo.roundWinnerIds.ToArray(),
                opponentName = ClientCrossServerOneVsOne.opponentName,
            });

            ClientCrossServerOneVsOne.JiaDungeonExit((int)duration);
        }

        public override void End()
        {
            if (ClientCrossServerOneVsOne.isClientCrossServerOneVsOne)
            {
                ClientCrossServerOneVsOne.StopClientCrossServerOneVsOne();
            }
        }

        public override void Update()
        {
            timer += Time.deltaTime;
            completed = timer >= duration;
        }

    }

    public enum PKStageType
    {
        WaitStart,
        Fight,
        RoundPrepare,
        FightOver,
    }

    public struct FightInfo
    {
        public int myBornPoint;
        public bool isOver;
        public int roundCount;
        public List<uint> roundWinnerIds;
    }

}