using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace UnityCommon
{
    public class FlyState : CameraState
    {
        private float speed = 50;

        private Vector3 initPosition;
        private Quaternion initRotation;
        public FlyState(Camera camera, Vector3 position, Quaternion rotation) : base(camera)
        {
            initPosition = position;
            initRotation = rotation;
        }
        public override void Enter()
        {
            base.Enter();

            SetCameraPosition(initPosition, initRotation);
            targetCameraPos = initPosition;
            targetRotation = initRotation;
        }

        Vector3 targetCameraPos;
        Quaternion targetRotation = default;

        public override void OnMove(Vector3 vecDir)
        {
            if (!m_isAllReady) return;
            if (vecDir == Vector3.zero) return;
            vecDir *= speedScaleFactor;
            var axis_h = vecDir.x;
            var axis_v = vecDir.y;
            var axis_updown = vecDir.z;
            targetCameraPos = m_camera.transform.position + m_camera.transform.TransformDirection(new Vector3(axis_h, axis_updown, axis_v) * speed * Time.deltaTime);
            //m_camera.transform.Translate(axis_h * speed * Time.deltaTime, axis_updown * speed * Time.deltaTime, axis_v * speed * Time.deltaTime);
            //initPosition = m_camera.transform.position;

        }

        public override void Update()
        {
            base.Update();
            if (!m_isAllReady) return;
            //控制相机运动
            if (Vector3.Distance(m_camera.transform.position, targetCameraPos) > 0.1f)
            {
                m_camera.transform.position = Vector3.Lerp(m_camera.transform.position, targetCameraPos, 0.3f);
                initPosition = m_camera.transform.position;
            }
            //控制相机旋转 缓动效果
            if (Quaternion.Angle(m_camera.transform.rotation, targetRotation) > 0.1f)
            {
                m_camera.transform.rotation = Quaternion.Lerp(m_camera.transform.rotation, targetRotation, 0.1f);
                initRotation = m_camera.transform.rotation;
            }
        }

        //private float rotateFactor = 1;
        float xLimit = 89;//上下旋转角度限制

        public override void OnRotate(Vector2 vec2Rotate)
        {
            if (!m_isAllReady) return;
            var rotateDx = vec2Rotate.x; //*= speedScaleFactor
            var rotateDy = vec2Rotate.y; //*= speedScaleFactor
            if (vec2Rotate != Vector2.zero)
            {
                Vector3 angles = m_camera.transform.rotation.eulerAngles;
                angles.y += rotateDx;

                angles.x = Mathf.Repeat(angles.x + 180f, 360f) - 180f;
                angles.x -= rotateDy;
                angles.x = ClampAngle(angles.x, -xLimit, xLimit);

                targetRotation.eulerAngles = new Vector3(angles.x, angles.y, 0);

                //initRotation = targetRotation;
                m_camera.transform.rotation = targetRotation;

            }
        }

        public override void OnZoom(float zoom)
        {
            if (!m_isAllReady) return;

            if (zoom != 0)
            {
                zoom *= speedScaleFactor;
                //m_camera.transform.Translate(0, 0, zoom);
                targetCameraPos = m_camera.transform.position + m_camera.transform.TransformDirection(Vector3.forward * zoom);
                //initPosition = m_camera.transform.position;
            }
        }
        public override void OnAddSpeed(float addSpeed)
        {
            base.OnAddSpeed(addSpeed);
            speed = (addSpeed == 1) ? 200 : 50;
        }

        // 控制角度范围
        private float ClampAngle(float angle, float min, float max)
        {
            if (angle < -360f) angle += 360f;
            else if (angle > 360f) angle -= 360f;

            return Mathf.Clamp(angle, min, max);
        }
    }
}