//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, September 11, 2017
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using System;
namespace vnxbqy.UI
{
    public class FlipScroll : MaskableGraphic, IBeginDragHandler, IEndDragHandler, IDragHandler
    {
        public enum FlipDirEnum
        {
            Horizon,
            Vertical,
        }
        private int page = 0;
        /// <summary>
        /// 当前页
        /// </summary>
        public int Page {
            get { return page; }
        }
        [SerializeField]
        private FlipDirEnum flipType = FlipDirEnum.Horizon;
        public FlipDirEnum FlipType {
            get {
                return flipType;
            }
            set {
                flipType = value;
            }
        }
        [SerializeField]
        private bool m_Loop = false;
        public bool loop {
            get {
                return m_Loop;
            }
            set {
                m_Loop = value;
            }
        }

        [SerializeField]
        private TweenType _tweenType = TweenType.Linear;
        public TweenType tweenType {
            get { return _tweenType; }
            set { _tweenType = value; }
        }
        [SerializeField]
        private float sensitive = 5.0f;

        public float Sensitive {
            get { return sensitive; }
            set { sensitive = value; }
        }
        [SerializeField]
        public bool resetOnEnable = true;

        private bool tweening = false;
        public bool IsTweening { get { return tweening; } }
        [SerializeField]
        private float _tweenTime = 1.0f;
        public float TweenTime {
            get { return _tweenTime; }
            set { _tweenTime = value; }
        }

        public RectTransform presentRT;
        public RectTransform lastRT;

        private RectTransform presentFlipRT;
        private RectTransform lastFlipRT;

        public event Action<int, RectTransform> OnRefreshData;
        public event Action OnTweenCompt;

        public int pageCnt = 0;
        [HideInInspector]
        public bool locked = false;

        protected override void Awake()
        {
            base.Awake();
            if (presentRT == null || lastRT == null) return;
            presentRT.SetActive(false);
            lastRT.SetActive(false);
            presentFlipRT = presentRT;
            lastFlipRT = lastRT;
        }

        protected override void OnEnable()
        {
            base.OnEnable();
            if (presentRT == null || lastRT == null || pageCnt == 0) return;
            presentRT.SetActive(true);
            lastRT.SetActive(true);
            presentRT.localPosition = Vector3.zero;
            if (resetOnEnable) {
                switch (FlipType) {
                    case FlipDirEnum.Horizon:
                        lastRT.localPosition = rectTransform.localPosition.SetX(rectTransform.sizeDelta.x);
                        break;
                    case FlipDirEnum.Vertical:
                        lastRT.localPosition = rectTransform.localPosition.SetY(-rectTransform.sizeDelta.y);
                        break;
                }
                page = 0;
            }
            presentFlipRT = presentRT;
            lastFlipRT = lastRT;
            RefreshActive();
        }

        private Vector2 lastPos = Vector2.zero;
        public void OnBeginDrag(PointerEventData eventData)
        {
            lastPos = eventData.position;
        }

        public void OnEndDrag(PointerEventData eventData)
        {
            if (IsTweening || locked) return;
            Vector2 nPos = lastPos - eventData.position;
            switch (FlipType) {
                case FlipDirEnum.Horizon: {
                        if (Math.Abs(nPos.x) < sensitive) return;
                        if (nPos.x > 0) {
                            FlipRight();
                        }
                        else {
                            FlipLeft();
                        }
                    }
                    break;
                case FlipDirEnum.Vertical: {
                        if (Math.Abs(nPos.y) < sensitive) return;
                        Vector3 pos = Vector3.zero;
                        if (nPos.y < 0) {
                            FlipLeft();
                        }
                        else {
                            FlipRight();
                        }
                    }
                    break;
            }
        }

        protected override void OnDisable()
        {
            tweening = false;
            StopAllCoroutines();
            base.OnDisable();
        }




        IEnumerator TweenPosition(Vector3 lPos, Vector3 nPos, Vector3 lastRtPos)
        {
            float time = 0;
            Vector3 newPresentPos = Vector3.zero;
            Vector3 newLastPos = Vector3.zero;
            bool InView = false;
            tweening = true;
            while (time < _tweenTime) {
                float per = 0;
                switch (tweenType) {
                    case TweenType.Immediate: per = 1; break;
                    case TweenType.Linear: per = Linear(time / _tweenTime); break;
                    case TweenType.Smooth: per = Smooth(time / _tweenTime); break;
                }
                newPresentPos = Vector3.Lerp(lPos, nPos, per);
                newLastPos = Vector3.Lerp(lastRtPos, Vector3.zero, per);
                presentFlipRT.localPosition = newPresentPos;
                lastFlipRT.localPosition = newLastPos;
                time += Time.unscaledDeltaTime;
                if (!InView) {
                    InView = InViewSide();
                }
                if (tweenType == TweenType.Immediate) {
                    break;
                }
                yield return null;
            }
            tweening = false;
            presentFlipRT.localPosition = nPos;
            lastFlipRT.localPosition = Vector3.zero;
            RectTransform temp = presentFlipRT;
            presentFlipRT = lastFlipRT;
            lastFlipRT = temp;
            if (OnTweenCompt != null) OnTweenCompt();
        }

        public bool InViewSide()
        {
            switch (FlipType) {
                case FlipDirEnum.Horizon: {
                        if (Vector3.Distance(Vector3.zero, lastFlipRT.localPosition) < lastFlipRT.sizeDelta.x + rectTransform.sizeDelta.x) {
                            if (OnRefreshData != null) {
                                lastFlipRT.SetActive(true);
                                OnRefreshData(page, lastFlipRT);
                            }
                            return true;
                        }
                    }
                    break;
                case FlipDirEnum.Vertical: {
                        if (Vector3.Distance(Vector3.zero, lastFlipRT.localPosition) < lastFlipRT.sizeDelta.y + rectTransform.sizeDelta.y) {
                            if (OnRefreshData != null) {
                                lastFlipRT.SetActive(true);
                                OnRefreshData(page, lastFlipRT);
                            }
                            return true;
                        }
                    }
                    break;
            }
            return false;
        }

        private float Linear(float val)
        {
            return Mathf.Lerp(0, 1, val);
        }

        private float Smooth(float val)
        {
            float result = Mathf.SmoothStep(0, 1, val);
            result = Mathf.Clamp(result, 0, 1);
            return result;
        }

        public void RefreshActive()
        {
            if (pageCnt == 0 || presentFlipRT == null) return;
            if (OnRefreshData != null) {
                presentFlipRT.SetActive(true);
                OnRefreshData(page, presentFlipRT);
            }
        }

        public void FlipLeft()
        {
            if (IsTweening || pageCnt == 0) return;
            Vector3 pos = Vector3.zero;
            page--;
            if (page < 0) {
                if (loop) {
                    page = pageCnt - 1;
                }
                else {
                    page = 0;
                    return;
                }
            }
            switch (FlipType) {
                case FlipDirEnum.Horizon: {
                        lastFlipRT.localPosition = rectTransform.localPosition.SetX(-rectTransform.sizeDelta.x);
                        pos = rectTransform.localPosition.SetX(rectTransform.sizeDelta.x);
                    }
                    break;
                case FlipDirEnum.Vertical: {
                        lastFlipRT.localPosition = rectTransform.localPosition.SetY(rectTransform.sizeDelta.y);
                        pos = rectTransform.localPosition.SetY(-rectTransform.sizeDelta.y);
                    }
                    break;
            }
            StartCoroutine(TweenPosition(presentFlipRT.localPosition, pos, lastFlipRT.localPosition));
        }

        public void FlipRight()
        {
            if (IsTweening || pageCnt == 0) return;
            Vector3 pos = Vector3.zero;
            page++;
            if (page >= pageCnt) {
                if (loop) {
                    page = 0;
                }
                else {
                    page = pageCnt - 1;
                    return;
                }
            }
            switch (FlipType) {
                case FlipDirEnum.Horizon: {
                        lastFlipRT.localPosition = rectTransform.localPosition.SetX(rectTransform.sizeDelta.x);
                        pos = rectTransform.localPosition.SetX(-rectTransform.sizeDelta.x);
                    }
                    break;
                case FlipDirEnum.Vertical: {
                        lastFlipRT.localPosition = rectTransform.localPosition.SetY(-rectTransform.sizeDelta.y);
                        pos = rectTransform.localPosition.SetY(rectTransform.sizeDelta.y);
                    }
                    break;
            }
            StartCoroutine(TweenPosition(presentFlipRT.localPosition, pos, lastFlipRT.localPosition));
        }

        public void OnDrag(PointerEventData eventData)
        {

        }

        public enum TweenType
        {
            Immediate,
            Linear,
            Smooth,
        }
    }
}