using System;

using System.Collections;

using System.Collections.Generic;

using NUnit.Framework;

​

public class Program

{

    public static void Main()

    {

        var tests = new MultiMapTests();

        tests.WhenKeyExist_CanAddMultipleValues();

        tests.WhenUnion_ShouldHaveBothKeysAndValues();

        Console.WriteLine("It seems success");

        Console.WriteLine();

    }

}

    [TestFixture]

    public class MultiMapTests{

        [Test]

        public void WhenKeyExist_CanAddMultipleValues(){

            var mp = new MultiMap<int, string>();

            mp.Add(1, "Test");

            mp.Add(1, "Test2");

            Assert.That(mp.ContainsKey(1), Is.True);

            Assert.That(mp[1].Contains("Test2"), Is.True);

            Assert.That(mp[1].Contains("Test"), Is.True);

        }

        [Test]

        public void WhenUnion_ShouldHaveBothKeysAndValues(){

            var mp = new MultiMap<int, string>(){

            {1, "a"},

            {1, "b"},

            {2, "d"}

            };

            var mp2 = new MultiMap<int, string>(){

            {1, "a"},

            {1, "c"},

            {2, "3"},

            {3, "a"}

            };

            var mp3 = mp.Union(mp2);

            Assert.That(mp3.ContainsKey(1), Is.True);

            Assert.That(mp3.ContainsKey(2), Is.True);

            Assert.That(mp3.ContainsKey(3), Is.True);

            Assert.That(mp3[3].Contains("a"), Is.True);

        }

    }

    public class MultiMap<TKey, TValue> : IEnumerable<KeyValuePair<TKey, HashSet<TValue>>> where TKey : struct{

        private readonly Dictionary<TKey, HashSet<TValue>> _dic = new  Dictionary<TKey, HashSet<TValue>>();

        public HashSet<TValue> this[TKey key]{

            get{

                if(_dic.ContainsKey(key)){

                    return _dic[key];

                }

                return new HashSet<TValue>();

            }

            set{

                this.Add(key, value);

            }

        }

        public void Add(TKey key, TValue val){

            if(!_dic.ContainsKey(key)){

                _dic.Add(key, new HashSet<TValue>());

            }

            _dic[key].Add(val);

        }

        public void Add(TKey key, HashSet<TValue> val){

            if(!_dic.ContainsKey(key)){

                _dic.Add(key, val);

            } else{

                _dic[key].UnionWith(val);

            }

        }

        public bool Remove(TKey key, TValue val){

            if(_dic.TryGetValue(key, out var hashSet)){

                return hashSet.Remove(val);

            }

            return false;

        }

        IEnumerator IEnumerable.GetEnumerator(){

            return this.GetEnumerator();

        }

        public bool ContainsKey(TKey key){

            return _dic.ContainsKey(key);

        }

        public IEnumerator<KeyValuePair<TKey, HashSet<TValue>>> GetEnumerator(){

            foreach(var kvp in _dic){

                yield return kvp;

            }

        }

    }

​

    public static class MultiMapExtensions{

        public static MultiMap<TKey, TValue> Union<TKey, TValue>(this MultiMap<TKey, TValue> first, MultiMap<TKey, TValue> second)

        where TKey : struct

        {

​

        var result = new MultiMap<TKey, TValue>();

​

        foreach (var kvp in first)

        {

            result.Add(kvp.Key, kvp.Value);

        }

​

        foreach (var kvp in second)

        {

            result.Add(kvp.Key, kvp.Value);

        }

​

        return result;

        }

        public static MultiMap<TKey, TValue> Except<TKey, TValue>(this MultiMap<TKey, TValue> first, MultiMap<TKey, TValue> second)

        where TKey : struct

        {

            var result = new MultiMap<TKey, TValue>();

            foreach(var kvp in first){

                if(!second.ContainsKey(kvp.Key)){

                    result.Add(kvp.Key, kvp.Value);

                }

            }

            return result;

        }

    }

​

​