using System;
using AibisDream.FixSystem;
using AibisDream.Framework;
using AibisDream.Utility;
using Cinemachine;
using UnityEngine;
using UnityEngine.Events;

namespace AibisDream
{
    public class EngineSystem : MonoBehaviour
    {
        private CordPull _cordPull;
        private StaticGear _centerGear;

        [Header("系统配置")] public EngineConfig engineConfig;
        [Header("系统数据")] public EngineData engineData;
        
        public bool isAvailable;

        [HideInInspector] public UnityEvent<float> updateSpeedEvent = new();

        [SerializeField] private float coverMoveDuration = 5f;

        [SerializeField] private float coverMoveDistance = 2.8f;

        private void Awake()
        {
            FixSystemCenter.SystemDic.Register(this);
            _cordPull = transform.Find("拉绳").GetComponent<CordPull>();
            _centerGear = transform.Find("中央齿轮").GetComponent<StaticGear>();

            // 注册相机
            var virtualCam = transform.Find("Engine Camera").GetComponentInChildren<ICinemachineCamera>();
            CameraKit.Instance.RegisterCamera(CameraEnum.Engine, virtualCam);
        }

        private void Start()
        {
            // 初始化数据
            engineData = new EngineData
            {
                config = engineConfig
            };
            _centerGear.StartRotate();
        }

        private void OnDestroy()
        {
            CameraKit.Instance.UnRegisterCamera(CameraEnum.Engine);
        }

        public void Update()
        {
            // 收集数据
            engineData.curOil = _cordPull.GetCurOil();
            // 更新数据
            engineData.CalcSpeed();

            // 传递速度
            updateSpeedEvent.Invoke(engineData.GetRealSpeed());
        }

        /// <summary>
        /// 开启系统交互
        /// </summary>
        public void EnableSystem()
        {
            isAvailable = true;
        }

        /// <summary>
        /// 关闭系统交互
        /// </summary>
        public void DisableSystem()
        {
            isAvailable = false;
        }
    }

    [Serializable]
    public struct EngineConfig
    {
        public float oilRate;
        public float resistance;
        public float speedRate;
        public float targetDuration;
        public float pullMaxSpeed;
        public float retrunSpeed;
    }

    [Serializable]
    public struct EngineData
    {
        public EngineConfig config;
        public float curSpeed;
        public float curOil;
        public float curAcceleration;
        public bool isSuccess;
        public float reachTargetTime;

        public void CalcSpeed()
        {
            if (curOil != 0)
            {
                curAcceleration = curAcceleration < 0 ? 0 : curAcceleration;
                curAcceleration = CommonUtil.Limit(curOil * config.oilRate * Time.deltaTime + curAcceleration, 100, 0);
            }
            else
            {
                curAcceleration = -config.resistance * (1f + curSpeed);
            }


            curSpeed = CommonUtil.Limit(curSpeed + curAcceleration * Time.deltaTime, 1, 0);
        }

        public bool CheckSuccess()
        {
            // 已经成功就不用校验了
            if (isSuccess) return false;

            if (curSpeed >= 0.95f)
            {
                reachTargetTime += Time.deltaTime;
            }
            else
            {
                reachTargetTime = 0;
            }
            
            // 如果速度达标时间足够就判断成功
            if (!(reachTargetTime >= config.targetDuration)) return false;

            isSuccess = true;
            return true;
        }


        /// <summary>
        /// 获取处理后的速度
        /// </summary>
        /// <returns>速度</returns>
        public float GetRealSpeed()
        {
            return 1 + curSpeed * config.speedRate;
        }
    }
}