using System;
using System.Collections;
using System.Collections.Generic;
using AibisDream.Kit;
using AibisDream.Utility;
using Cinemachine;
using DG.Tweening;
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
using UnityEngine;
using UnityEngine.Rendering.Universal;
using Yarn.Unity;

namespace AibisDream.Framework
{
    public class CameraKit : Singleton<CameraKit>
    {
        private const int LowPriority = 1;
        private const int HighPriority = 10;

        #region 相机组件

        private static Camera _mainCam;
        public static Camera UICamera => UIManager.Instance.UICamera;

        private CinemachineBrain _orthoCameraBrain;
        // private CinemachineBrain _perspectiveCameraBrain;
        private readonly Dictionary<CameraEnum, ICinemachineCamera> _virtualCameraDict = new();
        private readonly Dictionary<CameraEnum, CamState> _camInitStateDict = new();

        private CameraEnum _curCameraEnum;
        private CamState _curInitState;
        private Camera _orthoMainCamera;
        // private Camera _perspectiveMainCamera;

        private struct CamState
        {
            public Vector3 pos;
            public float initOrthoSize;
            public bool isPerspective;
        }

        #endregion

        private CameraKit()
        {
        }

        public override void OnSingletonInit()
        {
            // 获取正交相机
            _orthoMainCamera = Camera.main;
            _orthoCameraBrain = _orthoMainCamera?.GetComponent<CinemachineBrain>();

            // 获取透视相机
            // _perspectiveMainCamera = GameObject.Find("PerspectiveMainCamera")?.GetComponent<Camera>();
            // _perspectiveCameraBrain = _perspectiveMainCamera?.GetComponent<CinemachineBrain>();

            _curCameraEnum = CameraEnum.Default;
            
            // if (_orthoMainCamera && _perspectiveMainCamera)
            // {
            //     // 默认激活正交相机，禁用透视相机
            //     _orthoMainCamera.gameObject.SetActive(true);
            //     _perspectiveMainCamera.gameObject.SetActive(false);
            // }
        }

        #region 相机信息注册

        public void UpdateCameraViewport(bool reset = false)
        {
            foreach (var overlayCam in _orthoMainCamera.GetUniversalAdditionalCameraData().cameraStack)
            {
                overlayCam.UpdateCameraViewport(reset);
            }
            _orthoMainCamera.UpdateCameraViewport(reset);
        }
 
        public void RegisterUICamera(Camera overlayCamera)
        {
            // 获取 Main Camera 的 UniversalAdditionalCameraData
            var mainCameraData = _orthoMainCamera.GetUniversalAdditionalCameraData();
        
            if (mainCameraData != null)
            {
                // 检查 Overlay Camera 是否已经在 Stack 中
                if (!mainCameraData.cameraStack.Contains(overlayCamera))
                {
                    overlayCamera.UpdateCameraViewport();
                    // 将 Overlay Camera 添加到 Stack
                    mainCameraData.cameraStack.Insert(0, overlayCamera);
                    Debug.Log("Overlay Camera added to Main Camera stack.");
                }
            }
            else
            {
                Debug.LogError("Main Camera does not have UniversalAdditionalCameraData.");
            }
        }

        public void UnRegisterUICamera(Camera overlayCamera)
        {
            // 获取 Main Camera 的 UniversalAdditionalCameraData
            var mainCameraData = _orthoMainCamera.GetUniversalAdditionalCameraData();
        
            if (mainCameraData != null)
            {
                // 检查 Overlay Camera 是否已经在 Stack 中
                if (!mainCameraData.cameraStack.Contains(overlayCamera))
                {
                    // 将 Overlay Camera 添加到 Stack
                    mainCameraData.cameraStack.Remove(overlayCamera);
                    Debug.Log("Overlay Camera added to Main Camera stack.");
                }
            }
            else
            {
                Debug.LogError("Main Camera does not have UniversalAdditionalCameraData.");
            }
        }
        
        public void RegisterCamera(CameraEnum camType, ICinemachineCamera virtualCamera, bool isPerspective = false)
        {
            _virtualCameraDict[camType] = virtualCamera;

            var initState = new CamState
            {
                pos = virtualCamera.VirtualCameraGameObject.transform.localPosition,
                initOrthoSize = virtualCamera.VirtualCameraGameObject.gameObject
                    .GetComponent<CinemachineVirtualCamera>().m_Lens.OrthographicSize,
                isPerspective = isPerspective
            };
            _camInitStateDict[camType] = initState;
        }

        public void UnRegisterCamera(CameraEnum camType)
        {
            _virtualCameraDict.Remove(camType);
            _camInitStateDict.Remove(camType);
        }

        public void RemoveAllCam()
        {
            _virtualCameraDict.Clear();
            _camInitStateDict.Clear();
        }

        #endregion

        /// <summary>
        /// 检查当前是否需要切相机
        /// </summary>
        /// <param name="targetCameraState"></param>
        /// <returns>是就不用切相机</returns>
        public bool EqualToCameraState(CameraEnum targetCameraState)
        {
            return _curCameraEnum == targetCameraState;
        }

        /// <summary>
        /// 切换相机
        /// </summary>
        /// <param name="camType"></param>
        public IEnumerator SwitchCamera(CameraEnum camType)
        {
            var switchDuration = SwitchCameraSync(camType);
            yield return new WaitForSeconds(switchDuration);
        }

        private float SwitchCameraSync(CameraEnum camType)
        {
            if (_curCameraEnum == camType)
            {
                return 0;
            }

            if (!_virtualCameraDict.ContainsKey(camType))
            {
                Debug.Log($"{camType.ToString()}相机未注册");
                return 0;
            }

            // 切换主相机
            bool isPerspective = _camInitStateDict[camType].isPerspective;
            _orthoMainCamera.gameObject.SetActive(!isPerspective);
             // _perspectiveMainCamera.gameObject.SetActive(isPerspective);
            // var activeBrain = isPerspective ? _perspectiveCameraBrain : _orthoCameraBrain;
            var activeBrain = _orthoCameraBrain;

            // 设置虚拟相机优先级
            foreach (var camPair in _virtualCameraDict)
            {
                if (camPair.Key == camType) camPair.Value.Priority = HighPriority;
                if (camPair.Key != camType) camPair.Value.Priority = LowPriority;
            }

            _curInitState = _camInitStateDict[camType];
            var lastCamEnum = _curCameraEnum;
            _curCameraEnum = camType;

            // 切完之后记得复原
            ActionKit.Delay(activeBrain.m_DefaultBlend.BlendTime, () => ResetVirCam(lastCamEnum)).StartGlobal();

            return activeBrain.m_DefaultBlend.BlendTime;
        }

        public void ResetCamera()
        {
            _curCameraEnum = CameraEnum.Default;
            _camInitStateDict.Clear();
            _camInitStateDict.Clear();
        }

        private void ResetVirCam(CameraEnum cameraEnum)
        {
            if (cameraEnum == CameraEnum.Default)
            {
                return;
            }

            if (!_virtualCameraDict.TryGetValue(cameraEnum, out var virCam))
            {
                return;
            }
            
            var camState = _camInitStateDict[cameraEnum];
            virCam.VirtualCameraGameObject.transform.localPosition = camState.pos;
            var camObj = virCam.VirtualCameraGameObject.GetComponent<CinemachineVirtualCamera>();
            camObj.m_Lens.OrthographicSize = camState.initOrthoSize;
        }

        private Tween TransCamera(Vector3 targetPos, float targetOrthographicSize, float duration)
        {
            // 寻找现在正在激活的相机
            var curCamera = _orthoCameraBrain.ActiveVirtualCamera;

            var sq = DOTween.Sequence();
            // 移动
            sq.Join(curCamera.DOLocalMove(targetPos, duration));
            // 缩放
            sq.Join(curCamera.DOOrthoSize(targetOrthographicSize, duration));

            return sq;
        }

        private Tween ReturnInitCamera(float duration)
        {
            return TransCamera(_curInitState.pos, _curInitState.initOrthoSize, duration);
        }

        public IEnumerator TransCameraAsync(Vector3 targetPos, float targetOrthographicSize, float duration)
        {
            yield return TransCamera(targetPos, targetOrthographicSize, duration).WaitForCompletion();
        }

        public IEnumerator ReturnInitCameraAsync(float duration)
        {
            yield return ReturnInitCamera(duration).WaitForCompletion();
        }

        // 方法已废弃，后面改成用Cinemachine的Shake
        [Obsolete]
        public IEnumerator ShakeCamera(float duration, float strength, int vibrate)
        {
            var curCamera = _orthoCameraBrain.ActiveVirtualCamera;
            yield return curCamera.VirtualCameraGameObject.transform
                .DOShakePosition(duration, strength, vibrate, 90, false, false)
                .WaitForCompletion();
        }

        /// <summary>
        /// 获取当前激活的相机
        /// </summary>  
        public Camera GetCurrentCamera()
        {
            // return _camInitStateDict.TryGetValue(_curCameraEnum, out var state) && state.isPerspective
            //     ? _perspectiveMainCamera
            //     : _orthoMainCamera;

            return _orthoMainCamera;
        }

        /// <summary>
        /// 获取鼠标在世界中的位置
        /// </summary>
        /// <param name="mousePoint">鼠标界面位置</param>
        /// <returns>世界位置</returns>
        public static Vector3 GetMouseWorldPos(Vector3 mousePoint)
        {
            if (!_mainCam) _mainCam = Camera.main;
            var pos = _mainCam.ScreenToWorldPoint(mousePoint);
            return new Vector3(pos.x, pos.y, 0);
        }

        public static Vector3 GetScreenPos(Vector3 worldPos)
        {
            if (!_mainCam) _mainCam = Camera.main;

            worldPos.z = 0;
            return _mainCam.WorldToScreenPoint(worldPos);
        }
    }

    public static class CinemachineExtension
    {
        public static TweenerCore<Vector3, Vector3, VectorOptions> DOLocalMove(this ICinemachineCamera camera,
            Vector3 targetPos, float duration)
        {
            var transform = camera.VirtualCameraGameObject.gameObject.transform;
            return transform.DOLocalMove(targetPos, duration);
        }

        public static TweenerCore<float, float, FloatOptions> DOOrthoSize(this ICinemachineCamera camera,
            float endValue, float duration)
        {
            var virtualCamera = camera.VirtualCameraGameObject.GetComponent<CinemachineVirtualCamera>();
            var currentOrthoSize = virtualCamera.m_Lens.OrthographicSize;
            return DOTween.To(() => currentOrthoSize, x => currentOrthoSize = x, endValue, duration)
                .OnUpdate(() => virtualCamera.m_Lens.OrthographicSize = currentOrthoSize);
        }
        
        public static void UpdateCameraViewport(this Camera camera, bool reset = false)
        {
            if (reset)
            {
                camera.rect = new Rect(0, 0, 1, 1);
                return;
            }
            
            // 当前屏幕宽高比
            float windowAspect = (float)Screen.width / (float)Screen.height;
        
            // 计算缩放比例
            float scaleHeight = windowAspect / ConstRef.TargetAspect;
            
            Rect rect = camera.rect;
            if (scaleHeight < 1.0f)
            {
                // 添加黑边
                rect.width = 1.0f;
                rect.height = scaleHeight;
                rect.x = 0;
                rect.y = (1.0f - scaleHeight) / 2.0f;
            }
            else
            {
                // 如果宽高比大于目标，则无需添加黑边
                rect.width = 1.0f / scaleHeight;
                rect.height = 1.0f;
                rect.x = (1.0f - 1.0f / scaleHeight) / 2.0f;
                rect.y = 0;
            }

            camera.rect = rect;
        }
    }

    public static class CameraCommand
    {
        [YarnCommand("return_init_camera")]
        public static IEnumerator ReturnInitCamera(float duration = 1f)
        {
            return CameraKit.Instance.ReturnInitCameraAsync(duration);
        }

        [YarnCommand("trans_camera")]
        public static IEnumerator TransCameraAsync(float x, float y, float targetOrthographicSize, float duration)
        {
            Vector3 targetPos = new Vector3(x, y, -10);
            return CameraKit.Instance.TransCameraAsync(targetPos, targetOrthographicSize, duration);
        }

        [YarnCommand("shake_camera")]
        public static IEnumerator ShakeCamera(float duration, float strength, int vibrate = 10)
        {
            return CameraKit.Instance.ShakeCamera(duration, strength, vibrate);
        }

        [YarnCommand("switch_camera")]
        public static IEnumerator SwitchCamera(string targetStateStr)
        {
            // 字符串转枚举
            if (!Enum.TryParse<CameraEnum>(targetStateStr, out var targetState))
            {
                Debug.Log($"{targetStateStr}不在FixState枚举中");
                yield break;
            }

            yield return CameraKit.Instance.SwitchCamera(targetState);
        }
    }

    public enum CameraEnum
    {
        Default,
        Clinic,
        CoolingMachine,
        BodyModule,
        BodyModuleCenter,
        Memory,
        Logic,
        Eye,
        UF,
        Expression,
        Engine,
        Gear,
        EyeDeep,
        ExpressionDeep,
        Emo,
        EmoDeep,
        Op,
        CutEmo,
        CutMemory,
        CutLogic,
        CutEmoDeep,
        CutMemoryDeep,
        CutLogicDeep,
        BreakCamera,
        DreamCamera,
        Subway,
        SubwayTV,
        Language,
        LanguageDeep,
        AnalysisMode,
        AnalysisModeDeep,
        BlockPuzzle,
    }
}