using DG.Tweening;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace AibisDream
{
    public class Shaft : MonoBehaviour
    {
        [SerializeField]
        private int id;

        [SerializeField]
        public ShaftType shaftType;

        // 初始角速度
        [SerializeField]
        private float initialSpeed;

        // 初始齿轮
        [SerializeField]
        private GearModel gearModel;
        private GameObject childGear;

        // 目标角速度
        [SerializeField]
        private float targetSpeed;

        // 当前角速度
        private float currentSpeed;
        public float Speed
        {
            get { return currentSpeed; }
            set
            {
                currentSpeed = value;
                UpdateSpeedAnima();
            }
        }

        /// <summary>
        /// 当前齿轮半径
        /// </summary>
        public float GearRadius
        {
            get
            {
                if (childGear == null)
                {
                    return 0;
                }

                if (shaftType == ShaftType.Pluggable)
                {
                    Gear gear = childGear.GetComponent<Gear>();
                    return gear.data.radius;
                }
                else
                {
                    return gearModel.radius;
                }
            }
        }

        private GearController gearController;

        private void Awake()
        {
            gearController = transform.parent.parent.GetComponent<GearController>();
        }

        /// <summary>
        /// 初始化当前轴位置
        /// </summary>
        public void InitShaft()
        {
            // 如果不带齿轮
            if (gearModel == null) { return; }

            // 如果带齿轮，要根据齿轮类型生成
            if (shaftType == ShaftType.Pluggable)
            {
                // 初始化可插拔齿轮
                childGear = InitPluggableGear();
            }
            else
            {
                // 初始化固定齿轮
                childGear = InitStaticGear();
            }

            Speed = initialSpeed;
        }

        private GameObject InitStaticGear()
        {
            GameObject staticGear = transform.GetChild(0).gameObject;

            // 添加齿轮图片
            staticGear.SetActive(true);
            staticGear.GetComponent<SpriteRenderer>().sprite = Resources.Load<Sprite>(gearModel.spriteName);
            // 如果有初速，就要开始转动了
            if (!CommonUtil.IsZero(initialSpeed))
            {
                staticGear.transform.DORotate(new Vector3(0, 0, 360), 1 / initialSpeed, RotateMode.FastBeyond360).SetEase(Ease.Linear).SetLoops(-1);
            }

            return staticGear;
        }

        private GameObject InitPluggableGear()
        {
            return gearController.InitGear(transform.position, gearModel, initialSpeed);
        }

        public void PlugInGear(Gear gear)
        {
            childGear = gear.gameObject;
        }

        /// <summary>
        /// 速度修改后改变动画
        /// </summary>
        private void UpdateSpeedAnima()
        {
            // 没有齿轮的不需要旋转
            if (!HasChildGear())
            {
                return;
            }

            if (CommonUtil.IsZero(Speed))
            {
                childGear.transform.DOPause();
                return;
            }

            // 更新动画
            childGear.transform.DOKill();
            childGear.transform.DORotate(new Vector3(0, 0, 360), 1 / Speed, RotateMode.FastBeyond360).SetEase(Ease.Linear).SetLoops(-1);
        }

        /// <summary>
        /// 判断是否带齿轮
        /// </summary>
        /// <returns>是否带齿轮</returns>
        public bool HasChildGear()
        {
            return childGear != null;
        }

        /// <summary>
        /// 判断两个轴是否齿轮相接
        /// </summary>
        /// <param name="shaft1">轴1</param>
        /// <param name="shaft2">轴2</param>
        /// <returns>是否相接</returns>
        public static bool IsShaftConnected(Shaft shaft1, Shaft shaft2)
        {
            // 如果轴上无齿轮就不计算
            if (shaft1 == null || shaft2 == null)
            {
                return false;
            }
            if (shaft1.childGear == null || shaft2.childGear == null)
            {
                return false;
            }
            // 如果两个都有齿轮，就判断是否相邻
            float distence = (shaft1.transform.position - shaft2.transform.position).magnitude;
            float radiusSum = shaft1.GearRadius + shaft2.GearRadius;

            return distence < radiusSum;
        }

        /// <summary>
        /// 求两个轴角速度之比
        /// </summary>
        /// <param name="shaft1">轴1</param>
        /// <param name="shaft2">轴2</param>
        /// <returns>角速度之比</returns>
        public static float CalcAngularVelocityRatio(Shaft shaft1, Shaft shaft2)
        {
            return shaft1.GearRadius / shaft2.GearRadius;
        }
    }

    public enum ShaftType
    {
        Driver, // 拥有初始速度，没有目标速度，全局仅有一个
        Target, // 没有初始速度，有目标速度，全局有多个
        Constant, // 没有初始速度，没有目标速度，不可拖动
        Pluggable // 没有初始速度，没有目标速度，可拔插
    }
}