// 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.Generic;
using System.Collections.Immutable;
using System.Diagnostics;
using Microsoft.AspNetCore.Razor.Threading;
using Microsoft.AspNetCore.Razor.Utilities;
 
namespace Microsoft.AspNetCore.Razor.Language;
 
public abstract partial class TagHelperCollection
{
    /// <summary>
    ///  Represents an abstract collection of tag helper descriptors organized into segments.
    /// </summary>
    /// <remarks>
    ///  SegmentCollection provides efficient lookup and indexing for tag helper descriptors by
    ///  utilizing a segmented internal structure. This class is intended to be used as a base
    ///  for specialized collections that require optimized access patterns for large numbers of
    ///  tag helpers. Thread safety and mutability depend on the implementation of the derived class.
    /// </remarks>
    private abstract class SegmentCollectionBase : TagHelperCollection
    {
        private LazyValue<TagHelperCollection, Dictionary<Checksum, int>> _lazyLookupTable = new(collection =>
        {
            var lookupTable = new Dictionary<Checksum, int>(collection.Count);
            var index = 0;
 
            foreach (var segment in collection.Segments)
            {
                foreach (var item in segment.Span)
                {
                    lookupTable.Add(item.Checksum, index++);
                }
            }
 
            return lookupTable;
        });
 
        private LazyValue<TagHelperCollection, Checksum> _lazyChecksum = new(collection =>
        {
            var builder = new Checksum.Builder();
 
            foreach (var segment in collection.Segments)
            {
                foreach (var item in segment.Span)
                {
                    builder.Append(item.Checksum);
                }
            }
 
            return builder.FreeAndGetChecksum();
        });
 
        private bool UseLookupTable => Count > 8;
 
        private Dictionary<Checksum, int> LookupTable
        {
            get
            {
                Debug.Assert(UseLookupTable);
                return _lazyLookupTable.GetValue(this);
            }
        }
 
        internal override Checksum Checksum
            => _lazyChecksum.GetValue(this);
 
        public override int IndexOf(TagHelperDescriptor item)
        {
            if (UseLookupTable)
            {
                return LookupTable.TryGetValue(item.Checksum, out var index)
                    ? index
                    : -1;
            }
 
            var currentOffset = 0;
 
            foreach (var segment in Segments)
            {
                var index = segment.Span.IndexOf(item);
 
                if (index >= 0)
                {
                    return currentOffset + index;
                }
 
                currentOffset += segment.Length;
            }
 
            return -1;
        }
 
        public override void CopyTo(Span<TagHelperDescriptor> destination)
        {
            ArgHelper.ThrowIfDestinationTooShort(destination, Count);
 
            foreach (var segment in Segments)
            {
                segment.Span.CopyTo(destination);
                destination = destination[segment.Length..];
            }
        }
    }
}