using System.Collections;
#if UNITY_6000_0_OR_NEWER
using Unity.Cinemachine;
#else
using Cinemachine;
#endif
using Convention.WindowsUI.Variant;
using UnityEngine;
using Demo.Game.Attr;
using System.IO;
using Convention;

namespace Demo.Game
{
    namespace ConfigType
    {
        public class CameraObjectConfig : ScriptLoadableConfig
        {
            public bool orthographic;
            public float fieldOfView;
            public float orthographicSize;
            public float nearClipPlane;
            public float farClipPlane;
            public float depth;
            public int VirtualCameraFollow;
            public int VirtualCameraLookAt;
            public Vector3 VirtualCameraFollowOffset;
            public Vector3 VirtualCameraLookAtDamping;

            public override void Deserialize(BinaryReader reader)
            {
                orthographic = BinarySerializeUtility.ReadBool(reader);
                fieldOfView = BinarySerializeUtility.ReadFloat(reader);
                orthographicSize = BinarySerializeUtility.ReadFloat(reader);
                nearClipPlane = BinarySerializeUtility.ReadFloat(reader);
                farClipPlane = BinarySerializeUtility.ReadFloat(reader);
                depth = BinarySerializeUtility.ReadFloat(reader);
                VirtualCameraFollow = BinarySerializeUtility.ReadInt(reader);
                VirtualCameraLookAt = BinarySerializeUtility.ReadInt(reader);
                VirtualCameraFollowOffset = BinarySerializeUtility.ReadVec3(reader);
                VirtualCameraLookAtDamping = BinarySerializeUtility.ReadVec3(reader);
                base.Deserialize(reader);
            }

            public override void Serialize(BinaryWriter writer)
            {
                BinarySerializeUtility.WriteBool(writer, orthographic);
                BinarySerializeUtility.WriteFloat(writer, fieldOfView);
                BinarySerializeUtility.WriteFloat(writer, orthographicSize);
                BinarySerializeUtility.WriteFloat(writer, nearClipPlane);
                BinarySerializeUtility.WriteFloat(writer, farClipPlane);
                BinarySerializeUtility.WriteFloat(writer, depth);
                BinarySerializeUtility.WriteInt(writer, VirtualCameraFollow);
                BinarySerializeUtility.WriteInt(writer,VirtualCameraLookAt);
                BinarySerializeUtility.WriteVec3(writer, VirtualCameraFollowOffset);
                BinarySerializeUtility.WriteVec3(writer, VirtualCameraLookAtDamping);
                base.Serialize(writer);
            }
        }
    }

    [Scriptable(nameof(MakeCameraObject))]
    public class CameraObject : ScriptableObject
    {
        private Camera MainCamera => Camera.main;
        private CinemachineCamera m_VirtualCamera;
        private CinemachineCamera VirtualCamera
        {
            get
            {
                if (m_VirtualCamera == null)
                    m_VirtualCamera = GetComponent<CinemachineCamera>();
                return m_VirtualCamera;
            }
        }

        public static CameraObject MakeCameraObject()
        {
            Transform mainCameraTransform = Editor.EditorController.instance.MainGameController.MainCameraTransform;
            if (mainCameraTransform.GetComponent<CameraObject>() != null)
            {
                Debug.LogError($"Too much {nameof(CameraObject)}", mainCameraTransform);
                return null;
            }
            // Binding Output
            FindFirstObjectByType<SceneGameWindow>().ModuleCamera =
                mainCameraTransform.gameObject.GetComponent<CinemachineCamera>();
            return mainCameraTransform.gameObject.AddComponent<CameraObject>();
        }

        public override IEnumerator UnloadScript()
        {
            yield return base.UnloadScript();
            FindFirstObjectByType<SceneGameWindow>().ModuleCamera = null;
        }

        /// <summary>
        /// 设置是否为正交相机
        /// </summary>
        [Convention.RScript.Variable.Attr.Method]
        public void SetOrthographic(bool orthographic)
        {
            MainCamera.orthographic = orthographic;
        }

        /// <summary>
        /// 设置相机视野角度
        /// </summary>
        [Convention.RScript.Variable.Attr.Method]
        public void SetFieldOfView(float fieldOfView)
        {
            MainCamera.fieldOfView = fieldOfView;
        }

        /// <summary>
        /// 设置正交相机的尺寸
        /// </summary>
        [Convention.RScript.Variable.Attr.Method]
        public void SetOrthographicSize(float orthographicSize)
        {
            MainCamera.orthographicSize = orthographicSize;
        }

        /// <summary>
        /// 设置近裁剪面距离
        /// </summary>
        [Convention.RScript.Variable.Attr.Method]
        public void SetNearClipPlane(float nearClipPlane)
        {
            MainCamera.nearClipPlane = nearClipPlane;
        }

        /// <summary>
        /// 设置远裁剪面距离
        /// </summary>
        [Convention.RScript.Variable.Attr.Method]
        public void SetFarClipPlane(float farClipPlane)
        {
            MainCamera.farClipPlane = farClipPlane;
        }

        /// <summary>
        /// 设置相机深度
        /// </summary>
        [Convention.RScript.Variable.Attr.Method]
        public void SetDepth(float depth)
        {
            MainCamera.depth = depth;
        }

        /// <summary>
        /// 设置虚拟相机跟随目标
        /// </summary>
        [Convention.RScript.Variable.Attr.Method]
        public void SetVirtualCameraFollow(ScriptableObject target)
        {
            VirtualCamera.Follow = target.transform;
        }

        /// <summary>
        /// 设置虚拟相机观察目标
        /// </summary>
        [Convention.RScript.Variable.Attr.Method]
        public void SetVirtualCameraLookAt(ScriptableObject target)
        {
            VirtualCamera.LookAt = target.transform;
        }

        /// <summary>
        /// 设置虚拟相机跟随偏移
        /// </summary>
        /// <param name="x">X轴偏移</param>
        /// <param name="y">Y轴偏移</param>
        /// <param name="z">Z轴偏移</param>
        [Convention.RScript.Variable.Attr.Method]
        public void SetVirtualCameraFollowOffset(float x, float y, float z)
        {
            var body = VirtualCamera.GetCinemachineComponent(CinemachineCore.Stage.Body) as CinemachineFollow;
            if (body != null)
            {
                body.FollowOffset = new Vector3(x, y, z);
            }
        }

        /// <summary>
        /// 设置虚拟相机跟随阻尼
        /// </summary>
        /// <param name="x">X轴阻尼</param>
        /// <param name="y">Y轴阻尼</param>
        /// <param name="z">Z轴阻尼</param>
        //[Convention.RScript.Variable.Attr.Method]
        //public void SetVirtualCameraFollowDamping(float x, float y, float z)
        //{
        //    var body = VirtualCamera.GetCinemachineComponent(CinemachineCore.Stage.Body) as CinemachineFollow;
        //    if (body != null)
        //    {
        //        body.XDamping = x;
        //        body.YDamping = y;
        //        body.ZDamping = z;
        //    }
        //}

        /// <summary>
        /// 设置虚拟相机观察阻尼
        /// </summary>
        /// <param name="x">X轴阻尼</param>
        /// <param name="y">Y轴阻尼</param>
        /// <param name="z">Z轴阻尼</param>
        [Convention.RScript.Variable.Attr.Method]
        public void SetVirtualCameraLookAtDamping(float x, float y, float z)
        {
            var aim = VirtualCamera.GetCinemachineComponent(CinemachineCore.Stage.Body) as CinemachineRotationComposer;
            if (aim != null)
            {
                aim.Damping = new(x, y);
            }
        }
    }
}