using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;

public interface ICarouselItem
{
    RectTransform RectTransform { get; }
    void SetSelected(bool selected);
}

public abstract class CarouselView<TItem, TData> : MonoBehaviour, IDragHandler, IEndDragHandler, IBeginDragHandler
    where TItem : MonoBehaviour, ICarouselItem
{
    public event Action OnSelectedIndexChanged;

    readonly List<TItem> items = new List<TItem>();
    List<TData> dataList;

    float currentCenterOffset;
    float targetCenterOffset;
    bool isDragging;
    int currentSelectedIndex;

    protected abstract RectTransform Content { get; }
    protected abstract GameObject ItemPrefab { get; }
    protected abstract float ItemSpacing { get; }
    protected abstract float ScaleMax { get; }
    protected abstract float ScaleMin { get; }
    protected virtual int PoolSize => 7;
    protected int CurrentSelectedIndex => currentSelectedIndex;
    protected IReadOnlyList<TData> DataList => dataList;

    public void InitPool()
    {
        if (items.Count > 0)
            return;

        for (int i = 0; i < PoolSize; i++)
        {
            GameObject go = Instantiate(ItemPrefab, Content);
            TItem item = go.GetComponent<TItem>();
            if (item == null)
                continue;
            items.Add(item);
        }
    }

    public void InitWithIndex(int index)
    {
        if (dataList.IsNullOrEmpty())
            return;

        index = Mathf.Clamp(index, 0, dataList.Count - 1);
        currentSelectedIndex = index;
        currentCenterOffset = index;
        targetCenterOffset = index;
        UpdateItems();
    }

    public void SelectIndex(int index)
    {
        if (dataList.IsNullOrEmpty())
            return;

        index = GetRealIndex(index);

        int oldIndex = currentSelectedIndex;
        currentSelectedIndex = index;
        targetCenterOffset = index;
        currentCenterOffset = index;
        UpdateItems();

        if (oldIndex != currentSelectedIndex)
            OnSelectedIndexChanged?.Invoke();
    }

    public void SelectPrevious()
    {
        if (dataList.IsNullOrEmpty())
            return;

        int newIndex = (currentSelectedIndex - 1 + dataList.Count) % dataList.Count;
        SelectIndex(newIndex);
    }

    public void SelectNext()
    {
        if (dataList.IsNullOrEmpty())
            return;

        int newIndex = (currentSelectedIndex + 1) % dataList.Count;
        SelectIndex(newIndex);
    }

    public void RefreshAllItems()
    {
        if (!dataList.IsNullOrEmpty())
            UpdateItems();
    }

    protected void SetDataList(List<TData> newDataList, int selectedIndex)
    {
        dataList = newDataList;

        if (dataList.IsNullOrEmpty())
        {
            HideAllItems();
            return;
        }

        InitWithIndex(selectedIndex);
    }

    protected bool TryGetCurrentData(out TData data)
    {
        data = default(TData);
        if (dataList.IsNullOrEmpty() || currentSelectedIndex < 0)
            return false;

        int realIndex = GetRealIndex(currentSelectedIndex);
        data = dataList[realIndex];
        return true;
    }

    protected void HideAllItems()
    {
        for (int i = 0; i < items.Count; i++)
        {
            if (items[i] != null)
                items[i].gameObject.SetActive(false);
        }
    }

    protected virtual void OnDestroy()
    {
        items.Clear();
    }

    protected virtual void Update()
    {
        if (!isDragging && Mathf.Abs(currentCenterOffset - targetCenterOffset) > 0.001f)
        {
            currentCenterOffset = Mathf.Lerp(currentCenterOffset, targetCenterOffset, Time.deltaTime * 10f);
            if (Mathf.Abs(currentCenterOffset - targetCenterOffset) <= 0.001f)
                currentCenterOffset = targetCenterOffset;
            UpdateItems();
        }
    }

    void UpdateItems()
    {
        if (dataList.IsNullOrEmpty())
            return;

        int poolSize = items.Count;
        int startOffset = Mathf.FloorToInt(currentCenterOffset) - (poolSize / 2);
        int selectedLogicIndex = Mathf.RoundToInt(targetCenterOffset);

        for (int i = 0; i < poolSize; i++)
        {
            int logicIndex = startOffset + i;
            int realIndex = GetRealIndex(logicIndex);

            float distanceToCenter = logicIndex - currentCenterOffset;
            float posX = distanceToCenter * ItemSpacing;

            TItem itemUI = items[i];
            if (itemUI == null || itemUI.RectTransform == null)
                continue;

            itemUI.gameObject.SetActive(true);
            itemUI.RectTransform.anchoredPosition = new Vector2(posX, 0);

            float absDist = Mathf.Abs(distanceToCenter);
            float scaleProgress = Mathf.Clamp01(1f - absDist);
            float currentScale = Mathf.Lerp(ScaleMin, ScaleMax, scaleProgress);
            itemUI.RectTransform.localScale = Vector3.one * currentScale;

            bool isSelected = logicIndex == selectedLogicIndex;
            RefreshItem(itemUI, dataList[realIndex], realIndex, isSelected);
            itemUI.SetSelected(isSelected);
        }
    }

    int GetRealIndex(int logicIndex)
    {
        return (logicIndex % dataList.Count + dataList.Count) % dataList.Count;
    }

    protected abstract void RefreshItem(TItem item, TData data, int realIndex, bool isSelected);

    public void OnBeginDrag(PointerEventData eventData)
    {
        isDragging = true;
    }

    public void OnDrag(PointerEventData eventData)
    {
        if (dataList.IsNullOrEmpty())
            return;

        float dragDeltaX = eventData.delta.x;
        currentCenterOffset -= dragDeltaX / ItemSpacing;
        UpdateItems();
    }

    public void OnEndDrag(PointerEventData eventData)
    {
        if (dataList.IsNullOrEmpty())
            return;

        isDragging = false;

        float speedX = eventData.delta.x;
        if (speedX > 5f)
        {
            targetCenterOffset = Mathf.Floor(currentCenterOffset);
        }
        else if (speedX < -5f)
        {
            targetCenterOffset = Mathf.Ceil(currentCenterOffset);
        }
        else
        {
            targetCenterOffset = Mathf.Round(currentCenterOffset);
        }

        int oldIndex = currentSelectedIndex;
        currentSelectedIndex = GetRealIndex(Mathf.RoundToInt(targetCenterOffset));
        UpdateItems();

        if (oldIndex != currentSelectedIndex)
            OnSelectedIndexChanged?.Invoke();
    }
}