using Assets.MyGame.Scripts.Net;
using Assets.MyGame.Scripts.Net.API;
using Assets.MyGame.Scripts.Net.WebResponses;
using Newtonsoft.Json;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.InputSystem;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

public class GameMainPanel_XJMH : GameMainPanel_Base
{
    bool isOpenSetting;
    public Transform[] tra_SettingListPos;
    public Transform[] tra_SettingListComponent;
    public Button btn_SettingList;
    public GameObject turretParent_Left;


    public Animator mySitAnim;
    public Toggle toggle_SkillAuto;
    public Toggle toggle_Lock;
    public Toggle toggle_Three;
    bool isLock = false;
    bool isThree = false;
    //MonsterContral monCotl_Lock;
    public GameObject LockFX;
    public List<SitPosData> list_Sits = new List<SitPosData>();
    public SitPosData currSitData;

    int bulletCount = 0;

    public override void Awake()
    {
        base.Awake();
        EventCenter.Instance.AddEventListener<SyncGameData>(ConstEventString.SyncGameData_Rotate, SyncGameData_Rotate);
        EventCenter.Instance.AddEventListener<SyncGameData>(ConstEventString.SyncGameData_FireBullet, SyncGameData_FireBullit);
        EventCenter.Instance.AddEventListener<SyncGameData>(ConstEventString.SyncGameData_ChangeTargetMonster, SyncGameData_ChangeTargetMonster);

    }
    private void OnDestroy()
    {
        EventCenter.Instance.RemoveEventListener<SyncGameData>(ConstEventString.SyncGameData_Rotate, SyncGameData_Rotate);
        EventCenter.Instance.RemoveEventListener<SyncGameData>(ConstEventString.SyncGameData_FireBullet, SyncGameData_FireBullit);
        EventCenter.Instance.RemoveEventListener<SyncGameData>(ConstEventString.SyncGameData_ChangeTargetMonster, SyncGameData_ChangeTargetMonster);

    }
    public void JoinGame(int sitNum, long goldNum, long consumeGlod, int currentTurretID, UserToken user = null)
    {

        foreach (var item in list_Sits)
        {

            if (item.posID == sitNum)
            {
                item.gameObject.SetActive(true);
                if (user == null)
                {
                    user = GameManager.Instance.user;
                }
                item.user = user;
                item.goldNum = goldNum;
                item.consumeGoldNum = consumeGlod;
                item.tMP_GoldNum.text = goldNum.ToString();

                item.ChangeTurret(currentTurretID);
                item.tMP_TurretConsumeNum.text = consumeGlod.ToString();
            }
        }
    }
    bool isZD;
    public void Start()
    {

        CreateFishManager.Instance.EnterRoom(Assets.MyGame.Scripts.Net.APIResponses.Enum.GameTypeEnum.星际迷航);

        btn_SettingList.onClick.AddListener(() =>
        {
            if (isOpenSetting)
            {
                StartCoroutine(CloseSettingList());
            }
            else
            {
                StartCoroutine(OpenSettingList());
            }
        });
        toggle_Lock.onValueChanged.AddListener((a) =>
        {
            isLock = a;
            if (!a)
            {
                CancelLock();
            }

        });
        toggle_SkillAuto.onValueChanged.AddListener((a) =>
        {
           isZD = a;
        });
        
        toggle_Three.onValueChanged.AddListener((a) =>
        {
            isThree = a;

        });
        toggle_Shuang.onValueChanged.AddListener((a) =>
        {
            isShuang = a;
        });
        foreach (var item in tra_SettingListComponent)
        {
            if (item.name == "Setting")
            {
                item.GetComponent<Button>().onClick.AddListener(() =>
                {
                    UIManager.Instance.Close(UIPanel.MainGamePanelXJMH);
                    //等待界面添加
                    UIManager.Instance.ShowAsync(UIPanel.HomeMainPanel, UIPanel.MainGamePanelXJMH);
                });
            }
        }
    }
    #region 打开关闭右上角设置选项
    private IEnumerator OpenSettingList()
    {
        tra_SettingListComponent[tra_SettingListComponent.Length - 1].localScale = Vector3.one + Vector3.left * 2;
        isOpenSetting = true;
        int n = 0;
        while (true)
        {
            if (isOpenSetting == false)
            {
                yield break;
            }
            yield return null;
            for (int i = 0; i < tra_SettingListPos.Length; i++)
            {
                tra_SettingListComponent[i].position = Vector3.Lerp(tra_SettingListComponent[i].position, tra_SettingListPos[i].position, 0.5f);
                if (tra_SettingListComponent[i].position == tra_SettingListPos[i].position)
                {
                    n++;
                    if (n == tra_SettingListPos.Length)
                    {
                        yield break;
                    }
                }
            }
        }

    }
    private IEnumerator CloseSettingList()
    {
        tra_SettingListComponent[tra_SettingListComponent.Length - 1].localScale = Vector3.one;
        isOpenSetting = false;
        int n = 0;
        while (true)
        {
            if (isOpenSetting)
            {
                yield break;
            }
            yield return null;
            for (int i = 0; i < tra_SettingListPos.Length; i++)
            {
                tra_SettingListComponent[i].position = Vector3.Lerp(tra_SettingListComponent[i].position, tra_SettingListPos[tra_SettingListPos.Length - 1].position, 0.5f);
                if (tra_SettingListComponent[i].position == tra_SettingListPos[i].position)
                {
                    n++;
                    if (n == tra_SettingListPos.Length)
                    {
                        yield break;
                    }

                }
            }
        }
    }
    #endregion
    public float attackTime = 0.5f;
    float clickTime = 0;
    public GameObject bullet_Test;
    public GameObject bulletParent;
    float changeTurretTime = 0f;
    bool isChangingTurret = false;
    public void Update()
    {
        if (bulletCount >= 100)
        {
            SendBullet();
        }
        if (Touchscreen.current?.primaryTouch != null)
        {
            if (Touchscreen.current.primaryTouch.press.wasPressedThisFrame)
            {
                clickTime = attackTime;
            }
            #region 换炮台
            //Change Turret
            if (Touchscreen.current.primaryTouch.press.wasPressedThisFrame)
            {
                PointerEventData pointerData = new PointerEventData(EventSystem.current);
                pointerData.position = Touchscreen.current.primaryTouch.position.ReadValue();

                List<RaycastResult> results = new List<RaycastResult>();
                EventSystem.current.RaycastAll(pointerData, results);

                foreach (RaycastResult result in results)
                {
                    if (result.gameObject.tag == "ChangeTurret")
                    {
                        if (result.gameObject.GetComponentInParent<SitPosData>() == currSitData)
                        {
                            isChangingTurret = true;
                            return;
                        }

                    }
                }

            }
            if (Touchscreen.current.primaryTouch.press.isPressed)
            {
                if (isChangingTurret)
                {
                    changeTurretTime += Time.deltaTime;
                     
                    if (changeTurretTime > 1f)
                    {
                        if (!currSitData.changeTurretList.activeSelf)
                        {
                            //切换炮台面板
                            currSitData.changeTurretList.SetActive(true);
                        }
                    }
                    return;
                }
            }
            if (Touchscreen.current.primaryTouch.press.wasReleasedThisFrame)
            {
                if (isChangingTurret)
                {
                    changeTurretTime = 0;
                    isChangingTurret = false;
                    return;
                }

            }
            #endregion
            foreach (var item in list_Sits)
            {

            }
            if (isLock)
            {

                if (currSitData.monCotl_Lock == null)
                {
                    CancelLock();
                }
                //发射射线检测
                //发射完成后根据要求已有的子弹拐弯
                if (Touchscreen.current.primaryTouch.press.wasPressedThisFrame)
                {
                    Vector2 worldPos = Camera.main.ScreenToWorldPoint(Touchscreen.current.primaryTouch.position.ReadValue());
                    RaycastHit2D hit = Physics2D.Raycast(worldPos, Vector2.zero, 50, LayerMask.GetMask("Fish"));
                    currSitData.monCotl_Lock = hit.transform?.GetComponentInParent<MonsterContral>();

                    if (currSitData.monCotl_Lock != null && currSitData.monCotl_Lock.gameObject.activeSelf) //这里为之后加对象池铺垫
                    {
                        foreach (BullitMove item in bulletParent.GetComponentsInChildren<BullitMove>())
                        {
                            item.Lock(currSitData.monCotl_Lock);

                            

                        }
                        {
                            SyncGameData sgd = new SyncGameData
                            {
                                sitPos = currSitData.posID,
                                frameType = FrameDataType.changeAutoTarget,
                                frameData = new FrameData_ChangeAutoTarget
                                {
                                    targetGuid = currSitData.monCotl_Lock.guid,
                                }
                            };

                            WebSocketSendList.SyncGameData(sgd);
                        }

                        if (!LockFX.activeSelf)
                        {
                            LockFX.SetActive(true);
                            {
                                SyncGameData sgd = new SyncGameData
                                {
                                    sitPos = currSitData.posID,
                                    frameType = FrameDataType.changeAutoTarget,
                                    frameData = new FrameData_ChangeAutoTarget
                                    {
                                        targetGuid = currSitData.monCotl_Lock.guid,
                                    }
                                };

                                WebSocketSendList.SyncGameData(sgd);
                            }
                        }
                    }
                    else
                    {
                        CancelLock();
                    }
                }
                if (currSitData.monCotl_Lock != null)
                {
                    SelfPaoTaRotate();
                    LockFX.transform.position = currSitData.monCotl_Lock.transform.position;
                    //FireBullit();
                }

            }
            else
            {

                if (Touchscreen.current.primaryTouch.press.isPressed)
                {
                    //FireBullit();
                    if (!isZD)
                    {
                        SelfPaoTaRotate();
                    }
                    
                }
            }
            if (Touchscreen.current.primaryTouch.press.wasReleasedThisFrame)
            {
                SendBullet();
            }
        }

        if (isZD&&isLock==false)
        {
            SelfPaoTaRotate();
        }
    }

    private void SendBullet()
    {
        //if (bulletCount > 0)
        //    WebSocketSendList.ShootBullet(GameManager.Instance.gameData.currRoomData.roomId, currSitData.user.id, currSitData.consumeGlodNum, bulletCount);
        bulletCount = 0;
    }

    private void SelfPaoTaRotate()
    {

        #region 计算点击方向
        Vector2 touchPos;
        // 获取触摸位置（屏幕坐标）
        if (currSitData.monCotl_Lock != null)
        {
            touchPos = Camera.main.WorldToScreenPoint(currSitData.monCotl_Lock.transform.position);
        }
        else
        {
            touchPos = Touchscreen.current.primaryTouch.position.ReadValue();
        }

        // 转换Canvas坐标
        Vector2 worldPos;
        RectTransformUtility.ScreenPointToLocalPointInRectangle(currSitData.tra_CurrTurret.transform.parent as RectTransform, touchPos, null, out worldPos);
        // 计算方向
        Vector2 dir = worldPos - currSitData.tra_CurrTurret.GetComponent<RectTransform>().anchoredPosition;
        // 计算角度
        float angle = Mathf.Atan2(dir.y, dir.x) * Mathf.Rad2Deg - 90f;



        
        SetSitTurretRotame(currSitData,angle);

    }
    public void SyncGameData_Rotate(SyncGameData syncGameData)
    {
        if (syncGameData.sitPos!=currSitData.posID)
        {
            var rotateData = JsonConvert.DeserializeObject<FrameData_Rotate>(syncGameData.frameData.ToString());
            SetSitTurretRotame(list_Sits[syncGameData.sitPos], rotateData.angle, false);
        }
    }
    float frameTime=0;
    //IEnumerator RotateIE(SitPosData sitPosData, Quaternion qua)
    //{

    //    while (true)
    //    {
    //        yield return null;

    //        sitPosData.tra_CurrTurret.transform.rotation =Quaternion.Lerp(sitPosData.tra_CurrTurret.transform.rotation,qua,0.6f);
    //    }

    //}
    IEnumerator RotateIE_Angle(SitPosData sitPosData, Quaternion qua)
    {
        // 设置一个较小的阈值，判断是否旋转到位
        float angleThreshold = 0.1f; // 当角度差小于0.1度时停止

        while (true)
        {
            // 计算当前旋转和目标旋转之间的角度差
            float angleDifference = Quaternion.Angle(sitPosData.tra_CurrTurret.transform.rotation, qua);

            // 如果角度差很小，认为旋转完成
            if (angleDifference <= angleThreshold)
            {
                // 强制设置最终旋转，避免微小误差
                sitPosData.tra_CurrTurret.transform.rotation = qua;
                break; // 退出循环
            }

            // 执行旋转插值
            sitPosData.tra_CurrTurret.transform.rotation = Quaternion.Lerp(
                sitPosData.tra_CurrTurret.transform.rotation,
                qua,
                0.6f  // 这个系数决定了旋转速度
            );

            yield return null; // 等待下一帧
        }

        Debug.Log("旋转完成");
    }
    IEnumerator RotateIE_Time(SitPosData sitPosData, Quaternion qua)
    {
        float rotateDuration = 0.3f; // 旋转持续时间
        float elapsedTime = 0f;
        Quaternion startRotation = sitPosData.tra_CurrTurret.transform.rotation;

        while (elapsedTime < rotateDuration)
        {
            elapsedTime += Time.deltaTime;
            float t = elapsedTime / rotateDuration;

            // 使用Slerp进行更平滑的球面插值
            sitPosData.tra_CurrTurret.transform.rotation = Quaternion.Slerp(
                startRotation,
                qua,
                t
            );

            yield return null;
        }

        // 确保最终旋转精确
        sitPosData.tra_CurrTurret.transform.rotation = qua;
    }
    private Coroutine currentRotateCoroutine;
    private void SetSitTurretRotame(SitPosData sitPosData,float angle, bool isSelf = true)
    {

        
        if (isSelf==false)
        {
            Vector3 v3 = Vector3.forward * angle;
            // 如果已有协程在运行，先停止它
            if (currentRotateCoroutine != null)
            {
                StopCoroutine(currentRotateCoroutine);
                currentRotateCoroutine = null;
            }

            // 启动新的协程并保存引用
            currentRotateCoroutine = StartCoroutine(RotateIE_Angle(sitPosData, Quaternion.Euler(v3)));
            //StartCoroutine(RotateIE(sitPosData,));
            return ;
        }
        else
        {
            sitPosData.tra_CurrTurret.transform.rotation = Quaternion.Euler(Vector3.forward * angle);
            frameTime += Time.deltaTime;
            if (frameTime > 0.1f)
            {
                {
                    SyncGameData sgd = new SyncGameData
                    {
                        sitPos = currSitData.posID,
                        frameType = FrameDataType.rotateTurrect,
                        frameData = new FrameData_Rotate
                        {
                            angle = angle,
                        }
                    };

                    WebSocketSendList.SyncGameData(sgd);
                }
            }
        }
            
        #endregion

        clickTime += Time.deltaTime;
        if (clickTime > attackTime)
        {
            clickTime = 0;

        }
        else
        {
            return;
        }

     
        FireBullit(currSitData,angle,isThree,isZD,isLock,isShuang);
        {
            SyncGameData sgd = new SyncGameData
            {
                sitPos = currSitData.posID,
                frameType = FrameDataType.fireBullet,
                frameData = new FrameData_FireBullit
                {
                    angle = angle,
                    gold = currSitData.goldNum,
                    isSanShe = isThree,
                    twoRTruuect = isShuang,
                    isSuoDing = isLock,
                    auto = isZD
                }
            };

            WebSocketSendList.SyncGameData(sgd);
        }
    }

    private void CancelLock() { currSitData.monCotl_Lock = null; LockFX.SetActive(false); }
    public void SyncGameData_FireBullit(SyncGameData syncGameData)
    {
        if (syncGameData.sitPos != currSitData.posID)
        {
            var fireBullet = JsonConvert.DeserializeObject<FrameData_FireBullit>(syncGameData.frameData.ToString());
            FireBullit(list_Sits[syncGameData.sitPos], fireBullet.angle, fireBullet.isSanShe, fireBullet.auto, fireBullet.isSuoDing, fireBullet.twoRTruuect, false);
        }
    }
    public void SyncGameData_ChangeTargetMonster(SyncGameData syncGameData)
    {
        if (syncGameData.sitPos != currSitData.posID)
        {
            var fireBullet = JsonConvert.DeserializeObject<FrameData_ChangeAutoTarget>(syncGameData.frameData.ToString());
            list_Sits[syncGameData.sitPos].monCotl_Lock = CreateFishManager.Instance.fishDatas_hashCodekey[fireBullet.targetGuid];
            list_Sits[syncGameData.sitPos].isLock = true;
        }
    }
    private void FireBullit(SitPosData sitPosData,float angle, bool isSanShe, bool auto, bool isSuoDing,bool twoRTruuect, bool isSelf=true)
    {

       
        //计算方向
        Vector2 startV2;
            startV2 = CoordinateTransformation.AnchoredPos_ToCanvas(sitPosData.tra_CurrTurret.transform.GetChild(1).GetComponent<RectTransform>(), UIManager.Instance.uiRoot.GetComponent<Canvas>());
            startV2 = CoordinateTransformation.CanvasToWorld(startV2, UIManager.Instance.uiRoot.GetComponent<RectTransform>(), Camera.main);

            //Vector2 endV2 = touchPos;
            //var vectorTarget = endV2 - startV2;
            //var a = Mathf.Atan2(vectorTarget.y, vectorTarget.x) * Mathf.Rad2Deg;
            //obj_CurrTurret.GetComponent<SkeletonAnimation>()


            if (isSanShe)
            {
                BullitMove bulletMove1 = CreateBullet(angle - 20, startV2, sitPosData, Guid.NewGuid().ToString(), twoRTruuect);
                BullitMove bulletMove2 = CreateBullet(angle, startV2, sitPosData, Guid.NewGuid().ToString(), twoRTruuect);
            BullitMove bulletMove3 = CreateBullet(angle + 20, startV2, sitPosData, Guid.NewGuid().ToString(), twoRTruuect);
            if (isSuoDing)
                {
                    bulletMove1?.Lock(sitPosData.monCotl_Lock);
                    bulletMove2?.Lock(sitPosData.monCotl_Lock);
                    bulletMove3?.Lock(sitPosData.monCotl_Lock);
                }
            }
            else
            {
                BullitMove bulletMove = CreateBullet(angle, startV2, sitPosData, Guid.NewGuid().ToString(), twoRTruuect);
                if (isSuoDing)
                {
                    bulletMove?.Lock(sitPosData.monCotl_Lock);
                }
            }

        
    }

    public Toggle toggle_Shuang;
    bool isShuang= false;
    private BullitMove CreateBullet(float angle, Vector2 startV2, SitPosData roomJoinNotice,string guid,bool twoRTruuect)
    {

        GameObject bulletPrefab;
        //这里有双倍炮台的需求
        if (twoRTruuect)
        {
            bulletPrefab = roomJoinNotice.currentTurret.bulletPrefab_Two;
            if (!roomJoinNotice.ConsumeGold(2))
            {
                return null;
            }
        }
        else
        {
            bulletPrefab = roomJoinNotice.currentTurret.bulletPrefab;
            if (!roomJoinNotice.ConsumeGold())
            {
                return null;
            }
        }
        var bulletMove = Instantiate(bulletPrefab, startV2, Quaternion.Euler(Vector3.forward * angle), bulletParent.transform).GetComponent<BullitMove>();
        bulletMove.user = roomJoinNotice.user;
        bulletMove.playerID = roomJoinNotice.user.id;
        bulletMove.bulletID= guid;
        roomJoinNotice.skeletonAnimation.AnimationState.SetAnimation(0, "shot", false);
        bulletCount++;

        return bulletMove;
    }
    bool isfirstShow=false;
    protected override void OnShow(object args = null)
    {
        base.OnShow(args);
        //UIManager.Instance.ShowBoard("太好看了");
        var v = JsonConvert.DeserializeObject<WebSocketResponseBase<RoomJoinNotice>>(args.ToString());
        if (v.arguments.Count > 0)
        {
            
            RoomJoinNotice roomJoinNotice = v.arguments[0];
            if (isfirstShow == false)
            {
                
                foreach (var item in GameManager.Instance.gameData.currRoomData.players)
                {
                    JoinGame(item.position, item.gold, item.cannonMultiple, 1);
                }
                GameManager.Instance.gameData.roomJoinNotice = v.arguments[0];
                isfirstShow = true;
                currSitData = list_Sits[roomJoinNotice.position];
                //currSitData.ChangeTurret(1);
            }
            else
            {
                JoinGame(roomJoinNotice.position, roomJoinNotice.gold, roomJoinNotice.cannonMultiple, 1);
               
            }
            
          
            
            
            
        }
        else
        {
            UIManager.Instance.ShowBoard("获取信息失败");
        }

    }

    protected override void OnHide()
    {
        base.OnHide();
        CreateFishManager.Instance.ExitRoom();
        SceneManager.UnloadSceneAsync("XJMH");
        WebSocketSendList.LeaveRoom(GameManager.Instance.gameData.currRoomData.roomId,currSitData.user.id);
        
    }
}