using UnityEngine;
using System.Collections.Generic;

public enum ScrollDirection
{
    Horizontal,
    Vertical
}

public enum LoopMode
{
    Normal,
    InfiniteLoop
}

public enum SnapMode
{
    Free,
    CenterAligned
}

public enum DragMode
{
    FixedDistance,
    MouseDistance
}

public enum EasingType
{
    Linear,
    EaseIn,
    EaseOut,
    EaseInOut
}

public class CustomListComponent : MonoBehaviour
{
    [Header("基本设置")] [SerializeField] private ScrollDirection direction = ScrollDirection.Horizontal;
    [SerializeField] private LoopMode loopMode = LoopMode.InfiniteLoop;
    [SerializeField] private SnapMode snapMode = SnapMode.CenterAligned;
    [SerializeField] private DragMode dragMode = DragMode.MouseDistance;
    [SerializeField] private EasingType easingType = EasingType.EaseOut;

    [Header("Item设置")] [SerializeField] private GameObject itemPrefab;
    [SerializeField] private float itemSize = 100f;
    [SerializeField] private float spacing = 20f;

    [Header("动画设置")] [SerializeField] private float snapSpeed = 5f;
    [SerializeField] private float dragSensitivity = 1f;
    [SerializeField] private float fixedDragDistance = 50f;

    [Header("数据")] [SerializeField] private List<ItemData> itemDataList = new List<ItemData>();

    private RectTransform rectTransform;
    private List<ItemInstance> activeItems = new List<ItemInstance>();
    private float viewportSize;
    private int maxVisibleItems;
    private float totalContentSize;
    private float currentPosition;
    private float targetPosition;
    private Vector2 lastMousePosition;
    private bool isDragging;
    private int centerItemIndex;
    private float dragStartTime;
    private float dragStartPosition;

    [System.Serializable]
    public class ItemData
    {
        public string id;
        public string name;
        public Sprite icon;
        public object data;
    }

    private class ItemInstance
    {
        public GameObject gameObject;
        public RectTransform rectTransform;
        public int dataIndex;
        public ItemUI itemUI;
    }

    public delegate void CenterItemChangedHandler(int index, ItemData data);

    public event CenterItemChangedHandler OnCenterItemChanged;

    private void Awake()
    {
        rectTransform = GetComponent<RectTransform>();
        CalculateViewportSize();
        CalculateMaxVisibleItems();
        InitializeItems();
    }

    private void CalculateViewportSize()
    {
        if (direction == ScrollDirection.Horizontal)
        {
            viewportSize = rectTransform.rect.width;
        }
        else
        {
            viewportSize = rectTransform.rect.height;
        }
    }

    private void CalculateMaxVisibleItems()
    {
        // 计算最多需要多少个Item才能铺满视口
        maxVisibleItems = Mathf.CeilToInt((viewportSize + spacing) / (itemSize + spacing)) + 2;
        Debug.Log($"最多可见Item数量: {maxVisibleItems}");
    }

    private void InitializeItems()
    {
        // 清除现有Item
        foreach (var item in activeItems)
        {
            Destroy(item.gameObject);
        }

        activeItems.Clear();

        // 创建必要的Item实例
        for (int i = 0; i < maxVisibleItems; i++)
        {
            GameObject itemGO = Instantiate(itemPrefab, transform);
            ItemInstance item = new ItemInstance
            {
                gameObject = itemGO,
                rectTransform = itemGO.GetComponent<RectTransform>(),
                dataIndex = i % itemDataList.Count,
                itemUI = itemGO.GetComponent<ItemUI>()
            };

            UpdateItemPosition(item, i);
            UpdateItemData(item);

            activeItems.Add(item);
        }

        // 计算总内容大小
        totalContentSize = itemDataList.Count * (itemSize + spacing) - spacing;

        // 初始化位置
        currentPosition = 0;
        targetPosition = 0;
        UpdateCenterItem();
    }

    private void UpdateItemPosition(ItemInstance item, int index)
    {
        float position = index * (itemSize + spacing);

        if (direction == ScrollDirection.Horizontal)
        {
            item.rectTransform.anchoredPosition = new Vector2(position - currentPosition, 0);
        }
        else
        {
            item.rectTransform.anchoredPosition = new Vector2(0, -(position - currentPosition));
        }
    }

    private void UpdateItemData(ItemInstance item)
    {
        if (item.itemUI != null && item.dataIndex < itemDataList.Count)
        {
            item.itemUI.SetData(itemDataList[item.dataIndex]);
        }
    }

    private void Update()
    {
        HandleInput();
        UpdateScrollPosition();
        UpdateItems();
    }

    private void HandleInput()
    {
        if (Input.GetMouseButtonDown(0))
        {
            if (RectTransformUtility.RectangleContainsScreenPoint(rectTransform, Input.mousePosition))
            {
                isDragging = true;
                lastMousePosition = Input.mousePosition;
                dragStartTime = Time.time;
                dragStartPosition = currentPosition;
            }
        }

        if (Input.GetMouseButtonUp(0))
        {
            if (isDragging)
            {
                isDragging = false;

                if (snapMode == SnapMode.CenterAligned)
                {
                    SnapToNearestItem();
                }
            }
        }

        if (isDragging)
        {
            Vector2 mouseDelta = Input.mousePosition - new Vector3(lastMousePosition.x, lastMousePosition.y, 0);
            lastMousePosition = Input.mousePosition;

            float dragAmount = direction == ScrollDirection.Horizontal ? mouseDelta.x : -mouseDelta.y;

            if (dragMode == DragMode.FixedDistance)
            {
                dragAmount = Mathf.Sign(dragAmount) * fixedDragDistance;
            }

            currentPosition -= dragAmount * dragSensitivity;

            // 处理边界
            if (loopMode == LoopMode.Normal)
            {
                currentPosition = Mathf.Clamp(currentPosition, 0, Mathf.Max(0, totalContentSize - viewportSize));
            }
        }
    }

    private void UpdateScrollPosition()
    {
        if (!isDragging && currentPosition != targetPosition)
        {
            float deltaTime = Time.deltaTime * snapSpeed;

            // 应用缓动函数
            switch (easingType)
            {
                case EasingType.Linear:
                    currentPosition = Mathf.Lerp(currentPosition, targetPosition, deltaTime);
                    break;
                case EasingType.EaseIn:
                    currentPosition = EaseIn(currentPosition, targetPosition, deltaTime);
                    break;
                case EasingType.EaseOut:
                    currentPosition = EaseOut(currentPosition, targetPosition, deltaTime);
                    break;
                case EasingType.EaseInOut:
                    currentPosition = EaseInOut(currentPosition, targetPosition, deltaTime);
                    break;
            }

            if (Mathf.Abs(currentPosition - targetPosition) < 0.1f)
            {
                currentPosition = targetPosition;
            }
        }
    }

    private void UpdateItems()
    {
        if (loopMode == LoopMode.InfiniteLoop)
        {
            // 处理无限循环
            foreach (var item in activeItems)
            {
                bool needsUpdate = false;

                if (direction == ScrollDirection.Horizontal)
                {
                    float itemPos = item.rectTransform.anchoredPosition.x + currentPosition;

                    // 如果Item超出左边界，移动到右侧
                    if (itemPos < -itemSize)
                    {
                        item.dataIndex = (item.dataIndex + activeItems.Count) % itemDataList.Count;
                        needsUpdate = true;
                    }
                    // 如果Item超出右边界，移动到左侧
                    else if (itemPos > viewportSize)
                    {
                        item.dataIndex = (item.dataIndex - activeItems.Count + itemDataList.Count) % itemDataList.Count;
                        needsUpdate = true;
                    }
                }
                else
                {
                    float itemPos = -(item.rectTransform.anchoredPosition.y - currentPosition);

                    // 如果Item超出上边界，移动到下侧
                    if (itemPos < -itemSize)
                    {
                        item.dataIndex = (item.dataIndex + activeItems.Count) % itemDataList.Count;
                        needsUpdate = true;
                    }
                    // 如果Item超出下边界，移动到上侧
                    else if (itemPos > viewportSize)
                    {
                        item.dataIndex = (item.dataIndex - activeItems.Count + itemDataList.Count) % itemDataList.Count;
                        needsUpdate = true;
                    }
                }

                if (needsUpdate)
                {
                    UpdateItemData(item);

                    // 重新计算位置
                    int virtualIndex = Mathf.FloorToInt(currentPosition / (itemSize + spacing));
                    virtualIndex = (virtualIndex + item.dataIndex) % itemDataList.Count;

                    UpdateItemPosition(item, virtualIndex);
                }
                else
                {
                    // 仅更新位置
                    UpdateItemPosition(item,
                        Mathf.FloorToInt((item.rectTransform.anchoredPosition.x + currentPosition) /
                                         (itemSize + spacing)));
                }
            }
        }

        UpdateCenterItem();
    }

    private void SnapToNearestItem()
    {
        if (itemDataList.Count == 0) return;

        // 计算最接近中心的Item
        float centerPos = viewportSize / 2;
        float closestDistance = float.MaxValue;
        int closestIndex = 0;

        foreach (var item in activeItems)
        {
            float itemPos = direction == ScrollDirection.Horizontal
                ? item.rectTransform.anchoredPosition.x + itemSize / 2
                : -(item.rectTransform.anchoredPosition.y - itemSize / 2);

            float distance = Mathf.Abs(itemPos - centerPos);

            if (distance < closestDistance)
            {
                closestDistance = distance;
                closestIndex = item.dataIndex;
            }
        }

        // 设置目标位置
        float targetPos = closestIndex * (itemSize + spacing);

        // 调整目标位置使选中的Item居中
        if (direction == ScrollDirection.Horizontal)
        {
            targetPos -= (viewportSize - itemSize) / 2;
        }
        else
        {
            targetPos -= (viewportSize - itemSize) / 2;
        }

        // 限制在边界内
        if (loopMode == LoopMode.Normal)
        {
            targetPos = Mathf.Clamp(targetPos, 0, Mathf.Max(0, totalContentSize - viewportSize));
        }

        targetPosition = targetPos;
    }

    private void UpdateCenterItem()
    {
        float centerPos = viewportSize / 2;
        float closestDistance = float.MaxValue;
        int newCenterIndex = -1;

        foreach (var item in activeItems)
        {
            float itemPos = direction == ScrollDirection.Horizontal
                ? item.rectTransform.anchoredPosition.x + itemSize / 2
                : -(item.rectTransform.anchoredPosition.y - itemSize / 2);

            float distance = Mathf.Abs(itemPos - centerPos);

            if (distance < closestDistance)
            {
                closestDistance = distance;
                newCenterIndex = item.dataIndex;
            }
        }

        if (newCenterIndex != centerItemIndex && newCenterIndex >= 0 && newCenterIndex < itemDataList.Count)
        {
            centerItemIndex = newCenterIndex;
            OnCenterItemChanged?.Invoke(centerItemIndex, itemDataList[centerItemIndex]);
        }
    }

    // 缓动函数
    private float EaseIn(float start, float end, float value)
    {
        end -= start;
        return end * Mathf.Pow(value, 2) + start;
    }

    private float EaseOut(float start, float end, float value)
    {
        end -= start;
        return -end * value * (value - 2) + start;
    }

    private float EaseInOut(float start, float end, float value)
    {
        value /= 0.5f;
        end -= start;

        if (value < 1)
        {
            return end * 0.5f * Mathf.Pow(value, 2) + start;
        }

        value--;
        return -end * 0.5f * (value * (value - 2) - 1) + start;
    }

    // 公共方法
    public void SetDirection(ScrollDirection newDirection)
    {
        direction = newDirection;
        CalculateViewportSize();
        InitializeItems();
    }

    public void SetLoopMode(LoopMode newMode)
    {
        loopMode = newMode;
    }

    public void SetSnapMode(SnapMode newMode)
    {
        snapMode = newMode;
    }

    public void SetDragMode(DragMode newMode)
    {
        dragMode = newMode;
    }

    public void SetEasingType(EasingType newType)
    {
        easingType = newType;
    }

    public void SetItemSize(float size)
    {
        itemSize = size;
        CalculateMaxVisibleItems();
        InitializeItems();
    }

    public void SetSpacing(float newSpacing)
    {
        spacing = newSpacing;
        CalculateMaxVisibleItems();
        InitializeItems();
    }

    public void SetItemData(List<ItemData> dataList)
    {
        itemDataList = dataList;
        CalculateMaxVisibleItems();
        InitializeItems();
    }

    public ItemData GetCenterItemData()
    {
        if (centerItemIndex >= 0 && centerItemIndex < itemDataList.Count)
        {
            return itemDataList[centerItemIndex];
        }

        return null;
    }
}