#region Copyright RenGuiYou. All rights reserved.
//=====================================================
// NeatlyFrameWork
// Author:      RenGuiyou
// Feedback: 	mailto:750539605@qq.com
//=====================================================
#endregion

using UnityEngine;
using System.Collections.Generic;
using Neatly.UI;
using UnityEngine.UI;

namespace Neatly.Tween
{
    public class NeatlyTween : MonoBehaviour
    {
        private static NeatlyTween m_Instance;

        public static NeatlyTween Instance
        {
            get
            {
                if (m_Instance == null)
                {
                    Init();
                }
                return m_Instance;
            }
        }

        public static void Init()
        {
            GameObject go = new GameObject("~NeatlyTween");
            m_Instance = go.AddComponent<NeatlyTween>();
            DontDestroyOnLoad(go);
        }

        private static uint m_counter = 0;

        private static uint Counter
        {
            get
            {
                m_counter++;
                if (m_counter > uint.MaxValue - 1)
                {
                    m_counter = 1;
                }
                return m_counter;
            }
        }

        public delegate Vector2 PositionDelegate(float y);
        public delegate float AlphaDelegate(float y);
        private readonly List<NTweenImp> m_Tweens = new List<NTweenImp>();
        public TweenObjectPool<TweenRtPosObj> TweenRtPosPool = new TweenObjectPool<TweenRtPosObj>();
        public TweenObjectPool<NTweenImp> ImplementPool = new TweenObjectPool<NTweenImp>();

        private static NTweenImp CreateImplement(TweenObjectBase itween)
        {
            NTweenImp imp = Instance.ImplementPool.Create().Init(Counter, itween);
            Instance.m_Tweens.Add(imp);
            return imp;
        }

        // spline move
        public static NTweenImp FuncMove(RectTransform rt, float targetY, float time, PositionDelegate posResult,
            AlphaDelegate alphaResult)
        {
            TweenObjectBase itween = TweenFuncPosObj.Create(rt, targetY, time, posResult, alphaResult);
            return CreateImplement(itween);
        }

        public static NTweenImp Move(GameObject gameObject, float x, float y, float z, float time)
        {
            return Move(gameObject, new Vector3(x, y, z), time);
        }

        // Move (World Position)
        public static NTweenImp Move(GameObject gameObject, Vector3 target, float time)
        {
            TweenObjectBase itween = TweenRtPosObj.CreateMove(gameObject, target, time);
            return CreateImplement(itween);
        }

        public static NTweenImp MoveLocal(GameObject gameObject, float x, float y, float z, float time)
        {
            return MoveLocal(gameObject, new Vector3(x, y, z), time);
        }

        // Move (LocalPosition)
        public static NTweenImp MoveLocal(GameObject gameObject, Vector3 target, float time)
        {
            TweenObjectBase itween = TweenRtPosObj.CreateMoveLocal(gameObject, target, time);
            return CreateImplement(itween);
        }

        public static NTweenImp MoveUI(RectTransform rt, float x, float y, float time)
        {
            return MoveUI(rt, new Vector2(x, y), time);
        }

        // Move (UI)
        public static NTweenImp MoveUI(RectTransform rt, Vector2 target, float time)
        {
            TweenObjectBase itween = TweenRtPosObj.CreateMove(rt, target, time);
            return CreateImplement(itween);
        }

        // Move Bezier (UI)
        public static NTweenImp MoveBezier(RectTransform rt, Vector2 target, Vector2 bezier, float time)
        {
            TweenObjectBase itween = TweenRtPosObj.CreateBezierMove(rt, target, bezier, time);
            return CreateImplement(itween);
        }

        // Move Bezier (UI)
        public static NTweenImp MoveBezier(RectTransform rt, RectTransform target, float percent, float y, float time)
        {
            var bezier = NMathf.Lerp(rt.anchoredPosition, target.anchoredPosition, percent);
            bezier.y = y;
            TweenObjectBase itween = TweenRtPosObj.CreateBezierMove(rt, target.anchoredPosition, bezier, time);
            return CreateImplement(itween);
        }

        // Move Bezier (UI)
        public static NTweenImp MoveBezier(RectTransform rt, Vector2 target, float percent, float y, float time)
        {
            var bezier = NMathf.Lerp(rt.anchoredPosition, target, percent);
            bezier.y = y;
            TweenObjectBase itween = TweenRtPosObj.CreateBezierMove(rt, target, bezier, time);
            return CreateImplement(itween);
        }

        // Move X(UI)
        public static NTweenImp MoveX(RectTransform rt, float x, float time)
        {
            Vector2 target = new Vector2(x, rt.anchoredPosition.y);
            return MoveUI(rt, target, time);
        }

        // Move Y(UI)
        public static NTweenImp MoveY(RectTransform rt, float y, float time)
        {
            Vector2 target = new Vector2(rt.anchoredPosition.x, y);
            return MoveUI(rt, target, time);
        }

        public static NTweenImp SizeDeltaX(RectTransform rt, float val, float time)
        {
            Vector2 target = new Vector2(val, rt.sizeDelta.y);
            return SizeDelta(rt, target, time);
        }

        public static NTweenImp SizeDeltaY(RectTransform rt, float val, float time)
        {
            Vector2 target = new Vector2(rt.sizeDelta.x, val);
            return SizeDelta(rt, target, time);
        }

        public static NTweenImp SizeDelta(RectTransform rt, Vector2 target, float time)
        {
            TweenObjectBase itween = TweenRtPosObj.CreateSizeDelta(rt, target, time);
            return CreateImplement(itween);
        }

        // Scale
        public static NTweenImp Scale(Transform rt, Vector3 target, float time)
        {
            TweenObjectBase itween = TweenRtPosObj.CreateScale(rt, target, time);
            return CreateImplement(itween);
        }

        public static NTweenImp Scale(Transform rt, float scale, float time)
        {
            TweenObjectBase itween = TweenRtPosObj.CreateScale(rt, new Vector3(scale, scale, scale), time);
            return CreateImplement(itween);
        }

        // ScaleY
        public static NTweenImp ScaleY(Transform rt, float target, float time)
        {
            Vector3 v = rt.localScale;
            v.y = target;
            TweenObjectBase itween = TweenRtPosObj.CreateScale(rt, v, time);
            return CreateImplement(itween);
        }

        // Rotate
        public static NTweenImp Rotate(Transform rt, Vector3 target, float time)
        {
            TweenObjectBase itween = TweenRtPosObj.CreateRotate(rt, target, time);
            return CreateImplement(itween);
        }

        public static NTweenImp RotateX(Transform rt, float angle, float time)
        {
            Vector3 euler = rt.localEulerAngles;
            euler.x = angle;
            return Rotate(rt, euler, time);
        }

        public static NTweenImp RotateY(Transform rt, float angle, float time)
        {
            Vector3 euler = rt.localEulerAngles;
            euler.y = angle;
            return Rotate(rt, euler, time);
        }

        public static NTweenImp RotateZ(Transform rt, float angle, float time)
        {
            Vector3 euler = rt.localEulerAngles;
            euler.z = angle;
            return Rotate(rt, euler, time);
        }

        public static NTweenImp AutoRotate(Transform rt, Vector3 target, float time)
        {
            TweenObjectBase itween = TweenRtPosObj.CreateAutoRotate(rt, target, time);
            return CreateImplement(itween);
        }

        public static NTweenImp AutoRotateX(Transform rt, float angle, float time)
        {
            Vector3 euler = rt.localEulerAngles;
            euler.x = angle;
            return AutoRotate(rt, euler, time);
        }

        public static NTweenImp AutoRotateY(Transform rt, float angle, float time)
        {
            Vector3 euler = rt.localEulerAngles;
            euler.y = angle;
            return AutoRotate(rt, euler, time);
        }

        public static NTweenImp AutoRotateZ(Transform rt, float angle, float time)
        {
            Vector3 euler = rt.localEulerAngles;
            euler.z = angle;
            return AutoRotate(rt, euler, time);
        }

        // Graphic Color
        public static NTweenImp Color(Graphic graphic, Color target, float time)
        {
            TweenObjectBase itween = TweenRtPosObj.CreateColor(graphic, target, time);
            return CreateImplement(itween);
        }

        // Graphic Color
        public static NTweenImp ColorAlpha(Graphic graphic, float target, float time)
        {
            Color c = graphic.color;
            c.a = target;
            TweenObjectBase itween = TweenRtPosObj.CreateColor(graphic, c, time);
            return CreateImplement(itween);
        }

        // 文本跳动
        public static NTweenImp JumpVal(Text text, double startVal, double targetVal, float time)
        {
            TweenObjectBase itween = TweenJumpObj.Create(text, startVal, targetVal, time);
            return CreateImplement(itween);
        }

        // slider移动(直接到目标值)
        public static NTweenImp SliderMove(NSlider slider, float targetVal, float time)
        {
            TweenObjectBase itween = TweenSliderObj.Create(slider, targetVal, time);
            return CreateImplement(itween);
        }

        // slider移动(先到终点)
        public static NTweenImp SliderMoveDirect(Slider slider, float targetVal, float time, bool direct)
        {
            TweenObjectBase itween = TweenSliderDirectObj.Create(slider, targetVal, time, direct);
            return CreateImplement(itween);
        }

        // ImageFill
        public static NTweenImp ImageFill(NImage image, float targetVal, float time)
        {
            TweenObjectBase itween = TweenImgFillObj.Create(image, targetVal, time);
            return CreateImplement(itween);
        }

        void Update()
        {
            for (int i = m_Tweens.Count - 1; i >= 0; i--)
            {
                if (m_Tweens[i].IsDestroy)
                {
                    m_Tweens[i].Destroy();
                    m_Tweens.RemoveAt(i);
                    continue;
                }
                m_Tweens[i].Excute(Time.deltaTime);
            }
        }

        public static void Cancel(uint id)
        {
            if (id <= 0) return;
            for (int i = 0; i < Instance.m_Tweens.Count; i++)
            {
                if (Instance.m_Tweens[i].id == id)
                {
                    Instance.m_Tweens[i].Cancel();
                }
            }
        }

        public static void Cancel(GameObject gameObject)
        {
            if (Instance == null || gameObject == null) return;
            for (int i = 0; i < Instance.m_Tweens.Count; i++)
            {
                if (Instance.m_Tweens[i].gameObject == gameObject)
                {
                    Instance.m_Tweens[i].Cancel();
                }
            }
        }

        public static void Cancel(Component cmp)
        {
            if (Instance == null || cmp == null) return;
            for (int i = 0; i < Instance.m_Tweens.Count; i++)
            {
                if (Instance.m_Tweens[i].gameObject == cmp.gameObject)
                {
                    Instance.m_Tweens[i].Cancel();
                }
            }
        }

        public static void Pause(uint id)
        {
            for (int i = 0; i < Instance.m_Tweens.Count; i++)
            {
                if (Instance.m_Tweens[i].id == id)
                {
                    Instance.m_Tweens[i].Pause();
                }
            }
        }

        public static void Resume(uint id)
        {
            for (int i = 0; i < Instance.m_Tweens.Count; i++)
            {
                if (Instance.m_Tweens[i].id == id)
                {
                    Instance.m_Tweens[i].Resume();
                }
            }
        }
    }
}