// 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 Microsoft.AspNetCore.Shared;
using Microsoft.Extensions.Primitives;
using Microsoft.Net.Http.Headers;
 
namespace Microsoft.AspNetCore.Http;
 
/// <summary>
/// Represents a wrapper for RequestHeaders and ResponseHeaders.
/// </summary>
[DebuggerDisplay("{DebuggerToString(),nq}")]
[DebuggerTypeProxy(typeof(StringValuesDictionaryDebugView))]
public class HeaderDictionary : IHeaderDictionary
{
    private static readonly string[] EmptyKeys = Array.Empty<string>();
    private static readonly StringValues[] EmptyValues = Array.Empty<StringValues>();
    // Pre-box
    private static readonly IEnumerator<KeyValuePair<string, StringValues>> EmptyIEnumeratorType = default(Enumerator);
    private static readonly IEnumerator EmptyIEnumerator = default(Enumerator);
 
    /// <summary>
    /// Initializes a new instance of <see cref="HeaderDictionary"/>.
    /// </summary>
    public HeaderDictionary()
    {
    }
 
    /// <summary>
    /// Initializes a new instance of <see cref="HeaderDictionary"/>.
    /// </summary>
    /// <param name="store">The value to use as the backing store.</param>
    public HeaderDictionary(Dictionary<string, StringValues>? store)
    {
        Store = store;
    }
 
    /// <summary>
    /// Initializes a new instance of <see cref="HeaderDictionary"/>.
    /// </summary>
    /// <param name="capacity">The initial number of headers that this instance can contain.</param>
    public HeaderDictionary(int capacity)
    {
        EnsureStore(capacity);
    }
 
    private Dictionary<string, StringValues>? Store { get; set; }
 
    [MemberNotNull(nameof(Store))]
    private void EnsureStore(int capacity)
    {
        if (Store == null)
        {
            Store = new Dictionary<string, StringValues>(capacity, StringComparer.OrdinalIgnoreCase);
        }
    }
 
    /// <summary>
    /// Get or sets the associated value from the collection as a single string.
    /// </summary>
    /// <param name="key">The header name.</param>
    /// <returns>the associated value from the collection as a StringValues or StringValues.Empty if the key is not present.</returns>
    public StringValues this[string key]
    {
        get
        {
            if (Store == null)
            {
                return StringValues.Empty;
            }
 
            if (TryGetValue(key, out var value))
            {
                return value;
            }
 
            return StringValues.Empty;
        }
        set
        {
            ArgumentNullException.ThrowIfNull(key);
            ThrowIfReadOnly();
 
            if (value.Count == 0)
            {
                Store?.Remove(key);
            }
            else
            {
                EnsureStore(1);
                Store[key] = value;
            }
        }
    }
 
    StringValues IDictionary<string, StringValues>.this[string key]
    {
        get
        {
            if (Store == null)
            {
                ThrowKeyNotFoundException();
            }
 
            return Store[key];
        }
        set
        {
            ThrowIfReadOnly();
            this[key] = value;
        }
    }
 
    /// <inheritdoc />
    public long? ContentLength
    {
        get
        {
            long value;
            var rawValue = this[HeaderNames.ContentLength];
            if (rawValue.Count == 1 &&
                !string.IsNullOrEmpty(rawValue[0]) &&
                HeaderUtilities.TryParseNonNegativeInt64(new StringSegment(rawValue[0]).Trim(), out value))
            {
                return value;
            }
 
            return null;
        }
        set
        {
            ThrowIfReadOnly();
            if (value.HasValue)
            {
                this[HeaderNames.ContentLength] = HeaderUtilities.FormatNonNegativeInt64(value.GetValueOrDefault());
            }
            else
            {
                this.Remove(HeaderNames.ContentLength);
            }
        }
    }
 
    /// <summary>
    /// Gets the number of elements contained in the <see cref="HeaderDictionary" />;.
    /// </summary>
    /// <returns>The number of elements contained in the <see cref="HeaderDictionary" />.</returns>
    public int Count => Store?.Count ?? 0;
 
    /// <summary>
    /// Gets a value that indicates whether the <see cref="HeaderDictionary" /> is in read-only mode.
    /// </summary>
    /// <returns>true if the <see cref="HeaderDictionary" /> is in read-only mode; otherwise, false.</returns>
    public bool IsReadOnly { get; set; }
 
    /// <summary>
    /// Gets the collection of HTTP header names in this instance.
    /// </summary>
    public ICollection<string> Keys
    {
        get
        {
            if (Store == null)
            {
                return EmptyKeys;
            }
            return Store.Keys;
        }
    }
 
    /// <summary>
    /// Gets the collection of HTTP header values in this instance.
    /// </summary>
    public ICollection<StringValues> Values
    {
        get
        {
            if (Store == null)
            {
                return EmptyValues;
            }
            return Store.Values;
        }
    }
 
    /// <summary>
    /// Adds a new header item to the collection.
    /// </summary>
    /// <param name="item">The item to add.</param>
    public void Add(KeyValuePair<string, StringValues> item)
    {
        if (item.Key == null)
        {
            throw new ArgumentException("The key is null");
        }
        ThrowIfReadOnly();
        EnsureStore(1);
        Store.Add(item.Key, item.Value);
    }
 
    /// <summary>
    /// Adds the given header and values to the collection.
    /// </summary>
    /// <param name="key">The header name.</param>
    /// <param name="value">The header values.</param>
    public void Add(string key, StringValues value)
    {
        ArgumentNullException.ThrowIfNull(key);
        ThrowIfReadOnly();
        EnsureStore(1);
        Store.Add(key, value);
    }
 
    /// <summary>
    /// Clears the entire list of objects.
    /// </summary>
    public void Clear()
    {
        ThrowIfReadOnly();
        Store?.Clear();
    }
 
    /// <summary>
    /// Returns a value indicating whether the specified object occurs within this collection.
    /// </summary>
    /// <param name="item">The item.</param>
    /// <returns>true if the specified object occurs within this collection; otherwise, false.</returns>
    public bool Contains(KeyValuePair<string, StringValues> item)
    {
        if (Store == null ||
            !Store.TryGetValue(item.Key, out var value) ||
            !StringValues.Equals(value, item.Value))
        {
            return false;
        }
        return true;
    }
 
    /// <summary>
    /// Determines whether the <see cref="HeaderDictionary" /> contains a specific key.
    /// </summary>
    /// <param name="key">The key.</param>
    /// <returns>true if the <see cref="HeaderDictionary" /> contains a specific key; otherwise, false.</returns>
    public bool ContainsKey(string key)
    {
        if (Store == null)
        {
            return false;
        }
        return Store.ContainsKey(key);
    }
 
    /// <summary>
    /// Copies the <see cref="HeaderDictionary" /> elements to a one-dimensional Array instance at the specified index.
    /// </summary>
    /// <param name="array">The one-dimensional Array that is the destination of the specified objects copied from the <see cref="HeaderDictionary" />.</param>
    /// <param name="arrayIndex">The zero-based index in <paramref name="array" /> at which copying begins.</param>
    public void CopyTo(KeyValuePair<string, StringValues>[] array, int arrayIndex)
    {
        if (Store == null)
        {
            return;
        }
 
        foreach (var item in Store)
        {
            array[arrayIndex] = item;
            arrayIndex++;
        }
    }
 
    /// <summary>
    /// Removes the given item from the the collection.
    /// </summary>
    /// <param name="item">The item.</param>
    /// <returns>true if the specified object was removed from the collection; otherwise, false.</returns>
    public bool Remove(KeyValuePair<string, StringValues> item)
    {
        ThrowIfReadOnly();
        if (Store == null)
        {
            return false;
        }
 
        if (Store.TryGetValue(item.Key, out var value) && StringValues.Equals(item.Value, value))
        {
            return Store.Remove(item.Key);
        }
        return false;
    }
 
    /// <summary>
    /// Removes the given header from the collection.
    /// </summary>
    /// <param name="key">The header name.</param>
    /// <returns>true if the specified object was removed from the collection; otherwise, false.</returns>
    public bool Remove(string key)
    {
        ThrowIfReadOnly();
        if (Store == null)
        {
            return false;
        }
        return Store.Remove(key);
    }
 
    /// <summary>
    /// Retrieves a value from the dictionary.
    /// </summary>
    /// <param name="key">The header name.</param>
    /// <param name="value">The value.</param>
    /// <returns>true if the <see cref="HeaderDictionary" /> contains the key; otherwise, false.</returns>
    public bool TryGetValue(string key, out StringValues value)
    {
        if (Store == null)
        {
            value = default(StringValues);
            return false;
        }
        return Store.TryGetValue(key, out value);
    }
 
    /// <summary>
    /// Returns an enumerator that iterates through a collection.
    /// </summary>
    /// <returns>An <see cref="Enumerator" /> object that can be used to iterate through the collection.</returns>
    public Enumerator GetEnumerator()
    {
        if (Store == null || Store.Count == 0)
        {
            // Non-boxed Enumerator
            return default;
        }
        return new Enumerator(Store.GetEnumerator());
    }
 
    /// <summary>
    /// Returns an enumerator that iterates through a collection.
    /// </summary>
    /// <returns>An <see cref="IEnumerator" /> object that can be used to iterate through the collection.</returns>
    IEnumerator<KeyValuePair<string, StringValues>> IEnumerable<KeyValuePair<string, StringValues>>.GetEnumerator()
    {
        if (Store == null || Store.Count == 0)
        {
            // Non-boxed Enumerator
            return EmptyIEnumeratorType;
        }
        return Store.GetEnumerator();
    }
 
    /// <summary>
    /// Returns an enumerator that iterates through a collection.
    /// </summary>
    /// <returns>An <see cref="IEnumerator" /> object that can be used to iterate through the collection.</returns>
    IEnumerator IEnumerable.GetEnumerator()
    {
        if (Store == null || Store.Count == 0)
        {
            // Non-boxed Enumerator
            return EmptyIEnumerator;
        }
        return Store.GetEnumerator();
    }
 
    private void ThrowIfReadOnly()
    {
        if (IsReadOnly)
        {
            throw new InvalidOperationException("The response headers cannot be modified because the response has already started.");
        }
    }
 
    [DoesNotReturn]
    private static void ThrowKeyNotFoundException()
    {
        throw new KeyNotFoundException();
    }
 
    internal string DebuggerToString()
    {
        var debugText = $"Count = {Count}";
        if (IsReadOnly)
        {
            debugText += ", IsReadOnly = true";
        }
        return debugText;
    }
 
    /// <summary>
    /// Enumerates a <see cref="HeaderDictionary"/>.
    /// </summary>
    public struct Enumerator : IEnumerator<KeyValuePair<string, StringValues>>
    {
        // Do NOT make this readonly, or MoveNext will not work
        private Dictionary<string, StringValues>.Enumerator _dictionaryEnumerator;
        private readonly bool _notEmpty;
 
        internal Enumerator(Dictionary<string, StringValues>.Enumerator dictionaryEnumerator)
        {
            _dictionaryEnumerator = dictionaryEnumerator;
            _notEmpty = true;
        }
 
        /// <summary>
        /// Advances the enumerator to the next element of the <see cref="HeaderDictionary"/>.
        /// </summary>
        /// <returns><see langword="true"/> if the enumerator was successfully advanced to the next element;
        /// <see langword="false"/> if the enumerator has passed the end of the collection.</returns>
        public bool MoveNext()
        {
            if (_notEmpty)
            {
                return _dictionaryEnumerator.MoveNext();
            }
            return false;
        }
 
        /// <summary>
        /// Gets the element at the current position of the enumerator.
        /// </summary>
        public KeyValuePair<string, StringValues> Current
        {
            get
            {
                if (_notEmpty)
                {
                    return _dictionaryEnumerator.Current;
                }
                return default(KeyValuePair<string, StringValues>);
            }
        }
 
        /// <inheritdoc />
        public void Dispose()
        {
        }
 
        object IEnumerator.Current
        {
            get
            {
                return Current;
            }
        }
 
        void IEnumerator.Reset()
        {
            if (_notEmpty)
            {
                ((IEnumerator)_dictionaryEnumerator).Reset();
            }
        }
    }
}