using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;

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

public enum Direction
{
    Left,
    Null,
    Right,
}

public class Garden : Regist, IDragHandler, IPointerClickHandler, IEndDragHandler, IBeginDragHandler
{
    #region 变量

    public int ValidPage;

    private int Page;
    private bool Flag1;
    private bool Flag2;
    private float RatioBk2;
    private float RatioBk3;
    private float RatioBk4;
    private float RatioPlayer;
    private float SlideSpeed;
    private Direction Direction;
    private Transform Player;
    private Transform GardenA;
    private Transform GardenBk2;
    private Transform GardenBk3;
    private Transform GardenBk4;

    private List<Vector3> PlayerPos;
    private List<Vector3> GardenPosA;
    private List<Vector3> GardenPosBk2;
    private List<Vector3> GardenPosBk3;
    private List<Vector3> GardenPosBk4;

    #endregion

    public override void RegistValueA()
    {
        Flag1 = true;
        Flag2 = true;

        Page = 0;
        SlideSpeed = 0.1f;

        RatioBk2 = 0.25f;
        RatioBk3 = 0.5f;
        RatioBk4 = 0.75f;
        RatioPlayer = 0.75f;

        #region Garden

        #region Cloud1

        Transform tra0 = ManaReso.Get("Cloud1");

        Tween tween = tra0.CreateTweenVec(new Vector3(-12, tra0.position.y, tra0.position.z), 50f, false, true, Curve.Linear);

        var tra1 = tra0;
        tween.OnForwardFinish += () =>
        {
            tra1.TweenForVec();
        };

        tra1.TweenForVec();

        #endregion

        #region Cloud2

        tra0 = ManaReso.Get("Cloud2");

        tween = tra0.CreateTweenVec(new Vector3(-12, tra1.position.y, tra1.position.z), 75f, false, true, Curve.Linear);

        Transform tra2 = tra0;
        tween.OnForwardFinish += () =>
        {
            tra2.TweenForVec();
        };

        tra2.TweenForVec();

        #endregion

        #region Cloud3

        tra0 = ManaReso.Get("Cloud3");

        tween = tra0.CreateTweenVec(new Vector3(-12, tra1.position.y, tra1.position.z), 100, false, true, Curve.Linear);

        tween.OnForwardFinish += () =>
        {
            tra0.TweenForVec();
        };

        tra0.TweenForVec();

        #endregion

        #region GardenA

        MoveVec moveVec = GardenA.CreateMoveVec();

        moveVec.OnStart += () =>
        {
            Flag2 = false;
        };

        moveVec.OnFinish += () =>
        {
            Flag2 = true;
        };

        #endregion

        #region GardenMini
        
        tween = ManaReso.Get("GardenMini").CreateTweenVec
        (
            ManaReso.Get("PageTraMini").position,
            1f, 
            false, 
            true,
            Curve.EaseOutQuad
        );

        tween.OnForwardStart += () =>
        {
            ManaMiniGame.GamePrepare();
        };

        tween.OnForwardFinish += () =>
        {
            ManaReso.SetActive("Player", false);
            ManaReso.SetActive("Cloud1", false);
            ManaReso.SetActive("Cloud2", false);
            ManaReso.SetActive("Cloud3", false);
            ManaReso.SetActive("GardenA", false);
            ManaReso.SetActive("GardenBk1", false);
            ManaReso.SetActive("GardenBk2", false);
            ManaReso.SetActive("GardenBk3", false);
            ManaReso.SetActive("GardenBk4", false);
        };

        tween.OnBackwardStart += () =>
        {
            ManaReso.SetActive("Player", true);
            ManaReso.SetActive("Cloud1", true);
            ManaReso.SetActive("Cloud2", true);
            ManaReso.SetActive("Cloud3", true);
            ManaReso.SetActive("GardenA", true);
            ManaReso.SetActive("GardenBk1", true);
            ManaReso.SetActive("GardenBk2", true);
            ManaReso.SetActive("GardenBk3", true);
            ManaReso.SetActive("GardenBk4", true);
        };

        tween.OnBackwardFinish += () =>
        {
            for (int i = 0; i < ManaMiniGame.IdleList.Count; i++)
            {
                ManaReso.Save(ManaMiniGame.IdleList[i]);
            }

            for (int i = 0; i < ManaMiniGame.OpList.Count; i++)
            {
                ManaReso.Save(ManaMiniGame.OpList[i]);
            }

            ManaReso.SetActive("C_MiniGame", true);
        };

        #endregion

        #endregion
    }

    public override void RegistReference()
    {
        GardenBk2 = ManaReso.Get("GardenBk2");
        GardenBk3 = ManaReso.Get("GardenBk3");
        GardenBk4 = ManaReso.Get("GardenBk4");

        Player = ManaReso.Get("Player");
        GardenA = ManaReso.Get("GardenA");

        GardenPosBk2 = new List<Vector3>()
        {
            ManaReso.Get("PageTra21").position,
            ManaReso.Get("PageTra22").position,
        };

        GardenPosBk3 = new List<Vector3>()
        {
            ManaReso.Get("PageTra31").position,
            ManaReso.Get("PageTra32").position,
        };

        GardenPosBk4 = new List<Vector3>()
        {
            ManaReso.Get("PageTra41").position,
            ManaReso.Get("PageTra42").position,
        };

        GardenPosA = new List<Vector3>()
        {
            ManaReso.Get("PageTraA").position,
            ManaReso.Get("PageTraB").position,
        };

        PlayerPos = new List<Vector3>()
        {
            global::Player.ChildDic["PlayerTra1"].position,
            global::Player.ChildDic["PlayerTra2"].position,
        };
    }


    public void OnDrag(PointerEventData eventData)
    {
        if (Flag1 && Flag2)
        {
            if (Direction == Direction.Null)
            {
                if (eventData.delta.x > 0)
                {
                    Direction = Direction.Right;
                }
                else
                {
                    Direction = Direction.Left;
                }
            }
            
            if (Direction == Direction.Left)
            {
                if (eventData.delta.x > 0)
                {
                    Return();
                }
                else
                {
                    #region MyRegion

                    float rawDeltaX = eventData.position.x - eventData.pressPosition.x;

                    if (Page < ValidPage - 1)
                    {
                        float tempX = Mathf.Clamp(eventData.delta.x / 10, -2, 2) * SlideSpeed;

                        Player.Translate(Player.right * tempX * RatioPlayer, Space.World);

                        GardenA.Translate(GardenA.right * tempX, Space.World);
                        GardenBk2.Translate(GardenBk2.right * tempX * RatioBk2, Space.World);
                        GardenBk3.Translate(GardenBk3.right * tempX * RatioBk3, Space.World);
                        GardenBk4.Translate(GardenBk4.right * tempX * RatioBk4, Space.World);

                        if (rawDeltaX < -300)
                        {
                            NextPage();
                        }
                    }
                    else
                    {
                        float tempX = Mathf.Clamp(eventData.delta.x / 10, -2, 2) * SlideSpeed;

                        GardenA.Translate(GardenA.right * tempX, Space.World);

                        if (GardenA.position.x - GardenPosA[ValidPage - 1].x < -0.7f)
                        {
                            GardenA.SetX(GardenPosA[ValidPage - 1].x - 0.7f);

                            Return();
                        }
                    }

                    #endregion
                }
            }
            else if (Direction == Direction.Right)
            {
                if (eventData.delta.x < 0)
                {
                    Return();
                }
                else
                {
                    #region MyRegion

                    float rawDeltaX = eventData.position.x - eventData.pressPosition.x;

                    if (Page > 0)
                    {
                        float tempX = Mathf.Clamp(eventData.delta.x / 10, -2, 2) * SlideSpeed;

                        Player.Translate(Player.right * tempX * RatioPlayer, Space.World);

                        GardenA.Translate(GardenA.right * tempX, Space.World);
                        GardenBk2.Translate(GardenBk2.right * tempX * RatioBk2, Space.World);
                        GardenBk3.Translate(GardenBk3.right * tempX * RatioBk3, Space.World);
                        GardenBk4.Translate(GardenBk4.right * tempX * RatioBk4, Space.World);

                        if (rawDeltaX > 300)
                        {
                            PrevPage();
                        }
                    }
                    else
                    {
                        float tempX = Mathf.Clamp(eventData.delta.x / 10, -2, 2) * SlideSpeed;

                        GardenA.Translate(GardenA.right * tempX, Space.World);

                        if (GardenA.position.x - GardenPosA[0].x > 0.7f)
                        {
                            GardenA.SetX(GardenPosA[0].x + 0.7f);

                            Return();
                        }
                    }

                    #endregion
                }
            }
        }
    }

    public void OnEndDrag(PointerEventData eventData)
    {
        if (Flag1 && Flag2)
        {
            Return();
        }

        Flag1 = true;
        Direction = Direction.Null;
    }

    public void OnBeginDrag(PointerEventData eventData)
    {
        Direction = Direction.Null;
    }

    public void OnPointerClick(PointerEventData eventData)
    {
        if (!eventData.hovered.Contains(eventData.rawPointerPress))
        {
            return;
        }
        
        if (eventData.rawPointerPress.transform.name.Contains("Slot"))
        {
            Slot slot = eventData.rawPointerPress.GetComponent<Slot>();

            if (slot.Valid == false)
            {
                return;
            }

            FlowerInfo flowerInfo = null;
            FlowerCard flowerCard = ManaReso.Get<FlowerCard>("H_FlowerCard");

            for (int i = 0; i < ManaGarden.FlowerInfoList.Count; i++)
            {
                FlowerInfo temp = ManaGarden.FlowerInfoList[i];

                if (temp.Plant == false && temp.Unlock)
                {
                    flowerInfo = temp;

                    flowerCard.Add(temp);
                }
            }

            if (flowerInfo == null)
            {
                ManaReso.Get("G_Flower").TweenForCG();
            }
            else
            {
                ManaReso.Get("H_FlowerCard").TweenForCG();

                ManaReso.SetActive("H_Grid", true);
                ManaReso.SetActive("H_Prev", true);
                ManaReso.SetActive("H_Next", true);
                ManaReso.SetActive("H_Place", true);
                ManaReso.SetActive("H_Icon1", false);
                ManaReso.SetActive("H_Retrieve", false);

                ManaGarden.SeleSlot = slot;

                ManaGarden.SetFlowerCard(flowerInfo);

                Auxiliary.Inst.DelayCall
                (
                    () =>
                    {
                        flowerCard.Select(0);

                        flowerCard.LeftBorder = ManaReso.Get("H_Grid").position.x - Mathf.Abs(flowerCard.ItemList.Last(0).position.x - ManaReso.Get("H_Scrr").position.x);
                        flowerCard.RightBorder = ManaReso.Get("H_Grid").position.x + Mathf.Abs(flowerCard.ItemList[0].position.x - ManaReso.Get("H_Scrr").position.x);

                        ManaReso.Get<ContentSizeFitter>("H_Grid").enabled = false;
                        ManaReso.Get<HorizontalLayoutGroup>("H_Grid").enabled = false;
                    },
                    1
                );
            }
        }
    }


    private void Return()
    {
        Flag1 = false;

        Player.MoveVec(PlayerPos[Page], 0.25f, Curve.EaseOutQuad);
        GardenA.MoveVec(GardenPosA[Page], 0.25f, Curve.EaseOutQuad);
        GardenBk2.MoveVec(GardenPosBk2[Page], 0.25f, Curve.EaseOutQuad);
        GardenBk3.MoveVec(GardenPosBk3[Page], 0.25f, Curve.EaseOutQuad);
        GardenBk4.MoveVec(GardenPosBk4[Page], 0.25f, Curve.EaseOutQuad);
    }

    private void PrevPage()
    {
        Page--;
        
        Flag1 = false;

        Player.MoveVec(PlayerPos[Page], 0.5f, Curve.EaseOutQuad);
        GardenA.MoveVec(GardenPosA[Page], 0.5f, Curve.EaseOutQuad);
        GardenBk2.MoveVec(GardenPosBk2[Page], 0.5f, Curve.EaseOutQuad);
        GardenBk3.MoveVec(GardenPosBk3[Page], 0.5f, Curve.EaseOutQuad);
        GardenBk4.MoveVec(GardenPosBk4[Page], 0.5f, Curve.EaseOutQuad);
    }

    private void NextPage()
    {
        Page++;
        
        Flag1 = false;

        Player.MoveVec(PlayerPos[Page], 0.5f, Curve.EaseOutQuad);
        GardenA.MoveVec(GardenPosA[Page], 0.5f, Curve.EaseOutQuad);
        GardenBk2.MoveVec(GardenPosBk2[Page], 0.5f, Curve.EaseOutQuad);
        GardenBk3.MoveVec(GardenPosBk3[Page], 0.5f, Curve.EaseOutQuad);
        GardenBk4.MoveVec(GardenPosBk4[Page], 0.5f, Curve.EaseOutQuad);
    }
}