using Games.Events;
using Games.GlobeDefine;
using Games.LogicObj;
using Games.Scene;
using GCGame;
using GCGame.Table;
using Module.Log;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace Games.LogicObj
{
    public struct WCBingObjInfo
    {
        public ulong _Guid;
        public Transform _BindParent;
        public int _AnimationId;
        public float _ScaleVal;
        public WCBingObjInfo(ulong guid, Transform bindParent, int animationId, float scalVal)
        {
            _Guid = guid;
            _BindParent = bindParent;
            _AnimationId = animationId;
            _ScaleVal = scalVal;
        }
    }

    public class Obj_Init_WeddingCar : Obj_Character_Init_Data
    {
        public int _SceneId;
        public int _SceneInsId;
        public ulong _OwnerAId;
        public ulong _OwnerBId;
        public int _RoleBaseAttrId;

        public Obj_Init_WeddingCar()
        {
            CleanUp();
        }

        public override void CleanUp()
        {
            base.CleanUp();
            _SceneId = -1;
            _SceneInsId = -1;
            _OwnerAId = 0;
            _OwnerBId = 0;
            _RoleBaseAttrId = -1;
        }
    }
}

public class Obj_WeddingCar : Obj_Character
{
    private Obj_Init_WeddingCar initData = null;
    private const string _BindPointPathA = "PointA";
    private const string _BindPointPathB = "PointB";
    private const int _AnimationIdA = 37;
    private const int _AnimationIdB = 38;
    private NexusMover _mover;
    private bool _init;

    public override UIPathData HeadUiPath
    {
        get { return Obj_GuildGharryHeadUI.pathData; }
    }

    private float _CurScaleVal = 1.0f;
    public override bool Init(ObjParent_Init_Data initData1)
    {
        speedAdaption = true;
        var result = base.Init(initData1);
        if (!result)
            return false;

        initData = initData1 as Obj_Init_WeddingCar;

        var roleBaseAttr = TableManager.GetRoleBaseAttrByID(initData._RoleBaseAttrId, 0);
        if (roleBaseAttr == null)
        {
            Debug.LogError("RoleBaseAttr is null : " + initData._RoleBaseAttrId);
            return false;
        }

        var charModel = TableManager.GetCharModelByID(roleBaseAttr.CharModelID, 0);
        if (null != charModel)
        {
            BaseAttr.HeadPic = charModel.HeadPic;
            m_DeltaHeight = charModel.HeadInfoHeight * ModelScale;
        }


        m_ObjTransform.localRotation = Utils.DirServerToClient(initData.m_fDir);
        _CurScaleVal = charModel.Scale;
        m_ObjTransform.localScale = charModel.Scale * Vector3.one;
        BaseAttr.MoveSpeed = initData.m_MoveSpeed;

        InitNavAgent();
        CreateNameBoard();
        ObjManager.Instance.AddPoolObj(this);
        CreateModel(roleBaseAttr.CharModelID);
        _mover = new NexusMover(roleBaseAttr.Id, this);
        return true;
    }
    public override void DestroyObj()
    {
        //SceneLogic.CameraController.OnWCMovie(false);
        if (SceneLogic.CameraController != null)
            SceneLogic.CameraController.ResetCameraToMainPlayer();
        if (_mover != null)
        {
            _mover.DestroyMover();
            _mover = null;
        }
        base.DestroyObj();
    }
    public void SetMoveSpeed()
    {
        if (NavAgent == null)
        {
            LogModule.ErrorLog("NavAgent is null");
            return;
        }
        NavAgent.speed = initData.m_MoveSpeed;
    }

    public override void InitNameBoard(Obj_HeadUI headUiItem)
    {
        base.InitNameBoard(headUiItem);
        HeadUi.Init(this);
        HeadUi.SetName(initData.m_StrName);
        HeadUi.SetOwnerName(initData.m_OwerName);
    }

    protected override void Update()
    {
        base.Update();
        if (_mover != null && MovementState == MoveState.Move)
        {
            // 初始化Mover - 需要至少有一个移动目标，才可能正确获得预判位置来生成前导角色
            if (!_init)
            {
                _init = true;
                if (!_mover.CreateMover())
                    _mover = null;
            }
            else
                _mover.SyncMovers();
        }
    }

    protected override void CreateModelOver(Hashtable hashParam)
    {
        base.CreateModelOver(hashParam);
        StartCoroutine(SetPlayer());
    }

    private Obj_OtherPlayer _PlayerA;
    private Obj_OtherPlayer _PlayerB;
    private Transform parentA = null;
    private Transform parentB = null;
    IEnumerator SetPlayer()
    {
        yield return null;
        
        while (_PlayerA == null)
        {
            _PlayerA = FindPlayerObj(initData._OwnerAId);
            yield return null;
        }

        while (_PlayerB == null)
        {
            _PlayerB = FindPlayerObj(initData._OwnerBId);
            yield return null;
        }

        while(parentA == null)
        {
            parentA = FindTransform(_BindPointPathA);
            yield return null;
        }

        while(parentB == null)
        {
            parentB = FindTransform(_BindPointPathB);
            yield return null;
        }

        SetPlayer(_PlayerA, parentA, (initData._RoleBaseAttrId == 2 || initData._RoleBaseAttrId == 3) ? _AnimationIdA : _AnimationIdB, initData._OwnerAId);
        SetPlayer(_PlayerB, parentB, (initData._RoleBaseAttrId == 2 || initData._RoleBaseAttrId == 3) ? _AnimationIdA : _AnimationIdB, initData._OwnerAId);

        yield break;
    }

    void SetPlayer(Obj_OtherPlayer obj, Transform parent, int animationId, ulong guid)
    {
        if (obj == null)
        {
            WCBingObjInfo info = new WCBingObjInfo(guid, parent, animationId, 1.0f / _CurScaleVal);
            if (GameManager.gameManager.PlayerDataPool._WCBindObjDic == null)
                GameManager.gameManager.PlayerDataPool._WCBindObjDic = new Dictionary<ulong, WCBingObjInfo>();

            if (!GameManager.gameManager.PlayerDataPool._WCBindObjDic.ContainsKey(guid))
                GameManager.gameManager.PlayerDataPool._WCBindObjDic.Add(guid, info);
            return;
        }

        obj.BindCloneModelToWC(parent, animationId, 1.0f / _CurScaleVal);
        if (IsWCMainplayer(obj.GUID))
            FocusOnCamera();
    }

    bool IsWCMainplayer(ulong guid)
    {
        if (GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Guid == guid)
        {
            Debug.LogError("Is WC player");
            return true;
        }
        return false;
    }

    void FocusOnCamera()
    {
        Debug.LogWarning("Focus Camera");
        if (SceneLogic.CameraController.MoveOverrider == null)
        {
            var overrider = new WeddingCarCameraMovement(this);
            SceneLogic.CameraController.SetCameraOverrider(overrider);
        }

        //if (GameManager.gameManager.PlayerDataPool.WCCamera == null)
        //{
        //    GameManager.gameManager.PlayerDataPool.WCCamera = transform.GetComponentInChildren<Camera>(true);
        //    GameManager.gameManager.PlayerDataPool.WCCamera.enabled = true;
        //}

        //if(GameManager.gameManager.PlayerDataPool.WCCamera == null)
        //{
        //    Debug.LogError("WCCamera is null");
        //    return;
        //}

        //if (!GameManager.gameManager.PlayerDataPool.WCCamera.isActiveAndEnabled)
        //    GameManager.gameManager.PlayerDataPool.WCCamera.gameObject.SetActive(true);

        //SceneLogic.CameraController.ChangeFocusObj(this);
        ////SceneLogic.CameraController.OnWCMovie(true);
    }

    private List<ObjBindFlag> bindPointList;
    Transform FindTransform(string path)
    {
        if (bindPointList == null)
        {
            bindPointList = new List<ObjBindFlag>();
            foreach (var bind in transform.GetComponentsInChildren<ObjBindFlag>())
            {
                bindPointList.Add(bind);
            }
        }

        for (int index = 0; index < bindPointList.Count; index++)
        {
            if (bindPointList[index].BindPointName.Equals(path))
                return bindPointList[index].gameObject.transform;
        }

        LogModule.ErrorLog("找不到 : " + path);
        return null;
    }

    Obj_OtherPlayer FindPlayerObj(ulong guid)
    {
        var obj = ObjManager.Instance.FindOtherPlayerByGuid(guid);
        return obj;
    }
}


public class WeddingCarCameraMovement : CameraController.CameraMovementOverrider
{
    private const float _minDistance = 10f;
    private const float _maxDistance = 30f;

    private const float _cameraPitch = 30f;
    private const float _cameraYaw =-135f;
    private const float _cameraDistance = 18f;
    private const float _fieldOfView = 45f;
    private static readonly Vector3 _focusPoint = Vector3.up * 3.9f + Vector3.back * 1.25f;

    private readonly Obj_WeddingCar _weddingCar;
    private float _pitch;
    private float _yaw;
    private float _distance;

    public WeddingCarCameraMovement(Obj_WeddingCar weddingCar)
    {
        _weddingCar = weddingCar;
    }

    public override bool MoveByOverride(CameraController controller)
    {
        var cameraMode = ProcessInput.Instance.inputModule.isCameraMode;
        var rotation = Quaternion.Euler(_pitch, _yaw, 0f);
        // 非CameraMode下
        if (!cameraMode)
        {
            rotation = _weddingCar.Rotation * rotation;
        }
        controller.transform.rotation = rotation;
        controller.transform.position =
            _weddingCar.Position + _weddingCar.Rotation * _focusPoint + rotation * Vector3.back * _distance;
        return true;
    }

    private void OnCameraModeChange(bool isCameraMode)
    {
        if (isCameraMode)
        {
            var rotation = _weddingCar.Rotation * Quaternion.Euler(_pitch, _yaw, 0f);
            var eular = rotation.eulerAngles;
            _pitch = eular.x;
            _yaw = eular.y;
        }
        else
        {
            var rotation = Quaternion.Inverse(_weddingCar.Rotation) * Quaternion.Euler(_pitch, _yaw, 0f);
            var eular = rotation.eulerAngles;
            _pitch = eular.x;
            _yaw = eular.y;
        }
    }

    public override void Start(CameraController controller)
    {
        SceneLogic.CameraController.SetNoCullByDist(true);
        SceneLogic.CameraController.SetCameraParameterListener(false);
        SceneLogic.CameraController.FoVValue = _fieldOfView;
        ProcessInput.Instance.inputModule.onCameraModeChange += OnCameraModeChange;
        ProcessInput.Instance.inputModule.processCamera.onCameraAngle += OnCameraAngle;
        ProcessInput.Instance.inputModule.processCamera.onCameraDistance += OnCameraDistance;
        _distance = _cameraDistance;
        // 将默认转换到世界坐标系
        if (ProcessInput.Instance.inputModule.isCameraMode)
        {
            var rotation = _weddingCar.Rotation * Quaternion.Euler(_cameraPitch, _cameraYaw, 0f);
            var eular = rotation.eulerAngles;
            _pitch = eular.x;
            _yaw = eular.y;
        }
        else
        {
            _pitch = _cameraPitch;
            _yaw = _cameraYaw;
        }
    }

    public override void End(CameraController controller)
    {
        SceneLogic.CameraController.SetNoCullByDist(false);
        SceneLogic.CameraController.SetCameraParameterListener(true);
        SceneLogic.CameraController.FoVValue = -1f;
        ProcessInput.Instance.inputModule.onCameraModeChange -= OnCameraModeChange;
        ProcessInput.Instance.inputModule.processCamera.onCameraAngle -= OnCameraAngle;
        ProcessInput.Instance.inputModule.processCamera.onCameraDistance -= OnCameraDistance;
    }

    private void OnCameraAngle(Vector2 delta)
    {
        _pitch = Mathf.Clamp(_pitch - delta.y * GlobeVar.pitchPerDpi, GlobeVar.minPitch, GlobeVar.maxPitch);
        _yaw = _yaw + delta.x * GlobeVar.yawPerDpi;
    }

    private void OnCameraDistance(float delta)
    {
        _distance = Mathf.Clamp(_distance - delta * GlobeVar.distancePerDpi, _minDistance, _maxDistance);
    }
}