// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System.Collections;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Runtime.CompilerServices;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.WebUtilities;
using Microsoft.Extensions.Primitives;
 
namespace Microsoft.AspNetCore.Components.Endpoints.FormMapping;
 
[DebuggerDisplay($"{{{nameof(DebuggerDisplay)}(),nq}}")]
internal struct FormDataReader : IDisposable
{
    private readonly IReadOnlyDictionary<FormKey, StringValues> _readOnlyMemoryKeys;
    private readonly Memory<char> _prefixBuffer;
    private Memory<char> _currentPrefixBuffer;
    private int _currentDepth;
    private int _errorCount;
 
    // As an implementation detail, reuse FormKey for the values.
    // It's just a thin wrapper over ReadOnlyMemory<char> that caches
    // the computed hash code.
 
    private PrefixResolver _prefixResolver;
 
    public FormDataReader(IReadOnlyDictionary<FormKey, StringValues> formCollection, CultureInfo culture, Memory<char> buffer)
    {
        _readOnlyMemoryKeys = formCollection;
        Culture = culture;
        _prefixBuffer = buffer;
    }
 
    public FormDataReader(IReadOnlyDictionary<FormKey, StringValues> formCollection, CultureInfo culture, Memory<char> buffer, IFormFileCollection formFileCollection)
        : this(formCollection, culture, buffer)
    {
        FormFileCollection = formFileCollection;
    }
 
    internal ReadOnlyMemory<char> CurrentPrefix => _currentPrefixBuffer;
 
    public IFormatProvider Culture { get; }
 
    public IFormFileCollection? FormFileCollection { get; internal set; }
 
    public int MaxRecursionDepth { get; set; } = 64;
 
    public int MaxCollectionSize { get; set; } = FormReader.DefaultValueCountLimit;
 
    public Action<string, FormattableString, string?>? ErrorHandler { get; set; }
 
    public Action<string, object>? AttachInstanceToErrorsHandler { get; set; }
 
    public int MaxErrorCount { get; set; } = 200;
 
    public void AddMappingError(FormattableString errorMessage, string? attemptedValue)
    {
        ArgumentNullException.ThrowIfNull(errorMessage);
 
        if (ErrorHandler == null)
        {
            throw new FormDataMappingException(new FormDataMappingError(_currentPrefixBuffer.ToString(), errorMessage, attemptedValue));
        }
 
        _errorCount++;
        if (_errorCount == MaxErrorCount)
        {
            ErrorHandler.Invoke(
                _currentPrefixBuffer.ToString(),
                FormattableStringFactory.Create($"Maximum number of errors ({MaxErrorCount}) reached. Further errors will be suppressed."),
                null);
        }
 
        if (_errorCount >= MaxErrorCount)
        {
            return;
        }
 
        ErrorHandler.Invoke(_currentPrefixBuffer.ToString(), errorMessage, attemptedValue);
    }
 
    public void AddMappingError(Exception exception, string? attemptedValue)
    {
        ArgumentNullException.ThrowIfNull(exception);
 
        // Avoid re-wrapping the exception if it is already a FormDataMappingException
        // and we don't have an ErrorHandler configured.
        if (exception is FormDataMappingException && ErrorHandler == null)
        {
            throw exception;
        }
 
        var errorMessage = FormattableStringFactory.Create(exception.Message);
        AddMappingError(errorMessage, attemptedValue);
    }
 
    public void AttachInstanceToErrors(object value)
    {
        if (AttachInstanceToErrorsHandler == null)
        {
            return;
        }
 
        AttachInstanceToErrorsHandler(_currentPrefixBuffer.ToString(), value);
    }
 
    internal FormKeyCollection GetKeys()
    {
        // Scan the input dictionary for keys matching the current prefix followed by a bracket segment.
        // This avoids building a large upfront dictionary of all prefix→key mappings.
        var prefix = _currentPrefixBuffer;
        var result = new HashSet<FormKey>();
 
        foreach (var kvp in _readOnlyMemoryKeys)
        {
            var key = kvp.Key.Value;
 
            // The key must start with the current prefix (case-insensitive).
            if (key.Length <= prefix.Length ||
                !key.Span[..prefix.Length].Equals(prefix.Span, StringComparison.OrdinalIgnoreCase))
            {
                continue;
            }
 
            // Immediately after the prefix, there must be a '['.
            if (key.Span[prefix.Length] != '[')
            {
                continue;
            }
 
            // Find the closing ']' after the '['.
            var remaining = key[prefix.Length..];
            var closeIndex = remaining.Span[1..].IndexOf(']');
            if (closeIndex == -1)
            {
                // Malformed key — no closing bracket. Skip it.
                continue;
            }
 
            // Extract "[value]" (closeIndex is relative to position 1, so add 2 for the full segment).
            var segment = remaining[..(closeIndex + 2)];
            result.Add(new FormKey(segment));
 
            // Allow one extra item through so collection/dictionary binding can still detect overflow
            // and report the existing max-size error instead of silently truncating the input.
            if (result.Count > MaxCollectionSize)
            {
                break;
            }
        }
 
        return result.Count > 0
            ? new FormKeyCollection(result)
            : FormKeyCollection.Empty;
    }
 
    // This only ever gets invoked if we have a recursive type.
    // Recursive types make an existential check for the current prefix to determine if they
    // need to continue mapping data.
    // At that point, we are placing the keys into a sorted array, and we use binary search to
    // determine if the prefix exists.
    // We only make this search on recursive paths, as opposed to in every new scope that we push.
    internal bool CurrentPrefixExists()
    {
        if (CurrentPrefix.Span.Length == 0)
        {
            // Avoid creating the prefix array at the root level.
            return _readOnlyMemoryKeys.Count > 0;
        }
 
        if (!_prefixResolver.HasValues)
        {
            _prefixResolver = new PrefixResolver(_readOnlyMemoryKeys.Keys, _readOnlyMemoryKeys.Count);
        }
 
        return _prefixResolver.HasPrefix(_currentPrefixBuffer);
    }
 
    internal void PopPrefix(string key)
    {
        PopPrefix(key.AsSpan());
    }
 
    internal void PopPrefix(ReadOnlySpan<char> key)
    {
        if (_currentDepth > MaxRecursionDepth)
        {
            return;
        }
 
        _currentDepth--;
        Debug.Assert(_currentDepth >= 0);
        var keyLength = key.Length;
        // If keyLength is bigger than the current scope keyLength typically means there is a
        // bug where some part of the code has not popped the scope appropriately.
        Debug.Assert(_currentPrefixBuffer.Length >= keyLength);
        if (_currentPrefixBuffer.Length == keyLength || _currentPrefixBuffer.Span[^(keyLength + 1)] != '.')
        {
            _currentPrefixBuffer = _currentPrefixBuffer[..^keyLength];
        }
        else
        {
            _currentPrefixBuffer = _currentPrefixBuffer[..^(keyLength + 1)];
        }
    }
 
    internal void PushPrefix(string key)
    {
        PushPrefix(key.AsSpan());
    }
 
    internal void PushPrefix(scoped ReadOnlySpan<char> key)
    {
        _currentDepth++;
        // We automatically append a "." before adding the suffix, except when its the first element pushed to the
        // scope, or when we are accessing a property after a collection or an indexer like items[1].
        var separator = _currentPrefixBuffer.Length > 0 && key[0] != '['
            ? ".".AsSpan()
            : "".AsSpan();
        if (_currentDepth > MaxRecursionDepth)
        {
            throw new InvalidOperationException($"The maximum recursion depth of '{MaxRecursionDepth}' was exceeded for '{_currentPrefixBuffer}{separator}{key}'.");
        }
 
        Debug.Assert(_prefixBuffer.Length >= (_currentPrefixBuffer.Length + separator.Length));
 
        separator.CopyTo(_prefixBuffer.Span[_currentPrefixBuffer.Length..]);
 
        var startingPoint = _currentPrefixBuffer.Length + separator.Length;
        _currentPrefixBuffer = _prefixBuffer.Slice(0, startingPoint + key.Length);
        key.CopyTo(_prefixBuffer[startingPoint..].Span);
    }
 
    internal readonly bool TryGetValue([NotNullWhen(true)] out string? value)
    {
        var foundSingleValue = _readOnlyMemoryKeys.TryGetValue(new FormKey(_currentPrefixBuffer), out var result) || result.Count == 1;
        if (foundSingleValue)
        {
            value = result[0];
        }
        else
        {
            value = null;
        }
 
        return foundSingleValue;
    }
 
    internal readonly bool TryGetValues(out StringValues values) =>
        _readOnlyMemoryKeys.TryGetValue(new FormKey(_currentPrefixBuffer), out values);
 
    internal string GetPrefix() => _currentPrefixBuffer.ToString();
 
    internal string GetLastPrefixSegment()
    {
        var index = _currentPrefixBuffer.Span.LastIndexOfAny(".[");
        if (index == -1)
        {
            return _currentPrefixBuffer.ToString();
        }
        if (_currentPrefixBuffer.Span[index] == '.')
        {
            return _currentPrefixBuffer.Span[(index + 1)..].ToString();
        }
        else
        {
            // Return the value without the closing bracket ]
            return _currentPrefixBuffer.Span[(index + 1)..^1].ToString();
        }
    }
 
    public void Dispose()
    {
        _prefixResolver.Dispose();
    }
 
    internal readonly struct FormKeyCollection : IEnumerable<ReadOnlyMemory<char>>
    {
        private readonly HashSet<FormKey> _values;
        internal static readonly FormKeyCollection Empty;
 
        public bool HasValues() => _values != null;
 
        public FormKeyCollection(HashSet<FormKey> values) => _values = values;
 
        public Enumerator GetEnumerator() => new Enumerator(_values.GetEnumerator());
 
        IEnumerator<ReadOnlyMemory<char>> IEnumerable<ReadOnlyMemory<char>>.GetEnumerator() => GetEnumerator();
 
        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
        internal struct Enumerator : IEnumerator<ReadOnlyMemory<char>>
        {
            private HashSet<FormKey>.Enumerator _enumerator;
 
            public Enumerator(HashSet<FormKey>.Enumerator enumerator)
            {
                _enumerator = enumerator;
            }
 
            public ReadOnlyMemory<char> Current => _enumerator.Current.Value;
 
            object IEnumerator.Current => _enumerator.Current;
 
            void IDisposable.Dispose() => _enumerator.Dispose();
 
            public bool MoveNext() => _enumerator.MoveNext();
 
            void IEnumerator.Reset() { }
        }
    }
 
    private readonly string DebuggerDisplay =>
        $"Key count = {_readOnlyMemoryKeys.Count}, Prefix = {_currentPrefixBuffer}, Error count = {_errorCount}, Current depth = {_currentDepth}";
}