// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System;
using System.Collections.Immutable;
using System.Diagnostics;
using System.Linq;
 
namespace Microsoft.AspNetCore.Razor.Language;
 
public abstract partial class TagHelperCollection
{
    /// <summary>
    ///  Represents a read-only collection of <see cref="TagHelperDescriptor"/> objects composed
    ///  from multiple contiguous memory segments, providing efficient indexed access across all segments.
    /// </summary>
    /// <remarks>
    ///  This collection is optimized for scenarios where <see cref="TagHelperDescriptor"/> items
    ///  are distributed across several memory segments, allowing for efficient access without merging
    ///  the segments into a single array. The collection is immutable and thread-safe for concurrent
    ///  read operations.
    /// </remarks>
    private sealed class MultiSegmentCollection : SegmentCollectionBase
    {
        private readonly ImmutableArray<ReadOnlyMemory<TagHelperDescriptor>> _segments;
        private readonly int[] _segmentStartIndices;
        private readonly int _count;
 
        public MultiSegmentCollection(ImmutableArray<ReadOnlyMemory<TagHelperDescriptor>> segments)
        {
            Debug.Assert(segments.Length > 0, "Segments cannot be empty.");
 
            _segments = segments;
 
            // Pre-calculate segment boundaries for efficient indexing
            _segmentStartIndices = new int[segments.Length];
            var count = 0;
 
            for (var i = 0; i < segments.Length; i++)
            {
                Debug.Assert(segments[i].Length > 0, "Segments cannot be empty.");
 
                _segmentStartIndices[i] = count;
                count += segments[i].Length;
            }
 
            _count = count;
        }
 
        protected override int SegmentCount => _segments.Length;
 
        protected override ReadOnlyMemory<TagHelperDescriptor> GetSegment(int index)
        {
            Debug.Assert(index >= 0 && index < _segments.Length);
 
            return _segments[index];
        }
 
        public override int Count => _count;
 
        public override TagHelperDescriptor this[int index]
        {
            get
            {
                ArgHelper.ThrowIfNegative(index);
                ArgHelper.ThrowIfGreaterThanOrEqual(index, Count);
 
                // Binary search to find the segment containing this index
                var segmentIndex = FindSegmentIndex(index);
                var localIndex = index - _segmentStartIndices[segmentIndex];
 
                return _segments[segmentIndex].Span[localIndex];
            }
        }
 
        private int FindSegmentIndex(int index)
        {
            var searchResult = _segmentStartIndices.BinarySearch(index);
 
            if (searchResult >= 0)
            {
                return searchResult;
            }
 
            var insertionPoint = ~searchResult;
            return insertionPoint - 1;
        }
    }
}