using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;

namespace Swan.Collections {
  /// <summary>
  /// Represents a non-thread-safe collection of key/value pairs that does not store null values.
  /// </summary>
  /// <typeparam name="TKey">The type of keys in the dictionary. This must be a reference type.</typeparam>
  /// <typeparam name="TValue">The type of values in the dictionary. This must be a reference type.</typeparam>
  /// <seealso cref="IDataDictionary{TKey,TValue}"/>
  public sealed class DataDictionary<TKey, TValue> : IDataDictionary<TKey, TValue>
      where TKey : class
      where TValue : class {
    #region Private data

    private readonly Dictionary<TKey, TValue> _dictionary;

    #endregion

    #region Instance management

    /// <summary>
    /// Initializes a new instance of the <see cref="DataDictionary{TKey,TValue}"/> class
    /// that is empty, has the default initial capacity,
    /// and uses the default comparer for <typeparamref name="TKey"/>.
    /// </summary>
    /// <see cref="Dictionary{TKey,TValue}()"/>
    public DataDictionary() => this._dictionary = new Dictionary<TKey, TValue>();

    /// <summary>
    /// Initializes a new instance of the <see cref="DataDictionary{TKey,TValue}"/> class
    /// that contains elements copied from the specified <see cref="IEnumerable{T}"/>,
    /// has the default initial capacity, and uses the default comparer for <typeparamref name="TKey"/>.
    /// </summary>
    /// <param name="collection">The <see cref="IEnumerable{T}"/> whose elements are copied
    /// to the new <see cref="DataDictionary{TKey,TValue}"/>.</param>
    /// <exception cref="ArgumentNullException"><paramref name="collection"/> is <see langword="null"/>.</exception>
    /// <remarks>
    /// <para>Since <see cref="DataDictionary{TKey,TValue}"/> does not store null values,
    /// key/value pairs whose value is <see langword="null"/> will not be copied from <paramref name="collection"/>.</para>
    /// </remarks>
    /// <see cref="Dictionary{TKey,TValue}()"/>
    public DataDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection) {
      if(collection == null) {
        throw new ArgumentNullException(nameof(collection));
      }

      this._dictionary = new Dictionary<TKey, TValue>();
      foreach(KeyValuePair<TKey, TValue> pair in collection.Where(pair => pair.Value != null)) {
        this._dictionary.Add(pair.Key, pair.Value);
      }
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="DataDictionary{TKey,TValue}"/> class
    /// that is empty, has the default capacity, and uses the specified <see cref="IEqualityComparer{T}"/>.
    /// </summary>
    /// <param name="comparer">The equality comparison implementation to use when comparing keys.</param>
    /// <exception cref="ArgumentNullException"><paramref name="comparer"/> is <see langword="null"/>.</exception>
    /// <see cref="Dictionary{TKey,TValue}(IEqualityComparer{TKey})"/>
    public DataDictionary(IEqualityComparer<TKey> comparer) => this._dictionary = new Dictionary<TKey, TValue>(comparer);

    /// <summary>
    /// Initializes a new instance of the <see cref="DataDictionary{TKey, TValue}"/> class
    /// that contains elements copied from the specified <see cref="IEnumerable{T}"/>,
    /// has the default initial capacity, and uses the specified <see cref="IEqualityComparer{T}"/>.
    /// </summary>
    /// <param name="collection">The <see cref="IEnumerable{T}"/> whose elements are copied
    /// to the new <see cref="DataDictionary{TKey,TValue}"/>.</param>
    /// <param name="comparer">The equality comparison implementation to use when comparing keys.</param>
    /// <remarks>
    /// <para>Since <see cref="DataDictionary{TKey,TValue}"/> does not store null values,
    /// key/value pairs whose value is <see langword="null"/> will not be copied from <paramref name="collection"/>.</para>
    /// </remarks>
    /// <exception cref="ArgumentNullException">
    /// <para><paramref name="collection"/> is <see langword="null"/>.</para>
    /// <para>- or -.</para>
    /// <para><paramref name="comparer"/> is <see langword="null"/>.</para>
    /// </exception>
    /// <see cref="Dictionary{TKey,TValue}(IEqualityComparer{TKey})"/>
    public DataDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey> comparer) {
      if(collection == null) {
        throw new ArgumentNullException(nameof(collection));
      }

      this._dictionary = new Dictionary<TKey, TValue>(comparer);
      foreach(KeyValuePair<TKey, TValue> pair in collection.Where(pair => pair.Value != null)) {
        this._dictionary.Add(pair.Key, pair.Value);
      }
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="DataDictionary{TKey, TValue}"/> class
    /// that is empty, has the specified capacity, and uses the default comparer for the key type.
    /// </summary>
    /// <param name="capacity">The initial number of elements that the <see cref="DataDictionary{TKey, TValue}"/> can contain.</param>
    /// <exception cref="ArgumentOutOfRangeException"><paramref name="capacity"/> is less than 0.</exception>
    /// <see cref="Dictionary{TKey,TValue}(Int32)"/>
    public DataDictionary(Int32 capacity) => this._dictionary = new Dictionary<TKey, TValue>(capacity);

    /// <summary>
    /// Initializes a new instance of the <see cref="DataDictionary{TKey, TValue}"/> class
    /// that contains elements copied from the specified <see cref="IEnumerable{T}"/>, 
    /// has the specified capacity, and uses the specified <see cref="IEqualityComparer{T}"/>.
    /// </summary>
    /// <param name="capacity">The initial number of elements that the <see cref="DataDictionary{TKey, TValue}"/> can contain.</param>
    /// <param name="collection">The <see cref="IEnumerable{T}"/> whose elements are copied
    /// to the new <see cref="ConcurrentDataDictionary{TKey,TValue}"/>.</param>
    /// <param name="comparer">The equality comparison implementation to use when comparing keys.</param>
    /// <remarks>
    /// <para>Since <see cref="ConcurrentDataDictionary{TKey,TValue}"/> does not store null values,
    /// key/value pairs whose value is <see langword="null"/> will not be copied from <paramref name="collection"/>.</para>
    /// </remarks>
    /// <exception cref="ArgumentNullException">
    /// <para><paramref name="collection"/> is <see langword="null"/>.</para>
    /// <para>- or -.</para>
    /// <para><paramref name="comparer"/> is <see langword="null"/>.</para>
    /// </exception>
    /// <exception cref="ArgumentOutOfRangeException"><paramref name="capacity"/> is less than 0.</exception>
    /// <see cref="Dictionary{TKey,TValue}(Int32,IEqualityComparer{TKey})"/>
    public DataDictionary(Int32 capacity, IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey> comparer) {
      if(collection == null) {
        throw new ArgumentNullException(nameof(collection));
      }

      this._dictionary = new Dictionary<TKey, TValue>(capacity, comparer);
      foreach(KeyValuePair<TKey, TValue> pair in collection.Where(pair => pair.Value != null)) {
        this._dictionary.Add(pair.Key, pair.Value);
      }
    }

    #endregion

    #region Public APIs

    /// <inheritdoc cref="IDataDictionary{TKey,TValue}.Count"/>
    public Int32 Count => this._dictionary.Count;

    /// <inheritdoc cref="IDataDictionary{TKey,TValue}.IsEmpty"/>
    public Boolean IsEmpty => this._dictionary.Count == 0;

    /// <inheritdoc cref="IDictionary{TKey,TValue}.Keys"/>
    public ICollection<TKey> Keys => this._dictionary.Keys;

    /// <inheritdoc cref="IDictionary{TKey,TValue}.Values"/>
    public ICollection<TValue> Values => this._dictionary.Values;

    /// <inheritdoc cref="IDataDictionary{TKey,TValue}.this"/>
    public TValue this[TKey key] {
      get => this._dictionary.TryGetValue(key ?? throw new ArgumentNullException(nameof(key)), out TValue value) ? value : null;
      set {
        if(value != null) {
          this._dictionary[key] = value;
        } else {
          _ = this._dictionary.Remove(key);
        }
      }
    }

    /// <inheritdoc cref="IDataDictionary{TKey,TValue}.Clear"/>
    public void Clear() => this._dictionary.Clear();

    /// <inheritdoc cref="IDataDictionary{TKey,TValue}.ContainsKey"/>
    public Boolean ContainsKey(TKey key) =>
      // _dictionary.ContainsKey will take care of throwing on a null key.
      this._dictionary.ContainsKey(key);

    /// <inheritdoc cref="ConcurrentDictionary{TKey,TValue}.GetOrAdd(TKey,TValue)"/>
    public TValue GetOrAdd(TKey key, TValue value) {
      // _dictionary.TryGetValue will take care of throwing on a null key.
      if(this._dictionary.TryGetValue(key, out TValue result)) {
        return result;
      }

      if(value == null) {
        return null;
      }

      this._dictionary.Add(key, value);
      return value;
    }

    /// <inheritdoc cref="IDictionary{TKey,TValue}.Remove(TKey)"/>
    public Boolean Remove(TKey key) =>
      // _dictionary.Remove will take care of throwing on a null key.
      this._dictionary.Remove(key);

    /// <inheritdoc cref="ConcurrentDictionary{TKey,TValue}.TryAdd"/>
    public Boolean TryAdd(TKey key, TValue value) {
      // _dictionary.ContainsKey will take care of throwing on a null key.
      if(this._dictionary.ContainsKey(key)) {
        return false;
      }

      if(value != null) {
        this._dictionary.Add(key, value);
      }

      return true;
    }

    /// <inheritdoc cref="IDataDictionary{TKey,TValue}.TryGetValue"/>
    public Boolean TryGetValue(TKey key, out TValue value) => this._dictionary.TryGetValue(key, out value);

    /// <inheritdoc cref="IDataDictionary{TKey,TValue}.TryRemove"/>
    public Boolean TryRemove(TKey key, out TValue value) {
      // TryGetValue will take care of throwing on a null key.
      if(!this._dictionary.TryGetValue(key, out value)) {
        return false;
      }

      _ = this._dictionary.Remove(key);
      return true;
    }

    /// <inheritdoc cref="ConcurrentDictionary{TKey,TValue}.TryUpdate"/>
    public Boolean TryUpdate(TKey key, TValue newValue, TValue comparisonValue) {
      // TryGetValue will take care of throwing on a null key.
      if(!this._dictionary.TryGetValue(key, out TValue value)) {
        return false;
      }

      if(value != comparisonValue) {
        return false;
      }

      this._dictionary[key] = newValue;
      return true;
    }

    #endregion

    #region Implementation of IDictionary<TKey, TValue>

    /// <inheritdoc cref="IDictionary{TKey,TValue}.Add(TKey,TValue)"/>
    void IDictionary<TKey, TValue>.Add(TKey key, TValue value) {
      // Validating the key seems redundant, because both Add and Remove
      // will throw on a null key.
      // This way, though, the code path on null key does not depend on value.
      // Without this validation, there should be two unit tests for null key,
      // one with a null value and one with a non-null value,
      // which makes no sense.
      if(key == null) {
        throw new ArgumentNullException(nameof(key));
      }

      if(value != null) {
        this._dictionary.Add(key, value);
      } else {
        _ = this._dictionary.Remove(key);
      }
    }

    #endregion

    #region Implementation of IReadOnlyDictionary<TKey, TValue>

    /// <inheritdoc cref="IReadOnlyDictionary{TKey,TValue}.Keys"/>
    IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys => this._dictionary.Keys;

    /// <inheritdoc cref="IReadOnlyDictionary{TKey,TValue}.Values"/>
    IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values => this._dictionary.Values;

    #endregion

    #region Implementation of ICollection<KeyValuePair<TKey, TValue>>

    /// <inheritdoc cref="ICollection{T}.IsReadOnly"/>
    /// <remarks>
    /// <para>This property is always <see langword="false"/> for a <see cref="DataDictionary{TKey,TValue}"/>.</para>
    /// </remarks>
    Boolean ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => false;

    /// <inheritdoc cref="ICollection{T}.Add"/>
    void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item) {
      if(item.Value != null) {
        ((ICollection<KeyValuePair<TKey, TValue>>)this._dictionary).Add(item);
      } else {
        _ = this._dictionary.Remove(item.Key);
      }
    }

    /// <inheritdoc cref="ICollection{T}.Contains"/>
    Boolean ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item) => ((ICollection<KeyValuePair<TKey, TValue>>)this._dictionary).Contains(item);

    /// <inheritdoc cref="ICollection{T}.CopyTo"/>
    void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, Int32 arrayIndex) => ((ICollection<KeyValuePair<TKey, TValue>>)this._dictionary).CopyTo(array, arrayIndex);

    /// <inheritdoc cref="ICollection{T}.Remove"/>
    Boolean ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item) => ((ICollection<KeyValuePair<TKey, TValue>>)this._dictionary).Remove(item);

    #endregion

    #region Implementation of IEnumerable<KeyValuePair<TKey, TValue>>

    /// <inheritdoc cref="IEnumerable{T}.GetEnumerator"/>
    IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator() => this._dictionary.GetEnumerator();

    #endregion

    #region Implementation of IEnumerable

    /// <inheritdoc cref="IEnumerable.GetEnumerator"/>
    IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable)this._dictionary).GetEnumerator();

    #endregion
  }
}