using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Events;

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

public struct VecPair
{
    public Vector3 Key;
    public Vector3 Value;

    public VecPair(Vector3 key, Vector3 value)
    {
        Key = key;
        Value = value;
    }

    public VecPair(float x1, float y1, float z1, float x2, float y2, float z2)
    {
        Key = new Vector3(x1, y1, z1);
        Value = new Vector3(x2, y2, z2);
    }
}

public class StreamScale : StreamRoot 
{
    #region 变量

    public override bool InOrigin
    {
        get
        {
            if (Consecutive)
            {
                if (Target.localScale.Equal(DestList[0]))
                {
                    InOrigin_ = true;
                }
                else
                {
                    InOrigin_ = false;
                }
            }
            else
            {
                if (Target.localScale.Equal(DestKvList[0].Key))
                {
                    InOrigin_ = true;
                }
                else
                {
                    InOrigin_ = false;
                }
            }

            return InOrigin_;
        }
        set
        {
            InOrigin_ = value;

            InPause = false;
            InForward = false;
            InBackward = false;

            AtDestination = true;

            if (InOrigin_)
            {
                if (Consecutive)
                {
                    Target.localScale = DestList[0];
                }
                else
                {
                    Target.localScale = DestKvList[0].Key;
                }

                BackwardFinish();
            }
        }
    }

    public override bool InDestination
    {
        get
        {
            if (Consecutive)
            {
                if (Target.localScale.Equal(DestList.Back(0)))
                {
                    InDestination_ = true;
                }
                else
                {
                    InDestination_ = false;
                }
            }
            else
            {
                if (Target.localScale.Equal(DestKvList.Back(0).Value))
                {
                    InDestination_ = true;
                }
                else
                {
                    InDestination_ = false;
                }
            }

            return InDestination_;
        }
        set
        {
            InDestination_ = value;

            InPause = false;
            InForward = false;
            InBackward = false;

            AtOrigin = true;

            if (InDestination_)
            {
                if (Consecutive)
                {
                    Target.localScale = DestList.Back(0);
                }
                else
                {
                    Target.localScale = DestKvList.Back(0).Value;
                }

                ForwardFinish();
            }
        }
    }

    public Vector3 TempDest;
    public Vector3 TempDelta;
    public Vector3 TempOrigin;
    public List<VecPair> DestKvList = new List<VecPair>();
    public List<Vector3> DestList = new List<Vector3>();

    public Transform Target;
    public CurveFunctionV Func;

    #endregion

    public StreamScale(Transform target, List<float> delayList, List<float> durationList, List<VecPair> destKvList, bool originActive, bool destActive, Curve curve, bool cg = false, List<UnityAction> startActionList = null, List<UnityAction> finishActionList = null) : base(cg, curve, target)
    {
        Func = AnimManager.CurveFuncDicV[curve];
        Target = target;
        TotPhase = destKvList.Count - 1;
        Consecutive = false;

        DelayList = delayList;
        DestKvList = destKvList;
        DurationList = durationList;

        StartActionList = startActionList;
        FinishActionList = finishActionList;

        if (StartActionList.Valid())
        {
            if (DestKvList.Count != StartActionList.Count)
            {
                throw new Exception();
            }
        }

        if (FinishActionList.Valid())
        {
            if (DestKvList.Count != FinishActionList.Count)
            {
                throw new Exception();
            }
        }

        if (DestKvList.Count - DelayList.Count != 1)
        {
            throw new Exception();
        }

        if (DestKvList.Count - DurationList.Count != 0)
        {
            throw new Exception();
        }

        InForward = false;
        InBackward = false;

        DestActive = destActive;
        OriginActive = originActive;
    }

    public StreamScale(Transform target, List<float> delayList, List<float> durationList, List<Vector3> destList, bool originActive, bool destActive, Curve curve, bool cg = false, List<UnityAction> startActionList = null, List<UnityAction> finishActionList = null) : base(cg, curve, target)
    {
        Func = AnimManager.CurveFuncDicV[curve];
        Target = target;
        TotPhase = destList.Count - 1;
        Consecutive = true;

        DestList = destList;
        DelayList = delayList;
        DurationList = durationList;

        StartActionList = startActionList;
        FinishActionList = finishActionList;

        if (StartActionList.Valid())
        {
            if (DestList.Count - StartActionList.Count != 1)
            {
                throw new Exception();
            }
        }

        if (FinishActionList.Valid())
        {
            if (DestList.Count - FinishActionList.Count != 1)
            {
                throw new Exception();
            }
        }

        if (DestList.Count - DelayList.Count != 2)
        {
            throw new Exception();
        }

        if (DestList.Count - DurationList.Count != 1)
        {
            throw new Exception();
        }

        InForward = false;
        InBackward = false;

        DestActive = destActive;
        OriginActive = originActive;
    }


    public override bool StartForward()
    {
        if (base.StartForward())
        {
            return true;
        }
        
        if (InBackward)
        {
            InBackward = false;

            Phase = TotPhase - Phase;

            if (Consecutive)
            {
                TempDest = DestList[Phase];
                TempOrigin = DestList[Phase - 1];
                TempDuration = DurationList[Phase - 1];

                TempDelta = TempDest - TempOrigin;

                if (Phase != DestList.Count - 1)
                {
                    TempDelay = DelayList[Phase - 1];
                }
            }
            else
            {
                TempDest = DestKvList[Phase].Value;
                TempOrigin = DestKvList[Phase].Key;
                TempDuration = DurationList[Phase];

                TempDelta = TempDest - TempOrigin;

                if (Phase != DestKvList.Count - 1)
                {
                    TempDelay = DelayList[Phase];
                }
            }

            Timer = AnimManager.GetTimerVec(Target.localScale, TempDuration, TempOrigin, TempDelta, Curve);
        }
        else
        {
            if (Consecutive)
            {
                Phase = 1;
                TempDest = DestList[1];
                TempDelay = DelayList[0];
                TempOrigin = DestList[0];
                TempDuration = DurationList[0];
            }
            else
            {
                Phase = 0;
                TempDest = DestKvList[0].Value;
                TempDelay = DelayList[0];
                TempOrigin = DestKvList[0].Key;
                TempDuration = DurationList[0];
            }

            TempDelta = TempDest - TempOrigin;

            if (StartActionList.Valid())
            {
                StartActionList[0].SafeInvoke();
            }
        }

        return false;
    }

    public override bool StartBackward()
    {
        if (base.StartBackward())
        {
            return true;
        }

        if (InForward)
        {
            InForward = false;

            Phase = TotPhase - Phase;

            if (Consecutive)
            {
                TempDest = DestList.Back(Phase - 1);
                TempOrigin = DestList.Back(Phase);
                TempDuration = DurationList.Back(Phase - 1);

                TempDelta = TempDest - TempOrigin;

                if (Phase != DestList.Count - 1)
                {
                    TempDelay = DelayList.Back(Phase - 1);
                }
            }
            else
            {
                TempDest = DestKvList.Back(Phase).Key;
                TempOrigin = DestKvList.Back(Phase).Value;
                TempDuration = DurationList.Back(Phase);

                TempDelta = TempDest - TempOrigin;

                if (Phase != DestKvList.Count - 1)
                {
                    TempDelay = DelayList.Back(Phase);
                }
            }

            Timer = AnimManager.GetTimerVec(Target.localScale, TempDuration, TempOrigin, TempDelta, Curve);
        }
        else
        {
            if (Consecutive)
            {
                Phase = 1;
                TempDest = DestList.Back(1);
                TempDelay = DelayList.Back(0);
                TempOrigin = DestList.Back(0);
                TempDuration = DurationList.Back(0);
            }
            else
            {
                Phase = 0;
                TempDest = DestKvList.Back(0).Key;
                TempDelay = DelayList.Back(0);
                TempOrigin = DestKvList.Back(0).Value;
                TempDuration = DurationList.Back(0);
            }

            TempDelta = TempDest - TempOrigin;

            if (StartActionList.Valid())
            {
                StartActionList.Back(0).SafeInvoke();
            }
        }

        return false;
    }


    public override bool DoForward()
    {
        Timer += Time.deltaTime;
        
        if (Phase == TotPhase)
        {
            if (Timer >= TempDuration)
            {
                InDestination = true;

                if (FinishActionList.Valid())
                {
                    FinishActionList.Back(0).SafeInvoke();
                }

                if (OnForwardFinish != null)
                {
                    OnForwardFinish.Invoke();
                }

                SetLoop(EventType.ForwardFinish);

                return true;
            }
            else
            {
                Target.localScale = Func(Timer, TempDuration, TempOrigin, TempDelta);

                return false;
            }
        }
        else
        {
            if (Timer >= TempDuration + TempDelay)
            {
                Phase++;

                Timer = 0;

                ActionLock = false;

                if (Consecutive)
                {
                    TempDest = DestList[Phase];
                    TempOrigin = DestList[Phase - 1];
                    TempDuration = DurationList[Phase - 1];

                    TempDelta = TempDest - TempOrigin;

                    if (Phase != DestList.Count - 1)
                    {
                        TempDelay = DelayList[Phase - 1];
                    }

                    if (StartActionList.Valid())
                    {
                        StartActionList[Phase - 1].SafeInvoke();
                    }
                }
                else
                {
                    TempDest = DestKvList[Phase].Value;
                    TempOrigin = DestKvList[Phase].Key;
                    TempDuration = DurationList[Phase];

                    TempDelta = TempDest - TempOrigin;

                    if (Phase != DestKvList.Count - 1)
                    {
                        TempDelay = DelayList[Phase];
                    }

                    if (StartActionList.Valid())
                    {
                        StartActionList[Phase].SafeInvoke();
                    }
                }

                return false;
            }
            else if (Timer >= TempDuration)
            {
                if (!ActionLock)
                {
                    if (Consecutive)
                    {
                        if (FinishActionList.Valid())
                        {
                            FinishActionList[Phase - 1].SafeInvoke();
                        }
                    }
                    else
                    {
                        if (FinishActionList.Valid())
                        {
                            FinishActionList[Phase].SafeInvoke();
                        }
                    }
                }

                ActionLock = true;

                return false;
            }
            else
            {
                Target.localScale = Func(Timer, TempDuration, TempOrigin, TempDelta);

                return false;
            }
        }
    }

    public override bool DoBackward()
    {
        Timer += Time.deltaTime;

        if (Phase == TotPhase)
        {
            if (Timer >= TempDuration)
            {
                InOrigin = true;

                if (FinishActionList.Valid())
                {
                    FinishActionList[0].SafeInvoke();
                }

                if (OnBackwardFinish != null)
                {
                    OnBackwardFinish.Invoke();
                }

                SetLoop(EventType.BackwardFinish);

                return true;
            }
            else
            {
                Target.localScale = Func(Timer, TempDuration, TempOrigin, TempDelta);

                return false;
            }
        }
        else
        {
            if (Timer >= TempDuration + TempDelay)
            {
                Phase++;

                Timer = 0;

                ActionLock = false;

                if (Consecutive)
                {
                    TempDest = DestList.Back(Phase - 1);
                    TempOrigin = DestList.Back(Phase);
                    TempDuration = DurationList.Back(Phase - 1);

                    TempDelta = TempDest - TempOrigin;

                    if (Phase != DestList.Count - 1)
                    {
                        TempDelay = DelayList.Back(Phase - 1);
                    }

                    if (StartActionList.Valid())
                    {
                        StartActionList.Back(Phase - 1).SafeInvoke();
                    }
                }
                else
                {
                    TempDest = DestKvList.Back(Phase).Key;
                    TempOrigin = DestKvList.Back(Phase).Value;
                    TempDuration = DurationList.Back(Phase);

                    TempDelta = TempDest - TempOrigin;

                    if (Phase != DestKvList.Count - 1)
                    {
                        TempDelay = DelayList.Back(Phase);
                    }

                    if (StartActionList.Valid())
                    {
                        StartActionList.Back(Phase).SafeInvoke();
                    }
                }

                return false;
            }
            else if (Timer >= TempDuration)
            {
                if (!ActionLock)
                {
                    if (Consecutive)
                    {
                        if (FinishActionList.Valid())
                        {
                            FinishActionList.Back(Phase - 1).SafeInvoke();
                        }
                    }
                    else
                    {
                        if (FinishActionList.Valid())
                        {
                            FinishActionList.Back(Phase).SafeInvoke();
                        }
                    }
                }

                ActionLock = true;

                return false;
            }
            else
            {
                Target.localScale = Func(Timer, TempDuration, TempOrigin, TempDelta);

                return false;
            }
        }
    }
}