#region Apache License 2.0
/*
Nuclex .NET Framework
Copyright (C) 2002-2024 Markus Ewald / Nuclex Development Labs

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#endregion // Apache License 2.0

using System;
using System.Collections.Generic;

using NUnit.Framework;

namespace Nuclex.Support.Collections {

  /// <summary>Unit tests for the multi dictionary</summary>
  [TestFixture]
  internal class MultiDictionaryTest {

    /// <summary>
    ///   Verifies that new instances of the multi dictionary can be created
    /// </summary>
    [Test]
    public void CanConstructNewDictionary() {
      var dictionary = new MultiDictionary<int, string>();
      Assert.IsNotNull(dictionary); // nonsense, prevents compiler warning
    }

    /// <summary>
    ///   Verifies that the count is initialized correctly when building
    ///   a multi dictionary from a dictionary of value collections.
    /// </summary>
    [Test]
    public void CountIsCalculatedIfInitializedFromDictionary() {
      var contents = new Dictionary<int, ICollection<string>>();
      contents.Add(1, new List<string>(new string[] { "one", "eins" }));
      contents.Add(2, new List<string>(new string[] { "two", "zwei" }));

      var multiDictionary = new MultiDictionary<int, string>(contents);
      Assert.AreEqual(4, multiDictionary.Count);
    }

    /// <summary>
    ///   Verifies that a new multi dictionary based on a read-only dictionary is
    ///   also read-only
    /// </summary>
    [Test]
    public void IsReadOnlyWhenBasedOnReadOnlyContainer() {
      var readOnly = new ReadOnlyDictionary<int, ICollection<string>>(
        new Dictionary<int, ICollection<string>>()
      );
      var dictionary = new MultiDictionary<int, string>(readOnly);

      Assert.IsTrue(dictionary.IsReadOnly);
    }

    /// <summary>
    ///   Ensures that the multi dictionary can contain the same key multiple times
    ///   (or in other words, multiple values on the same key)
    /// </summary>
    [Test]
    public void CanContainKeyMultipleTimes() {
      var dictionary = new MultiDictionary<int, string>();
      dictionary.Add(123, "one two three");
      dictionary.Add(123, "eins zwei drei");

      Assert.AreEqual(2, dictionary.Count);

      CollectionAssert.AreEquivalent(
        new KeyValuePair<int, string>[] {
          new KeyValuePair<int, string>(123, "one two three"),
          new KeyValuePair<int, string>(123, "eins zwei drei")
        },
        dictionary
      );
    }

    /// <summary>
    ///   Verifies that adding values through the indexer still updates the item count
    /// </summary>
    [Test]
    public void AddingValuesFromIndexerUpdatesCount() {
      var dictionary = new MultiDictionary<int, string>();
      dictionary.Add(42, "the answer to everything");
      dictionary[42].Add("21x2");

      Assert.AreEqual(2, dictionary.Count);

      CollectionAssert.AreEquivalent(
        new KeyValuePair<int, string>[] {
          new KeyValuePair<int, string>(42, "the answer to everything"),
          new KeyValuePair<int, string>(42, "21x2")
        },
        dictionary
      );
    }

    /// <summary>
    ///   Tests whether the collection can count the number of values stored
    ///   under a key
    /// </summary>
    [Test]
    public void ValuesWithSameKeyCanBeCounted() {
      var dictionary = new MultiDictionary<int, string>();
      dictionary.Add(10, "ten");
      dictionary.Add(20, "twenty");
      dictionary.Add(30, "thirty");
      dictionary.Add(10, "zehn");
      dictionary.Add(20, "zwanzig");
      dictionary.Add(10, "dix");

      Assert.AreEqual(6, dictionary.Count);
      Assert.AreEqual(3, dictionary.CountValues(10));
      Assert.AreEqual(2, dictionary.CountValues(20));
      Assert.AreEqual(1, dictionary.CountValues(30));
    }

    /// <summary>
    ///   Verifies that counting the values of a non-existing key returns 0
    /// </summary>
    [Test]
    public void CountingValuesOfNonExistentKeyReturnsNull() {
      var dictionary = new MultiDictionary<int, string>();
      Assert.AreEqual(0, dictionary.CountValues(1));
    }

    /// <summary>
    ///   Ensures that its possible to remove values individually without affecting
    ///   other values stored under the same key
    /// </summary>
    [Test]
    public void ValuesCanBeRemovedIndividually() {
      var dictionary = new MultiDictionary<int, string>();
      dictionary.Add(10, "ten");
      dictionary.Add(10, "zehn");
      dictionary.Add(10, "dix");

      dictionary.Remove(10, "zehn");

      Assert.AreEqual(2, dictionary.Count);
      CollectionAssert.AreEquivalent(
        new KeyValuePair<int, string>[] {
          new KeyValuePair<int, string>(10, "ten"),
          new KeyValuePair<int, string>(10, "dix")
        },
        dictionary
      );
    }

    /// <summary>
    ///   Verifies that the Count property returns the number of unique keys if it is called
    ///   on the collection-of-collections interface implemented by the multi dictionary
    /// </summary>
    [Test]
    public void CollectionOfCollectionCountIsUniqueKeyCount() {
      var dictionary = new MultiDictionary<int, string>();
      dictionary.Add(10, "ten");
      dictionary.Add(10, "zehn");

      Assert.AreEqual(2, dictionary.Count);
      var collectionOfCollections =
        (ICollection<KeyValuePair<int, ICollection<string>>>)dictionary;
      Assert.AreEqual(1, collectionOfCollections.Count);
    }

    /// <summary>
    ///   Verifies that the multi dictionary can be tested for containment of a specific value
    /// </summary>
    [Test]
    public void ContainmentCanBeTested() {
      var dictionary = new MultiDictionary<int, string>();
      dictionary.Add(10, "ten");
      dictionary.Add(10, "zehn");

      Assert.IsTrue(dictionary.Contains(new KeyValuePair<int, string>(10, "ten")));
      Assert.IsTrue(dictionary.Contains(new KeyValuePair<int, string>(10, "zehn")));
      Assert.IsFalse(dictionary.Contains(new KeyValuePair<int, string>(10, "dix")));
      Assert.IsFalse(dictionary.Contains(new KeyValuePair<int, string>(20, "ten")));
    }

    /// <summary>
    ///   Verifies that the multi dictionary can be tested for containment of a specific key
    /// </summary>
    [Test]
    public void KeyContainmentCanBeTested() {
      var dictionary = new MultiDictionary<int, string>();
      dictionary.Add(10, "ten");
      dictionary.Add(10, "zehn");

      Assert.IsTrue(dictionary.ContainsKey(10));
      Assert.IsFalse(dictionary.ContainsKey(20));
    }

    /// <summary>
    ///   Verifies that the key collection can be retrieved from the dictionary
    /// </summary>
    [Test]
    public void KeyCollectionCanBeRetrieved() {
      var dictionary = new MultiDictionary<int, string>();
      dictionary.Add(10, "ten");
      dictionary.Add(10, "zehn");

      ICollection<int> keys = dictionary.Keys;
      Assert.IsNotNull(keys);
      Assert.AreEqual(1, keys.Count);
    }

    /// <summary>
    ///   Verifies that the key collection can be retrieved from the dictionary
    /// </summary>
    [Test]
    public void ValueCollectionCanBeRetrieved() {
      var dictionary = new MultiDictionary<int, string>();
      dictionary.Add(10, "ten");
      dictionary.Add(10, "zehn");
      dictionary.Add(20, "twenty");

      ICollection<string> values = dictionary.Values;
      Assert.IsNotNull(values);
      Assert.AreEqual(3, values.Count);
    }

    /// <summary>
    ///   Verifies that TryGetValue() returns false and doesn't throw if a key
    ///   is not found in the collection
    /// </summary>
    [Test]
    public void TryGetValueReturnsFalseOnMissingKey() {
      var dictionary = new MultiDictionary<int, string>();
      ICollection<string> values;
      Assert.IsFalse(dictionary.TryGetValue(123, out values));
    }

    /// <summary>Verifies that keys can be looked up via TryGetValue()</summary>
    [Test]
    public void TryGetValueCanLookUpValues() {
      var dictionary = new MultiDictionary<int, string>();
      dictionary.Add(10, "ten");
      dictionary.Add(10, "zehn");
      ICollection<string> values;
      Assert.IsTrue(dictionary.TryGetValue(10, out values));
      Assert.AreEqual(2, values.Count);
    }

    /// <summary>
    ///   Verifies that assigning null to a key deletes all the values stored
    ///   under it
    /// </summary>
    [Test]
    public void AssigningNullToKeyRemovesAllValues() {
      var dictionary = new MultiDictionary<int, string>();
      dictionary.Add(10, "ten");
      dictionary.Add(10, "zehn");
      dictionary.Add(20, "twenty");

      Assert.AreEqual(3, dictionary.Count);
      dictionary[10] = null;
      Assert.AreEqual(1, dictionary.Count);
      Assert.IsFalse(dictionary.ContainsKey(10));
    }

    /// <summary>
    ///   Verifies that assigning null to a key deletes all the values stored
    ///   under it
    /// </summary>
    [Test]
    public void ValueListCanBeAssignedToNewKey() {
      var dictionary = new MultiDictionary<int, string>();
      dictionary[3] = new List<string>() { "three", "drei" };

      Assert.AreEqual(2, dictionary.Count);
      Assert.IsTrue(dictionary.Contains(new KeyValuePair<int, string>(3, "three")));
    }

    /// <summary>
    ///   Verifies that assigning null to a key deletes all the values stored
    ///   under it
    /// </summary>
    [Test]
    public void ValueListCanOverwriteExistingKey() {
      var dictionary = new MultiDictionary<int, string>();
      dictionary.Add(10, "dix");

      Assert.AreEqual(1, dictionary.Count);

      dictionary[10] = new List<string>() { "ten", "zehn" };

      Assert.AreEqual(2, dictionary.Count);
      Assert.IsFalse(dictionary.Contains(new KeyValuePair<int, string>(10, "dix")));
      Assert.IsTrue(dictionary.Contains(new KeyValuePair<int, string>(10, "ten")));
    }

    /// <summary>
    ///   Verifies that nothing bad happens when a key is removed from the dictionary
    ///   that it doesn't contain
    /// </summary>
    [Test]
    public void NonExistingKeyCanBeRemoved() {
      var dictionary = new MultiDictionary<int, string>();
      Assert.AreEqual(0, dictionary.RemoveKey(123));
    }

    /// <summary>
    ///   Verifies that the remove method returns the number of values that have
    ///   been removed from the dictionary
    /// </summary>
    [Test]
    public void RemoveReturnsNumberOfValuesRemoved() {
      var dictionary = new MultiDictionary<int, string>();
      dictionary.Add(10, "ten");
      dictionary.Add(10, "zehn");
      Assert.AreEqual(2, dictionary.RemoveKey(10));
    }

    /// <summary>
    ///   Verifies that the dictionary becomes empty after clearing it
    /// </summary>
    [Test]
    public void DictionaryIsEmptyAfterClear() {
      var dictionary = new MultiDictionary<int, string>();
      dictionary.Add(10, "ten");
      dictionary.Add(10, "zehn");
      dictionary.Add(20, "twenty");
      Assert.AreEqual(3, dictionary.Count);
      dictionary.Clear();
      Assert.AreEqual(0, dictionary.Count);
    }

    /// <summary>
    ///   Verifies that non-existing values can be removed from the dictionary
    /// </summary>
    [Test]
    public void NonExistingValueCanBeRemoved() {
      var dictionary = new MultiDictionary<int, string>();
      Assert.IsFalse(dictionary.Remove(123, "test"));
    }

    /// <summary>
    ///   Verifies that nothing bad happens when the last value under a key is removed
    /// </summary>
    [Test]
    public void LastValueOfKeyCanBeRemoved() {
      var dictionary = new MultiDictionary<int, string>();
      dictionary.Add(123, "test");
      dictionary.Remove(123, "test");
      Assert.AreEqual(0, dictionary.CountValues(123));
    }

    /// <summary>
    ///   Verifies that the dictionary can be copied into an array
    /// </summary>
    [Test]
    public void DictionaryCanBeCopiedIntoArray() {
      var expected = new List<KeyValuePair<int, string>>() {
        new KeyValuePair<int, string>(1, "one"),
        new KeyValuePair<int, string>(1, "eins"),
        new KeyValuePair<int, string>(2, "two"),
        new KeyValuePair<int, string>(2, "zwei")
      };

      var dictionary = new MultiDictionary<int, string>();
      foreach(KeyValuePair<int, string> entry in expected) {
        dictionary.Add(entry.Key, entry.Value);
      }

      var actual = new KeyValuePair<int, string>[4];
      dictionary.CopyTo(actual, 0);

      CollectionAssert.AreEquivalent(expected, actual);
    }

  }

} // namespace Nuclex.Support.Collections