using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
using System;
using Cysharp.Threading.Tasks;
using System.Diagnostics;

[DisallowMultipleComponent]

public class CyclicScroll : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler
{
    [SerializeField] RectTransform m_Content;
    public RectTransform content { get { return m_Content; } }

    [SerializeField] protected BoundOffset m_BoundOffset;
    [SerializeField] protected Vector2 m_CellSize = new Vector2(100, 100);
    public Vector2 cellSize { get { return m_CellSize; } }

    [SerializeField] protected Vector2 m_Spacing;
    public Vector2 spacing { get { return m_Spacing; } }

    [SerializeField] Align m_Align = Align.Top;
    public Align align { get { return m_Align; } }

    [SerializeField] bool m_ElasticityOn = true;
    public bool elasticityOn { get { return m_ElasticityOn; } }

    [SerializeField] private float m_Elasticity = 0.1f;
    public float elasticity { get { return m_Elasticity; } }

    [SerializeField] private float m_DecelerationRate = 0.135f;
    public float decelerationRate { get { return m_DecelerationRate; } }

    [SerializeField] string m_ChildPrefabName = string.Empty;
    [SerializeField] string m_ChildDisplayName = string.Empty;
    [SerializeField] int m_ChildCount = 5;

    public float normalizedPosition {
        get {
            if (content == null)
            {
                return 0f;
            }

            var offset = (dataMaxOffset - dataMinOffset);
            switch (align)
            {
                case Align.Top:
                case Align.Bottom:
                    return Mathf.Clamp01(Mathf.Abs((content.anchoredPosition.y - dataMinOffset.y) / offset.y));
                case Align.Left:
                case Align.Right:
                    return Mathf.Clamp01(Mathf.Abs((content.anchoredPosition.x - dataMinOffset.x) / offset.x));
                default:
                    return 0f;
            }
        }
        set {
            if (content == null)
            {
                return;
            }

            value = Mathf.Clamp01(value);
            var normalize = 0f;
            var offset = (dataMaxOffset - dataMinOffset);
            switch (align)
            {
                case Align.Top:
                case Align.Bottom:
                    normalize = (content.anchoredPosition.y - dataMinOffset.y) / offset.y;
                    if (Mathf.Abs(normalize - value) > 0.0001f)
                    {
                        targetOffset = dataMinOffset + new Vector2(0, dataMaxOffset.y * value);
                        velocity = 0f;
                        autoLerp = true;
                        refAutoLerpPosition = Vector2.zero;
                    }
                    break;
                case Align.Left:
                case Align.Right:
                    normalize = (content.anchoredPosition.x - dataMinOffset.x) / offset.x;
                    if (Mathf.Abs(normalize - value) > 0.0001f)
                    {
                        targetOffset = dataMinOffset + new Vector2(dataMaxOffset.x * value, 0);
                        velocity = 0f;
                        autoLerp = true;
                        refAutoLerpPosition = Vector2.zero;
                    }
                    break;
            }
        }
    }

    protected Vector2 dataMaxOffset = Vector2.zero;
    protected Vector2 dataMinOffset = Vector2.zero;

    public bool autoLerp { get; private set; }

    Vector2 targetOffset = Vector2.zero;
    Vector2 refAutoLerpPosition = Vector2.zero;

    protected IList datas;
    protected List<ScrollItem> infiniteItems = new List<ScrollItem>();
    List<ScrollItem> tempList = new List<ScrollItem>();

    Vector2 startMousePosition = Vector2.zero;
    Vector2 startContentPosition = Vector2.zero;
    Vector2 prevPosition = Vector2.zero;

    protected float velocity = 0f;
    protected bool dragging = false;

    public int dataCount {
        get {
            return datas == null ? 0 : datas.Count;
        }
    }
    bool moveNextable {
        get {
            return hostIndex < dataCount - 1;
        }
    }
    bool moveLastable {
        get {
            return preIndex > 0;
        }
    }

    public RectTransform rectTransform { get { return this.transform as RectTransform; } }

    private Vector2 maxOffset { get { return rectTransform.GetMaxReferencePosition(rectTransform); } }
    private Vector2 minOffset { get { return rectTransform.GetMinReferencePosition(rectTransform); } }

    protected int preIndex {
        get; set;
    }

    protected int hostIndex {
        get; set;
    }

    public void LuaInit(int[] indexs, bool stepByStep)
    {
        Init(new List<int>(indexs), stepByStep);
    }

    public virtual void Init<T>(List<T> _datas, bool _stepByStep = false)
    {
        if (_datas == null)
        {
            this.SetActive(false);
            return;
        }

        datas = _datas;

        ReArrange();
        FillBatchData(0);

        if (_stepByStep)
        {
            for (int i = 0; i < infiniteItems.Count; i++)
            {
                var infiniteItem = infiniteItems[i];
                if (infiniteItem != null)
                {
                    infiniteItem.SetActive(false);
                }
            }
        }

        this.SetActive(true);

        dataMinOffset = content.anchoredPosition;
        var totalOffset = dataCount == 0 ? Vector2.zero : cellSize * dataCount + spacing * (dataCount - 1)
            + new Vector2(m_BoundOffset.left + m_BoundOffset.right, m_BoundOffset.top + m_BoundOffset.bottom);

        var longer = Mathf.Abs(totalOffset.x) > Mathf.Abs(rectTransform.rect.width);
        var higher = Mathf.Abs(totalOffset.y) > Mathf.Abs(rectTransform.rect.height);
        switch (align)
        {
            case Align.Left:
                dataMaxOffset = longer ? dataMinOffset - new Vector2(totalOffset.x - rectTransform.rect.width, 0) : dataMinOffset;
                break;
            case Align.Right:
                dataMaxOffset = longer ? dataMinOffset + new Vector2(totalOffset.x - rectTransform.rect.width, 0) : dataMinOffset;
                break;
            case Align.Top:
                dataMaxOffset = higher ? dataMinOffset + new Vector2(0, totalOffset.y - rectTransform.rect.height) : dataMinOffset;
                break;
            case Align.Bottom:
                dataMaxOffset = higher ? dataMinOffset - new Vector2(0, totalOffset.y - rectTransform.rect.height) : dataMinOffset;
                break;
        }

        if (_stepByStep)
        {
            Co_StepByStepAppear();
            // StartCoroutine("Co_StepByStepAppear");
        }
    }

    public void Dispose()
    {
        velocity = 0f;
        StopAllCoroutines();
        for (int i = 0; i < infiniteItems.Count; i++)
        {
            var infiniteItem = infiniteItems[i];
            if (infiniteItem != null)
            {
                infiniteItem.Dispose();
            }
        }
    }

    public void HideAll()
    {
        StopAllCoroutines();
        for (int i = 0; i < content.childCount; i++)
        {
            content.GetChild(i).SetActive(false);
        }
    }

    private async UniTask Co_StepByStepAppear()
    {
        for (int i = 0; i < infiniteItems.Count; i++)
        {
            var infiniteItem = infiniteItems[i];
            if (infiniteItem != null && i < datas.Count)
            {
                infiniteItem.SetActive(true);
                infiniteItem.OpeningShow();
                await UniTask.Delay(1000);
            }
        }
    }

    public void MoveToCenter(int _dataIndex)
    {
        if (_dataIndex < 0 || _dataIndex >= dataCount)
        {
            return;
        }

        switch (align)
        {
            case Align.Left:
                var leftOffsetX = Mathf.Clamp(m_BoundOffset.left + (_dataIndex + 0.5f) * cellSize.x + _dataIndex * spacing.x - rectTransform.rect.width * 0.5f, 0, Mathf.Abs(dataMaxOffset.x));
                targetOffset = new Vector2(dataMinOffset.x - leftOffsetX, 0);
                break;
            case Align.Right:
                var rightOffsetX = Mathf.Clamp(m_BoundOffset.right + (_dataIndex + 0.5f) * cellSize.x + _dataIndex * spacing.x - rectTransform.rect.width * 0.5f, 0, Mathf.Abs(dataMaxOffset.x));
                targetOffset = new Vector2(dataMinOffset.x + rightOffsetX, 0);
                break;
            case Align.Top:
                var topOffsetY = Mathf.Clamp(m_BoundOffset.top + (_dataIndex + 0.5f) * cellSize.y + _dataIndex * spacing.y - rectTransform.rect.height * 0.5f, 0, Mathf.Abs(dataMaxOffset.y));
                targetOffset = new Vector2(0, dataMinOffset.y + topOffsetY);
                break;
            case Align.Bottom:
                var bottomOffsetY = Mathf.Clamp(m_BoundOffset.bottom + (_dataIndex + 0.5f) * cellSize.y + _dataIndex * spacing.y - rectTransform.rect.height * 0.5f, 0, Mathf.Abs(dataMaxOffset.y));
                targetOffset = new Vector2(0, dataMinOffset.y - bottomOffsetY);
                break;
        }

        autoLerp = true;
    }

    #region Drag Process

    public void OnBeginDrag(PointerEventData eventData)
    {
        if (autoLerp || eventData.button != PointerEventData.InputButton.Left)
        {
            return;
        }

        startMousePosition = Vector2.zero;
        RectTransformUtility.ScreenPointToLocalPointInRectangle(rectTransform, eventData.position, eventData.pressEventCamera, out startMousePosition);
        prevPosition = startContentPosition = content.anchoredPosition;
        velocity = 0f;
        dragging = true;
    }

    public void OnDrag(PointerEventData eventData)
    {
        // if (NewBieCenter.Instance.inGuiding)
        // {
        //     return;
        // }

        if (autoLerp || eventData.button != PointerEventData.InputButton.Left)
        {
            return;
        }

        var localMouse = new Vector2();
        if (RectTransformUtility.ScreenPointToLocalPointInRectangle(rectTransform, eventData.position, eventData.pressEventCamera, out localMouse))
        {
            var pointerDelta = localMouse - startMousePosition;
            var position = startContentPosition + pointerDelta;
            SetContentAnchoredPosition(position, align);
        }
    }

    public void OnEndDrag(PointerEventData eventData)
    {
        if (autoLerp || eventData.button != PointerEventData.InputButton.Left)
        {
            return;
        }

        dragging = false;
    }
    #endregion

    private void Update()
    {
        if (autoLerp && Vector2.Distance(content.anchoredPosition, targetOffset) > 0.1f)
        {
            var newPosition = Vector2.SmoothDamp(content.anchoredPosition, targetOffset, ref refAutoLerpPosition, m_Elasticity, Mathf.Infinity, Time.unscaledDeltaTime);
            SetContentAnchoredPosition(newPosition, align);
        }
        else
        {
            autoLerp = false;
        }
    }

    protected virtual void LateUpdate()
    {
        if (content == null)
        {
            return;
        }

        var deltaTime = Time.unscaledDeltaTime;
        var offset = CalculateOffset(align);

        if (!dragging && (velocity != 0f || Vector2.SqrMagnitude(offset - Vector2.zero) > 0.1f))
        {
            Vector2 position = content.anchoredPosition;
            if (Vector2.SqrMagnitude(offset - Vector2.zero) > 0.1f)
            {
                float speed = velocity;
                switch (align)
                {
                    case Align.Left:
                    case Align.Right:
                        position[0] = Mathf.SmoothDamp(content.anchoredPosition[0], content.anchoredPosition[0] - offset.x, ref speed, m_Elasticity, Mathf.Infinity, deltaTime);
                        break;
                    case Align.Bottom:
                    case Align.Top:
                        position[1] = Mathf.SmoothDamp(content.anchoredPosition[1], content.anchoredPosition[1] - offset.y, ref speed, m_Elasticity, Mathf.Infinity, deltaTime);
                        break;
                }

                if (Mathf.Abs(speed) < 1)
                {
                    speed = 0f;
                }
                velocity = speed;
            }
            else
            {
                velocity *= Mathf.Pow(m_DecelerationRate, deltaTime);
                if (Mathf.Abs(velocity) < 50)
                {
                    velocity = 0;
                }
                switch (align)
                {
                    case Align.Left:
                    case Align.Right:
                        position[0] += velocity * deltaTime;
                        break;
                    case Align.Bottom:
                    case Align.Top:
                        position[1] += velocity * deltaTime;
                        break;
                }

            }

            SetContentAnchoredPosition(position, align);
        }

        if (dragging /*&& content.anchoredPosition != prevPosition*/)
        {
            var newVelocity = 0f;
            switch (align)
            {
                case Align.Left:
                case Align.Right:
                    newVelocity = (content.anchoredPosition[0] - prevPosition[0]) / deltaTime;
                    break;
                case Align.Bottom:
                case Align.Top:
                    newVelocity = (content.anchoredPosition[1] - prevPosition[1]) / deltaTime;
                    break;
            }

            velocity = Mathf.Lerp(velocity, newVelocity, deltaTime * 10);
            prevPosition = content.anchoredPosition;
        }

    }

    protected virtual void ProcessMoveNext()
    {
        ScrollItem lastRect = null;
        ScrollItem item = null;

        tempList.Clear();
        for (int i = 0; i < infiniteItems.Count; i++)
        {
            tempList.Add(infiniteItems[i]);
        }
        if (tempList.Count <= 0)
        {
            return;
        }
        lastRect = tempList[tempList.Count - 1];
        for (int i = 0; i < tempList.Count; i++)
        {
            item = tempList[i];
            var able = moveNextable && TestMoveNext(align, item);
            if (able)
            {
                infiniteItems.Remove(item);
                infiniteItems.Add(item);
                var offset = CalculateElementOffset(align);
                item.rectTransform.anchoredPosition = lastRect.rectTransform.anchoredPosition + offset;
                lastRect = item;

                hostIndex++;
                preIndex++;
                item.Dispose();
                item.LuaDispose();
                item.Display(datas[hostIndex]);
                item.LuaDisplay(hostIndex);
            }
            else
            {
                break;
            }
        }
    }

    protected virtual void ProcessMoveLast()
    {
        ScrollItem firstRect = null;
        ScrollItem item = null;

        tempList.Clear();
        for (int i = 0; i < infiniteItems.Count; i++)
        {
            tempList.Add(infiniteItems[i]);
        }

        firstRect = tempList[0];
        for (int i = tempList.Count - 1; i >= 0; i--)
        {
            item = tempList[i];
            var able = moveLastable && TestMoveLast(align, item);
            if (able)
            {
                infiniteItems.Remove(item);
                infiniteItems.Insert(0, item);
                var offset = CalculateElementOffset(align);
                item.rectTransform.anchoredPosition = firstRect.rectTransform.anchoredPosition - offset;
                firstRect = item;
                hostIndex--;
                preIndex--;
                item.Dispose();
                item.LuaDispose();
                item.Display(datas[preIndex]);
                item.LuaDisplay(preIndex);
            }
            else
            {
                break;
            }
        }
    }

    private void SetContentAnchoredPosition(Vector2 _position, Align _align)
    {
        if (_position == content.anchoredPosition)
        {
            return;
        }

        if (!elasticityOn)
        {
            _position.y = Mathf.Clamp(_position.y, dataMinOffset.y, dataMaxOffset.y);
            _position.x = Mathf.Clamp(_position.x, dataMinOffset.x, dataMaxOffset.x);
        }

        var offset = _position - content.anchoredPosition;

        switch (_align)
        {
            case Align.Left:
            case Align.Right:
                _position[1] = content.anchoredPosition[1];
                content.anchoredPosition = _position;
                break;
            case Align.Top:
            case Align.Bottom:
                _position[0] = content.anchoredPosition[0];
                content.anchoredPosition = _position;
                break;
        }

        var moveNext = (_align == Align.Left && offset.x < 0f) || (_align == Align.Right && offset.x > 0f) ||
            (_align == Align.Top && offset.y > 0f) || (_align == Align.Bottom && offset.y < 0f);

        if (moveNext)
        {
            ProcessMoveNext();
        }
        else
        {
            ProcessMoveLast();
        }
    }

    private Vector2 CalculateOffset(Align _align)
    {
        var offset = Vector2.zero;
        switch (_align)
        {
            case Align.Left:
                if (content.anchoredPosition.x > dataMinOffset.x)
                {
                    offset = content.anchoredPosition - dataMinOffset;
                }
                else if (content.anchoredPosition.x < dataMaxOffset.x)
                {
                    offset = content.anchoredPosition - dataMaxOffset;
                }
                break;
            case Align.Right:
                if (content.anchoredPosition.x < dataMinOffset.x)
                {
                    offset = content.anchoredPosition - dataMinOffset;
                }
                else if (content.anchoredPosition.x > dataMaxOffset.x)
                {
                    offset = content.anchoredPosition - dataMaxOffset;
                }
                break;
            case Align.Bottom:
                if (content.anchoredPosition.y > dataMinOffset.y)
                {
                    offset = content.anchoredPosition - dataMinOffset;
                }
                else if (content.anchoredPosition.y < dataMaxOffset.y)
                {
                    offset = content.anchoredPosition - dataMaxOffset;
                }
                break;
            case Align.Top:
                if (content.anchoredPosition.y < dataMinOffset.y)
                {
                    offset = content.anchoredPosition - dataMinOffset;
                }
                else if (content.anchoredPosition.y > dataMaxOffset.y)
                {
                    offset = content.anchoredPosition - dataMaxOffset;
                }
                break;
        }

        return offset;
    }

    [ContextMenu("Arrange")]
    public virtual void ReArrange()
    {
        velocity = 0f;
        autoLerp = false;
        CreateElements();
        ElementsMatch();
        Arrange(align);
    }

    private void CreateElements()
    {
        var items = this.content.GetComponentsInChildren<ScrollItem>(true);
        if (items.Length < m_ChildCount)
        {
            var dif = m_ChildCount - items.Length;
            if (!string.IsNullOrEmpty(m_ChildPrefabName) && !string.IsNullOrEmpty(m_ChildDisplayName))
            {
                for (var i = 0; i < dif; i++)
                {
                    var instance = UIUtility.CreateWidget(m_ChildPrefabName, m_ChildDisplayName);
                    instance.transform.SetParentEx(this.m_Content, Vector3.zero, Quaternion.identity, Vector3.one);
                }
            }
        }
    }

    private void Arrange(Align _align)
    {
        var head = infiniteItems[0];

        var offset1 = Vector2.zero;
        switch (_align)
        {
            case Align.Left:
                offset1 = new Vector2(-content.rect.width * 0.5f + head.rectTransform.rect.width * 0.5f + m_BoundOffset.left, 0);
                break;
            case Align.Right:
                offset1 = new Vector2(content.rect.width * 0.5f - head.rectTransform.rect.width * 0.5f - m_BoundOffset.right, 0);
                break;
            case Align.Top:
                offset1 = new Vector2(0f, content.rect.height * 0.5f - head.rectTransform.rect.height * 0.5f - m_BoundOffset.top);
                break;
            case Align.Bottom:
                offset1 = new Vector2(0f, -content.rect.height * 0.5f + head.rectTransform.rect.height * 0.5f + m_BoundOffset.bottom);
                break;
        }

        head.rectTransform.anchoredPosition = content.anchoredPosition + offset1;

        var offset2 = CalculateElementOffset(_align);
        for (int i = 1; i < infiniteItems.Count; i++)
        {
            var item = infiniteItems[i];
            item.rectTransform.anchoredPosition = head.rectTransform.anchoredPosition + offset2 * i;
        }
    }

    private void ElementsMatch()
    {
        if (content == null)
        {
            UnityEngine.Debug.Log("Content 不能为空！");
            return;
        }

        infiniteItems.Clear();
        for (int i = 0; i < content.childCount; i++)
        {
            var infiniteItem = content.GetChild(i).GetComponent<ScrollItem>();
            if (infiniteItem != null)
            {
                infiniteItems.Add(infiniteItem);
                infiniteItem.rectTransform.sizeDelta = cellSize;
                infiniteItem.rectTransform.anchorMax = Vector2.one * 0.5f;
                infiniteItem.rectTransform.anchorMin = Vector2.one * 0.5f;
                infiniteItem.rectTransform.pivot = Vector2.one * 0.5f;
            }
        }

        content.anchorMax = content.anchorMin = content.pivot = Vector2.one * 0.5f;
        content.sizeDelta = rectTransform.sizeDelta;
        content.anchoredPosition = Vector2.zero;
    }

    private void FillBatchData(int _startIndex)
    {
        int min = Mathf.Min(infiniteItems.Count, dataCount);
        preIndex = Mathf.Clamp(_startIndex, 0, dataCount - min);
        hostIndex = preIndex + min - 1;

        for (int i = 0; i < infiniteItems.Count; i++)
        {
            var item = infiniteItems[i];
            if (i <= hostIndex - preIndex)
            {
                item.SetActive(true);
                item.Display(datas[preIndex + i]);
                item.LuaDisplay(preIndex + i);
            }
            else
            {
                item.SetActive(false);
                item.Dispose();
                item.LuaDispose();
            }
        }
    }

    private Vector2 CalculateElementOffset(Align _align)
    {
        switch (_align)
        {
            case Align.Left:
                return new Vector2(cellSize.x + spacing.x, 0);
            case Align.Right:
                return new Vector2(-cellSize.x - spacing.x, 0);
            case Align.Top:
                return new Vector2(0, -cellSize.y - spacing.y);
            case Align.Bottom:
                return new Vector2(0, cellSize.y + spacing.y);
            default:
                return Vector2.zero;
        }
    }

    private bool TestMoveNext(Align _align, ScrollItem _item)
    {
        var itemMinPosition = _item.rectTransform.GetMinReferencePosition(rectTransform);
        var itemMaxPosition = _item.rectTransform.GetMaxReferencePosition(rectTransform);

        switch (_align)
        {
            case Align.Left:
                return itemMaxPosition.x < minOffset.x;
            case Align.Bottom:
                return itemMaxPosition.y < minOffset.y;
            case Align.Right:
                return itemMinPosition.x > maxOffset.x;
            case Align.Top:
                return itemMinPosition.y > maxOffset.y;
            default:
                return false;
        }
    }

    private bool TestMoveLast(Align _align, ScrollItem _item)
    {
        var itemMinPosition = _item.rectTransform.GetMinReferencePosition(rectTransform);
        var itemMaxPosition = _item.rectTransform.GetMaxReferencePosition(rectTransform);

        switch (_align)
        {
            case Align.Left:
                return itemMinPosition.x > maxOffset.x;
            case Align.Bottom:
                return itemMinPosition.y > maxOffset.y;
            case Align.Right:
                return itemMaxPosition.x < minOffset.x;
            case Align.Top:
                return itemMaxPosition.y < minOffset.y;
            default:
                return false;
        }
    }

    public enum Align
    {
        Left,
        Right,
        Top,
        Bottom,
    }

    [Serializable]
    public struct BoundOffset
    {
        public float left;
        public float right;
        public float top;
        public float bottom;
    }

}