namespace Gpm.Ui
{
    using System.Collections.Generic;
    using UnityEngine;

    /// <summary>
    /// 이 partial 클래스는 InfiniteScroll의 레이아웃 관련 로직을 담당합니다.
    /// 아이템의 배치, 줄 계산, 스크롤 영역 업데이트 등 UI 레이아웃에 필요한 모든 계산을 처리합니다.
    /// InfiniteScroll.cs의 일부로, 코드 관리를 용이하게 하기 위해 별도 파일로 분리되었습니다.
    /// </summary>
    public partial class InfiniteScroll
    {
        [Header("Layout", order = 3)]
        [Tooltip("스크롤 뷰의 레이아웃 설정을 담고 있는 객체입니다. 인스펙터에서 스크롤 방향, 간격, 그리드 등을 설정할 수 있습니다.")]
        public ScrollLayout layout = new ScrollLayout();

        /// <summary>
        /// 스크롤 뷰 내에서 한 줄(Row 또는 Column)의 레이아웃 정보를 관리하는 클래스입니다.
        /// 예: 수직 스크롤에서는 하나의 가로 줄(Row)을 의미합니다.
        /// </summary>
        public class LineLayout
        {
            /// <summary>
            /// LineLayout 생성자입니다.
            /// </summary>
            /// <param name="index">해당 줄의 인덱스입니다.</param>
            public LineLayout(int index)
            {
                this.index = index;
            }

            /// <summary>
            /// 줄의 모든 데이터를 초기화합니다.
            /// </summary>
            public void Clear()
            {
                dataList.Clear();
                offset = 0;
                size = 0;
            }

            /// <summary>
            /// 현재 줄에 데이터(아이템)를 추가하고, 줄의 전체 크기를 갱신합니다.
            /// </summary>
            /// <param name="context">추가할 아이템의 데이터 컨텍스트입니다.</param>
            /// <returns>아이템 추가 후 갱신된 줄의 끝 위치를 반환합니다.</returns>
            public float Add(DataContext context)
            {
                context.offset = offset;
                dataList.Add(context);

                // 아이템의 크기를 가져옵니다.
                float contextSize = context.GetItemSize();

                // 현재 줄의 크기(size)는 줄에 포함된 아이템들 중 가장 큰 아이템의 크기를 따릅니다.
                if (size < contextSize)
                {
                    size = contextSize;
                }

                // 이 줄의 시작 위치(offset)에 크기(size)를 더하여 이 줄이 차지하는 최종 위치를 반환합니다.
                return offset + size;
            }

            /// <summary>
            /// 이 줄의 인덱스입니다.
            /// </summary>
            internal int index = 0;

            /// <summary>
            /// 이 줄에 포함된 아이템들의 데이터 리스트입니다.
            /// </summary>
            internal List<DataContext> dataList = new List<DataContext>();

            /// <summary>
            /// 스크롤의 주 축(main axis)을 기준으로 이 줄의 시작 위치(offset)입니다.
            /// </summary>
            internal float offset = 0;

            /// <summary>
            /// 스크롤의 주 축을 기준으로 이 줄의 크기입니다.
            /// 이 줄에 포함된 아이템 중 가장 큰 아이템의 크기와 같습니다.
            /// </summary>
            internal float size = 0;

            /// <summary>
            /// 이 줄에 포함된 아이템의 개수를 반환합니다.
            /// </summary>
            /// <returns>아이템 개수</returns>
            public int GetCount()
            {
                return dataList.Count;
            }
        }

        /// <summary>
        /// 스크롤 뷰의 레이아웃 관련 상태를 캐싱하는 클래스입니다.
        /// 매 프레임마다 모든 값을 다시 계산하는 것을 피하고, 변경이 있을 때만 레이아웃을 업데이트하여 성능을 최적화합니다.
        /// </summary>
        public class CachedScrollData
        {
            /// <summary>
            /// 스크롤 콘텐츠의 현재 위치입니다.
            /// </summary>
            public float contentPosition = 0;

            /// <summary>
            /// 스크롤 콘텐츠의 전체 크기입니다.
            /// </summary>
            public float contentSize = 0;

            /// <summary>
            /// 스크롤 뷰포트(보여지는 영역)의 크기입니다.
            /// </summary>
            public float viewportSize = 0;

            /// <summary>
            /// 캐시된 콘텐츠 여백(padding)입니다.
            /// </summary>
            public Vector2 padding;

            /// <summary>
            /// 캐시된 아이템 간 간격(space)입니다.
            /// </summary>
            public Vector2 space;

            /// <summary>
            /// 캐시된 그리드의 수입니다. (예: 3열 그리드이면 3)
            /// </summary>
            public int gridCount = 0;

            /// <summary>
            /// 캐시된 스크롤 축 정보입니다.
            /// </summary>
            public ScrollAxis axis;

            /// <summary>
            /// 캐시된 수직 스크롤 방향입니다. (true: 위에서 아래로)
            /// </summary>
            public bool topToBotton = true;

            /// <summary>
            /// 캐시된 수평 스크롤 방향입니다. (true: 왼쪽에서 오른쪽으로)
            /// </summary>
            public bool leftToRight = true;

            /// <summary>
            /// 캐시된 그리드 레이아웃 값 리스트입니다.
            /// </summary>
            public List<ScrollLayout.LayoutValue> values = new List<ScrollLayout.LayoutValue>();

            /// <summary>
            /// 현재 스크롤이 수직인지 여부입니다.
            /// </summary>
            public bool IsVertical = false;

            /// <summary>
            /// 캐시된 아이템의 앵커 최소값입니다.
            /// </summary>
            public Vector2 anchorMin = Vector2.zero;

            /// <summary>
            /// 캐시된 아이템의 앵커 최대값입니다.
            /// </summary>
            public Vector2 anchorMax = Vector2.zero;

            /// <summary>
            /// 캐시된 아이템의 피벗입니다.
            /// </summary>
            public Vector2 itemPivot = Vector2.zero;

            /// <summary>
            /// 캐시된 콘텐츠의 피벗입니다.
            /// </summary>
            public Vector2 contentPivot = Vector2.zero;

            /// <summary>
            /// 캐시된 모든 데이터를 초기화합니다.
            /// </summary>
            public void Clear()
            {
                contentPosition = 0;
                contentSize = 0;
                viewportSize = 0;
            }
        }

        // 레이아웃 계산에 사용되는 내부 변수들
        internal List<LineLayout> lineLayout = new List<LineLayout>(); // 전체 라인들의 레이아웃 정보를 담는 리스트
        internal float layoutSize = 0;  // 모든 라인들의 크기를 합한 총 레이아웃 크기
        internal int lineCount = 0; // 현재 데이터로 계산된 총 라인 수

        private int showLineIndex = 0; // 화면에 보이는 첫 번째 라인의 인덱스
        private int showLineCount = 0; // 화면에 보이는 총 라인의 수

        private int firstItemIndex = 0; // 화면에 보이는 첫 번째 아이템의 인덱스
        private int lastItemIndex = 0; // 화면에 보이는 마지막 아이템의 인덱스

        // 레이아웃 업데이트 상태를 관리하는 플래그
        private bool isUpdateArea = false; // 스크롤 영역(위치, 크기)이 변경되었는지 여부
        private bool isRebuildLayout = false; // 레이아웃을 처음부터 다시 빌드했는지 여부

        protected bool needReBuildLayout = true; // 레이아웃을 다시 빌드해야 하는지 여부 (데이터 변경, 설정 변경 시 true)

        private bool isStartLine = true; // 스크롤이 시작 지점에 있는지 여부
        private bool isEndLine = true; // 스크롤이 끝 지점에 있는지 여부

        internal bool processing = false; // 현재 레이아웃 업데이트가 진행 중인지 여부 (중복 실행 방지)

        // 레이아웃 상태 캐싱을 위한 객체
        private CachedScrollData cachedData = new CachedScrollData();

        // 앵커 업데이트가 필요한지 여부
        internal bool anchorUpdate = false;

        // 구버전과의 호환성을 위한 필드. 현재는 layout.padding을 사용합니다.
        [SerializeField]
        [HideInInspector]
        [System.Obsolete("padding is obsolete. Use GetMainPadding() instead (UnityUpgradable) -> GetMainPadding()", false)]
        private int padding = 0;

        // 구버전과의 호환성을 위한 필드. 현재는 layout.space를 사용합니다.
        [SerializeField]
        [HideInInspector]
        [System.Obsolete("space is obsolete. Use GetMainSpace() instead (UnityUpgradable) -> GetMainSpace()", false)]
        private int space = 0;

        /// <summary>
        /// 스크롤 축(방향)을 설정합니다.
        /// </summary>
        /// <param name="axis">설정할 스크롤 축</param>
        public void SetScrollAxis(ScrollAxis axis)
        {
            layout.axis = axis;

            CheckScrollAxis();
            CheckScrollData();
        }

        /// <summary>
        /// 현재 설정된 스크롤 축을 가져옵니다.
        /// </summary>
        /// <returns>현재 스크롤 축</returns>
        public ScrollAxis GetScrollAxis()
        {
            return layout.axis;
        }

        /// <summary>
        /// 콘텐츠의 여백(padding)을 설정합니다.
        /// </summary>
        /// <param name="padding">x: 가로 여백, y: 세로 여백</param>
        public void SetPadding(Vector2 padding)
        {
            layout.padding = padding;
        }

        /// <summary>
        /// 아이템 간의 간격(space)을 설정합니다.
        /// </summary>
        /// <param name="space">x: 가로 간격, y: 세로 간격</param>
        public void SetSpace(Vector2 space)
        {
            layout.space = space;
        }

        /// <summary>
        /// 현재 설정된 여백(padding)을 가져옵니다.
        /// </summary>
        /// <returns>현재 여백</returns>
        public Vector2 GetPadding()
        {
            return layout.padding;
        }

        /// <summary>
        /// 현재 설정된 아이템 간 간격(space)을 가져옵니다.
        /// </summary>
        /// <returns>현재 간격</returns>
        public Vector2 GetSpace()
        {
            return layout.space;
        }

        /// <summary>
        /// 스크롤 주 축 방향의 여백을 가져옵니다.
        /// </summary>
        /// <returns>주 축 여백</returns>
        public float GetMainPadding()
        {
#pragma warning disable 618
            // 구버전 호환성 코드
            if (padding > 0)
            {
                layout.MainPadding = padding;
                padding = 0;
            }
#pragma warning restore 618
            return layout.MainPadding;
        }

        /// <summary>
        /// 스크롤 주 축 방향의 아이템 간 간격을 가져옵니다.
        /// </summary>
        /// <returns>주 축 간격</returns>
        public float GetMainSpace()
        {
#pragma warning disable 618
            // 구버전 호환성 코드
            if (space > 0)
            {
                layout.MainSpace = space;
                space = 0;
            }
#pragma warning restore 618
            return layout.MainSpace;
        }

        /// <summary>
        /// 스크롤 교차 축 방향의 여백을 가져옵니다.
        /// </summary>
        /// <returns>교차 축 여백</returns>
        public float GetCrossPadding()
        {
            return layout.CrossPadding;
        }

        /// <summary>
        /// 스크롤 교차 축 방향의 아이템 간 간격을 가져옵니다.
        /// </summary>
        /// <returns>교차 축 간격</returns>
        public float GetCrossSpace()
        {
            return layout.CrossSpace;
        }

        /// <summary>
        /// 레이아웃 관련 데이터의 변경 사항을 확인하고, 업데이트가 필요한 경우 관련 플래그를 설정합니다.
        /// 이 메서드는 매 프레임 호출되어 스크롤 위치, 뷰포트 크기, 레이아웃 설정 등의 변경을 감지합니다.
        /// </summary>
        protected void CheckScrollData()
        {
            float contentPosition = GetContentPosition();
            float viewportSize = GetViewportSize();
            float contentSize = GetContentSize();

            // 스크롤 위치, 콘텐츠 크기, 뷰포트 크기 변경 감지
            if (cachedData.contentPosition != contentPosition)
            {
                cachedData.contentPosition = contentPosition;
                isUpdateArea = true; // 보이는 영역이 변경되었으므로 업데이트 필요
            }

            if (cachedData.contentSize != contentSize)
            {
                cachedData.contentSize = contentSize;
                isUpdateArea = true;
            }

            if (cachedData.viewportSize != viewportSize)
            {
                cachedData.viewportSize = viewportSize;
                isUpdateArea = true;
            }

            // 간격(space) 변경 감지
            if (cachedData.space != layout.space)
            {
                cachedData.space = layout.space;
                needReBuildLayout = true; // 레이아웃 구조가 변경되었으므로 재계산 필요
            }

            // 그리드 수 또는 그리드 설정값 변경 감지
            if (cachedData.padding != layout.padding)
            {
                cachedData.padding = layout.padding;
                needReBuildLayout = true;
            }

            if (cachedData.gridCount != layout.values.Count)
            {
                cachedData.gridCount = layout.values.Count;

                needReBuildLayout = true;
            }

            if (layout.values.Count > 0)
            {
                for (int i = 0; i < layout.values.Count; i++)
                {
                    if (cachedData.values.Count < i + 1)
                    {
                        cachedData.values.Add(new ScrollLayout.LayoutValue());
                        needReBuildLayout = true;
                    }

                    if (cachedData.values[i].valueType != layout.values[i].valueType ||
                        cachedData.values[i].value != layout.values[i].value)
                    {
                        cachedData.values[i].valueType = layout.values[i].valueType;
                        cachedData.values[i].value = layout.values[i].value;

                        needReBuildLayout = true;
                    }
                }
            }

            bool isUpdateLayout = false;
            // 스크롤 축, 방향 등 레이아웃의 근본적인 구조 변경 감지
            if (cachedData.axis != layout.axis)
            {
                cachedData.axis = layout.axis;

                bool IsVertical = layout.IsVertical();
                if (cachedData.IsVertical != IsVertical)
                {
                    cachedData.IsVertical = IsVertical;

                    // ScrollRect의 스크롤 방향을 동기화
                    if (layout.IsVertical() == true)
                    {
                        scrollRect.vertical = true;
                    }
                    else
                    {
                        scrollRect.horizontal = true;
                    }
                }

                isUpdateLayout = true;
            }

            if (cachedData.topToBotton != layout.topToBotton)
            {
                cachedData.topToBotton = layout.topToBotton;
                isUpdateLayout = true;
            }

            if (cachedData.leftToRight != layout.leftToRight)
            {
                cachedData.leftToRight = layout.leftToRight;
                isUpdateLayout = true;
            }

            // 레이아웃 구조가 변경되었다면, 앵커와 피벗을 다시 계산하고 적용
            if (isUpdateLayout == true)
            {
                anchorUpdate = true;

                // 아이템과 콘텐츠의 앵커, 피벗 값을 새로 계산하여 캐시
                Rect anchor = layout.GetItemAnchor();
                cachedData.anchorMin = new Vector2(anchor.xMin, anchor.yMin);
                cachedData.anchorMax = new Vector2(anchor.xMax, anchor.yMax);

                cachedData.itemPivot = layout.GetItemPivot();
                cachedData.contentPivot = layout.GetAxisPivot();

                // 변경된 축 정보를 실제 RectTransform에 적용
                UpdateAxis();

                isUpdateArea = true; // 영역 업데이트 필요

                isUpdateLayout = false;
                anchorUpdate = false;
            }
        }

        /// <summary>
        /// 캐시된 앵커 및 피벗 값을 콘텐츠와 아이템들의 RectTransform에 적용합니다.
        /// 스크롤 방향이 변경될 때 호출됩니다.
        /// </summary>
        private void UpdateAxis()
        {
            // 스크롤 위치를 보존하기 위해 현재 normalizedPosition을 저장
            Vector2 normalizedPosition = scrollRect.normalizedPosition;

            // 콘텐츠(Content)의 앵커와 피벗을 설정
            content.anchorMin = cachedData.anchorMin;
            content.anchorMax = cachedData.anchorMax;
            content.pivot = cachedData.contentPivot;

            // 현재 활성화된 모든 아이템 객체들의 앵커와 피벗도 동일하게 설정
            for (int index = 0; index < itemObjectList.Count; ++index)
            {
                itemObjectList[index].SetAxis(cachedData.anchorMin, cachedData.anchorMax, cachedData.itemPivot);
            }

            // 스크롤 위치 복원
            scrollRect.normalizedPosition = normalizedPosition;
        }

        /// <summary>
        /// ScrollRect의 스크롤 가능 여부(vertical/horizontal)를 현재 레이아웃 축 설정에 맞게 조정합니다.
        /// </summary>
        public void CheckScrollAxis()
        {
            layout.CheckAxis(scrollRect);
        }

        /// <summary>
        /// 모든 아이템을 포함하는 데 필요한 총 거리를 계산합니다.
        /// </summary>
        protected float GetItemTotalSize()
        {
            return GetTotalDistance();
        }

        /// <summary>
        /// 특정 아이템까지의 거리를 계산합니다.
        /// </summary>
        /// <param name="itemIndex">아이템의 인덱스</param>
        /// <returns>스크롤 시작점부터 해당 아이템이 속한 라인까지의 거리</returns>
        protected float GetItemDistance(int itemIndex)
        {
            int lineIndex = GetLineIndex(itemIndex);
            return GetLineDistance(GetLineOffset(lineIndex), lineIndex);
        }

        /// <summary>
        /// 전체 데이터 리스트를 기반으로 레이아웃을 처음부터 다시 계산하고 빌드합니다.
        /// 데이터가 변경되거나 레이아웃 설정이 변경될 때 호출됩니다.
        /// </summary>
        protected void BuildLayout()
        {
            ClearLayout();

            // 모든 데이터에 대해 반복
            for (int dataIndex = 0; dataIndex < dataList.Count; dataIndex++)
            {
                var context = dataList[dataIndex];

                // 유효한 아이템만 레이아웃에 추가
                if (context.itemIndex == -1)
                {
                    continue;
                }

                AddItem(context);
            }

            // 계산된 레이아웃 크기에 맞게 콘텐츠(Content)의 크기를 조절
            ResizeContent();

            isRebuildLayout = true; // 재빌드가 완료되었음을 표시
        }

        /// <summary>
        /// 현재 스크롤 위치를 기준으로 화면에 보여야 할 라인(line)의 범위를 계산합니다.
        /// `showLineIndex`와 `showLineCount`를 설정합니다.
        /// </summary>
        protected void CheckShowLine()
        {
            bool showLine = false;

            showLineIndex = 0;
            showLineCount = 0;

            // 모든 라인을 순회하며 화면에 보이는지 검사
            for (int lineIndex = 0; lineIndex < GetLineCount(); lineIndex++)
            {
                var line = GetLine(lineIndex);
                if (showLine == false)
                {
                    // 뷰포트 상단 이전에 끝나는 라인은 건너뛴다.
                    if (IsShowBeforePosition(GetLineDistance(line.offset + line.size, lineIndex), cachedData.contentPosition) == false)
                    {
                        showLineIndex = lineIndex; // 화면에 보이기 시작하는 첫 라인
                        showLine = true;

                        showLineCount++;
                    }
                }
                else
                {
                    // 뷰포트 하단을 벗어나는 라인이 나오면 중단
                    if (IsShowAfterPosition(GetLineDistance(line.offset, lineIndex), cachedData.contentPosition, cachedData.viewportSize) == true)
                    {
                        break;
                    }

                    showLineCount++;
                }
            }

            // 스크롤바 크기 조절
            ResizeScrollView();
        }

        /// <summary>
        /// 화면에 보이는 아이템들을 업데이트하고, 보이지 않는 아이템은 비활성화(재활용)합니다.
        /// 스크롤이 움직일 때 주로 호출됩니다.
        /// </summary>
        /// <param name="forceUpdateData">true이면 보이는 모든 아이템의 데이터를 강제로 새로고침합니다.</param>
        protected void UpdateShowItem(bool forceUpdateData = false)
        {
            // 이미 처리 중이면 중복 실행 방지
            if (forceUpdateData == false &&
                processing == true)
            {
                return;
            }

            // 아이템 업데이트가 필요 없으면 종료
            if (NeedUpdateItem() == false)
            {
                return;
            }

            processing = true;

            // 레이아웃 재빌드가 필요하면 실행
            if (forceUpdateData == true ||
                needReBuildLayout == true)
            {
                BuildLayout();
                needReBuildLayout = false;
            }

            // 스크롤 영역이 변경되었거나 레이아웃이 재빌드되었다면, 보이는 라인을 다시 계산
            if (forceUpdateData == true ||
                isUpdateArea == true ||
                isRebuildLayout == true)
            {
                CheckShowLine();

                isUpdateArea = false;
                isRebuildLayout = false;
            }

            // 보이는 아이템의 첫 인덱스와 마지막 인덱스를 계산
            int prevFirstItemIndex = firstItemIndex;
            firstItemIndex = GetLineFirstItemIndex(showLineIndex);

            int prevLastItemIndex = lastItemIndex;
            if (showLineCount > 0)
            {
                int lastLineIndex = showLineIndex + showLineCount - 1;
                lastItemIndex = GetLineLastItemIndex(lastLineIndex);
            }
            else
            {
                lastItemIndex = firstItemIndex;
            }

            // 보이는 아이템 범위가 변경되었는지 확인
            if (prevFirstItemIndex < firstItemIndex ||
                prevLastItemIndex > lastItemIndex)
            {
                changeValue = true;
            }

            // ** 아이템 비활성화 (재활용) **
            // 현재 활성화된 아이템 객체들 중, 새로 계산된 보이는 범위(first ~ last)를 벗어난 것들을 비활성화
            for (int index = 0; index < itemObjectList.Count; ++index)
            {
                int linkedIndex = itemObjectList[index].GetItemIndex();
                if (linkedIndex < firstItemIndex ||
                    linkedIndex > lastItemIndex)
                {
                    if (itemObjectList[index].IsActive() == true)
                    {
                        itemObjectList[index].SetActive(false);
                    }
                }
            }

            // ** 아이템 활성화 및 업데이트 **
            // 화면에 보여야 할 라인들을 순회
            for (int lineIndex = showLineIndex; lineIndex < showLineIndex + showLineCount; lineIndex++)
            {
                if (lineIndex >= GetLineCount())
                {
                    break;
                }

                var line = GetLine(lineIndex);
                // 해당 라인에 속한 모든 아이템에 대해
                for (int i = 0; i < line.GetCount(); i++)
                {
                    var context = line.dataList[i];

                    // 아이템 풀에서 재활용할 아이템 객체를 가져옴
                    InfiniteScrollItem item = PullItem(context);

                    bool needUpdateItemData = false;

                    // 아이템이 비활성 상태이거나, 데이터가 변경되었으면 데이터 업데이트 필요
                    if (item.IsActive() == false ||
                        item.GetDataIndex() != context.index ||
                        context.IsNeedUpdateItemData() == true)
                    {
                        needUpdateItemData = true;
                        changeValue = true;
                    }

                    // 데이터 업데이트가 필요하거나, 강제 업데이트 모드일 때
                    if (needUpdateItemData == true || forceUpdateData == true)
                    {
                        item.UpdateItem(context);
                    }

                    // 아이템이 비활성 상태였다면 활성화
                    if (item.IsActive() == false)
                    {
                        item.SetActive(true, true);
                    }

                    RectTransform itemTransform = (RectTransform)item.transform;

                    // 앵커와 피벗 설정
                    itemTransform.anchorMin = cachedData.anchorMin;
                    itemTransform.anchorMax = cachedData.anchorMax;
                    itemTransform.pivot = cachedData.itemPivot;

                    // 동적 아이템 크기 모드에서 크기 업데이트가 필요하면 적용
                    if (item.needUpdateItemSize == true)
                    {
                        float size = context.GetItemSize();

                        layout.FitItemSize(itemTransform, context.itemIndex, size);

                        item.needUpdateItemSize = false;
                    }

                    // 최종 위치 계산 및 적용
                    FitItemPosition(itemTransform, context.itemIndex);
                }
            }

            if (changeValue == true)
            {
                onChangeValue.Invoke(firstItemIndex, lastItemIndex, isStartLine, isEndLine);
                changeValue = false;
            }

            ResizeContent();

            processing = false;
        }

        /// <summary>
        /// 아이템의 RectTransform 위치를 계산하고 적용합니다.
        /// </summary>
        /// <param name="rectTransform">위치를 설정할 아이템의 RectTransform</param>
        /// <param name="itemIndex">아이템의 인덱스</param>
        protected void FitItemPosition(RectTransform rectTransform, int itemIndex)
        {
            // 교차 축 위치 설정 (예: 수직 스크롤에서 좌/우 위치)
            layout.FitItemInlinePosition(rectTransform, itemIndex, GetCrossSize());

            // 주 축 위치 설정 (예: 수직 스크롤에서 상/하 위치)
            float itemPosition = GetItemPosition(itemIndex);
            rectTransform.anchoredPosition = layout.GetAxisVector(Vector2.zero, itemPosition);
        }

        /// <summary>
        /// 오프셋 값을 실제 anchoredPosition 값으로 변환합니다.
        /// </summary>
        protected float ItemPostionFromOffset(float offset)
        {
            float postion = layout.GetAxisPostionFromOffset(offset);

            // 콘텐츠와 아이템의 피벗 차이를 보정
            postion += GetPivotPostion();

            return postion;
        }

        /// <summary>
        /// 콘텐츠와 아이템의 피벗 차이로 인해 발생하는 위치 오차를 계산합니다.
        /// </summary>
        protected float GetPivotPostion()
        {
            float contentSize = GetContentSize();
            if (layout.IsVertical() == true)
            {
                return contentSize * (cachedData.contentPivot.y - cachedData.itemPivot.y);
            }
            else
            {
                return contentSize * (cachedData.contentPivot.x - cachedData.itemPivot.x);
            }
        }

        /// <summary>
        /// 레이아웃 계산에 사용되는 변수들을 초기화합니다.
        /// </summary>
        protected void ClearLayout()
        {
            layoutSize = 0;
            lineCount = 0;
        }

        /// <summary>
        /// 데이터를 레이아웃에 추가합니다. 그리드 설정에 따라 자동으로 줄바꿈을 처리합니다.
        /// </summary>
        /// <param name="context">추가할 아이템의 데이터 컨텍스트</param>
        protected void AddItem(DataContext context)
        {
            bool newLine = false;
            LineLayout currentLine = null;

            int lineIndex = lineCount - 1;
            if (lineCount == 0)
            {
                // 첫 아이템은 항상 새 라인에서 시작
                newLine = true;
            }
            else if (lineIndex < lineCount)
            {
                currentLine = lineLayout[lineIndex];
                // 현재 라인이 그리드 수만큼 꽉 찼으면 새 라인으로
                if (currentLine.GetCount() >= layout.GridCount())
                {
                    newLine = true;
                }
            }
            else
            {
                newLine = true;
            }

            if (newLine == true)
            {
                lineIndex = lineCount;

                // 기존에 생성된 LineLayout 객체가 있으면 재사용, 없으면 새로 생성
                if (lineIndex < lineLayout.Count)
                {
                    currentLine = lineLayout[lineIndex];
                }
                else
                {
                    currentLine = new LineLayout(lineIndex);
                    lineLayout.Add(currentLine);
                }

                currentLine.Clear();
                currentLine.offset = layoutSize; // 새 라인의 시작 위치는 현재까지의 총 레이아웃 크기

                newLine = false;
                lineCount++;
            }
            else
            {
                currentLine = lineLayout[lineIndex];
            }

            // 현재 라인에 아이템을 추가하고, 레이아웃 전체 크기를 갱신
            layoutSize = currentLine.Add(context);
        }

        /// <summary>
        /// 아이템 인덱스로 해당 아이템의 데이터 컨텍스트를 가져옵니다.
        /// </summary>
        protected DataContext GetItem(int itemIndex)
        {
            if (layout.IsGrid() == true)
            {
                int gridCount = layout.GridCount();

                int line = itemIndex / gridCount; // 아이템이 속한 라인 인덱스
                int index = itemIndex % gridCount; // 라인 내에서의 인덱스

                return lineLayout[line].dataList[index];
            }
            else
            {
                // 그리드가 아니면 아이템 인덱스가 라인 인덱스와 동일
                return lineLayout[itemIndex].dataList[0];
            }
        }

        /// <summary>
        /// 라인 인덱스로 해당 라인의 LineLayout 객체를 가져옵니다.
        /// </summary>
        protected LineLayout GetLine(int lineIndex)
        {
            return lineLayout[lineIndex];
        }

        /// <summary>
        /// 라인 인덱스로 해당 라인의 시작 위치(offset)를 가져옵니다.
        /// </summary>
        protected float GetLineOffset(int lineIndex)
        {
            return lineLayout[lineIndex].offset;
        }

        /// <summary>
        /// 아이템 인덱스로 해당 아이템이 속한 라인의 시작 위치(offset)를 가져옵니다.
        /// </summary>
        protected float GetItemOffset(int itemIndex)
        {
            int lineIndex = GetLineIndex(itemIndex);

            return lineLayout[lineIndex].offset;
        }

        /// <summary>
        /// 아이템 인덱스로 해당 아이템이 속한 라인의 인덱스를 계산합니다.
        /// </summary>
        protected int GetLineIndex(int itemIndex)
        {
            if (layout.IsGrid() == true)
            {
                return itemIndex / layout.GridCount();
            }
            return itemIndex; // 그리드가 아니면 아이템 인덱스 = 라인 인덱스
        }

        /// <summary>
        /// 해당 아이템이 라인의 마지막 아이템인지 확인합니다.
        /// </summary>
        protected bool IsLast(int itemIndex)
        {
            if (layout.IsGrid() == true)
            {
                if ((itemIndex + 1) % layout.GridCount() == 0)
                {
                    return true;
                }

                return false;
            }

            return true; // 그리드가 아니면 모든 아이템이 마지막 아이템
        }

        /// <summary>
        /// 현재 레이아웃의 총 라인 수를 가져옵니다.
        /// </summary>
        protected int GetLineCount()
        {
            return lineCount;
        }

        /// <summary>
        /// 모든 아이템, 여백, 간격을 포함한 콘텐츠의 총 거리를 계산합니다.
        /// </summary>
        protected float GetTotalDistance()
        {
            int lineCount = GetLineCount();

            // 총 라인 크기 + 상하/좌우 여백
            float size = layoutSize + GetMainPadding() * UPDOWN_MULTIPLY;
            if (lineCount > 1)
            {
                // 라인 간의 간격 추가
                size += ((lineCount - 1) * GetMainSpace());
            }

            return size;
        }

        /// <summary>
        /// 특정 라인까지의 실제 거리를 계산합니다. (여백, 간격 포함)
        /// </summary>
        /// <param name="offset">라인의 기본 오프셋</param>
        /// <param name="lineIndex">라인의 인덱스</param>
        /// <returns>스크롤 시작점부터의 실제 거리</returns>
        protected float GetLineDistance(float offset, int lineIndex)
        {
            float distance = offset + GetMainPadding();
            if (lineIndex > 0)
            {
                distance += lineIndex * GetMainSpace();
            }

            return distance;
        }

        /// <summary>
        /// 특정 라인에 포함된 첫 번째 아이템의 인덱스를 가져옵니다.
        /// </summary>
        protected int GetLineFirstItemIndex(int lineIndex)
        {
            int lineCount = GetLineCount();
            if (lineCount == 0)
            {
                return 0;
            }

            if (lineIndex >= lineCount)
            {
                lineIndex = lineCount - 1;
            }

            int firstItemIndex = lineIndex;
            if (layout.IsGrid() == true)
            {
                firstItemIndex = firstItemIndex * layout.GridCount();
            }

            if (firstItemIndex < 0)
            {
                firstItemIndex = 0;
            }

            return firstItemIndex;
        }

        /// <summary>
        /// 특정 라인에 포함된 마지막 아이템의 인덱스를 가져옵니다.
        /// </summary>
        protected int GetLineLastItemIndex(int lineIndex)
        {
            int lineCount = GetLineCount();
            if (lineCount == 0)
            {
                return 0;
            }
            if (lineIndex >= lineCount)
            {
                lineIndex = lineCount - 1;
            }

            int lastItemIndex = 0;
            if (layout.IsGrid() == true)
            {
                if (lineIndex > 0)
                {
                    lastItemIndex = lineIndex * layout.GridCount();
                }

                lastItemIndex += lineLayout[lineIndex].GetCount() - 1;
            }
            else
            {
                lastItemIndex = lineIndex;
            }

            return lastItemIndex;
        }

        /// <summary>
        /// 특정 라인의 크기(주 축 기준)를 가져옵니다.
        /// </summary>
        protected float GetLineSize(int lineIndex)
        {
            int lineCount = GetLineCount();
            if (lineCount == 0)
            {
                return 0;
            }

            if (lineIndex >= lineCount)
            {
                lineIndex = lineCount - 1;
            }

            return lineLayout[lineIndex].size;
        }
    }
}