using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Developpez.Dotnet.Collections;
using NUnit.Framework;

namespace Developpez.Dotnet.Tests.Collections
{
    [TestFixture(Description = "Tests unitaires pour la classe ReadOnlyDictionary")]
    public class ReadOnlyDictionaryTests
    {

        Dictionary<string, string> _original;
        ReadOnlyDictionary<string, string> _readOnly;

        [SetUp]
        public void Setup()
        {
            _original = new Dictionary<string, string>();
            _original.Add("test", "test");
            _readOnly = new ReadOnlyDictionary<string, string>(_original);
        }

        [Test]
        public void ReadOnlyDictionary_Contains_Should_Return_True_When_Exists()
        {
            Assert.IsTrue(_readOnly.Contains(new KeyValuePair<string, string>("test", "test")));
            Assert.IsFalse(_readOnly.Contains(new KeyValuePair<string, string>("test1", "test")));
        }

        [Test]
        public void ReadOnlyDictionary_ContainsKey_Should_Return_True_When_Key_Exists()
        {
            Assert.IsTrue(_readOnly.ContainsKey("test"));
            Assert.IsFalse(_readOnly.ContainsKey("test1"));
        }

        [Test]
        public void ReadOnlyDictionary_Item_Should_Return_Value_When_Key_Exists()
        {
            Assert.AreEqual("test", _readOnly["test"]);
        }

        [Test]
        public void ReadOnlyDictionary_Item_Should_Throw_KeyNotFoundException_When_Unexisting_Key()
        {
            string s = null;
            Assert.Throws<KeyNotFoundException>(
                () => s = _readOnly["test1"]);
        }

        [Test]
        public void ReadOnlyDictionary_Count()
        {
            Assert.AreEqual(1, _readOnly.Count);
        }

        [Test]
        public void ReadOnlyDictionary_Keys()
        {
            Assert.AreEqual("test", _readOnly.Keys.ToArray<string>()[0]);
        }

        [Test]
        public void ReadOnlyDictionary_Values()
        {
            Assert.AreEqual("test", _readOnly.Values.ToArray<string>()[0]);
        }

        [Test]
        public void ReadOnlyDictionary_CopyTo()
        {
            KeyValuePair<string, string>[] array = {new KeyValuePair<string,string>()};
            _readOnly.CopyTo(array, 0);

            Assert.AreEqual(1, array.Length);
            Assert.AreEqual("test", array[0].Key);
            Assert.AreEqual("test", array[0].Value);

            KeyValuePair<string, string>[] array2 = { };
            new ReadOnlyDictionary<string, string>().CopyTo(array2, 0);
            Assert.AreEqual(0, array2.Length);
        }

        [Test]
        public void ReadOnlyDictionary_TryGetValue()
        {
            string result;
            bool found = _readOnly.TryGetValue("test", out result);

            Assert.AreEqual("test", result);
            Assert.IsTrue(found);
            
            found = _readOnly.TryGetValue("test1", out result);

            Assert.AreEqual(null, result);
            Assert.IsFalse(found);
        }

        [Test]
        public void ReadOnlyDictionary_IsReadOnly()
        {
            _readOnly = new ReadOnlyDictionary<string, string>();
            Assert.IsTrue(_readOnly.IsReadOnly);
        }

        [Test]
        public void ReadOnlyDictionary_ForEach()
        {
            _original.Add("test2", "test2");

            string expected = ",test,test,test2,test2";
            string actual = string.Empty;

            _readOnly = new ReadOnlyDictionary<string, string>(_original);
            foreach (var item in _readOnly)
            {
                actual += "," + item.Value + "," + item.Key;
            }

            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void ReadOnlyDictionary_Should_Throw_On_Add()
        {
            Assert.Throws<NotSupportedException>(
                () => _readOnly.Add("titi", "toto"));
        }

        [Test]
        public void ReadOnlyDictionary_Should_Throw_On_Add_VeyValuePair()
        {
            Assert.Throws<NotSupportedException>(
                () => _readOnly.Add(new KeyValuePair<string, string>("titi", "toto")));
        }

        [Test]
        public void ReadOnlyDictionary_Should_Throw_On_SetIndexer()
        {
            Assert.Throws<NotSupportedException>(
                () => _readOnly["titi"] = "toto");
        }

        [Test]
        public void ReadOnlyDictionary_Should_Throw_On_Remove()
        {
            Assert.Throws<NotSupportedException>(
                () => _readOnly.Remove("test"));
        }

        [Test]
        public void ReadOnlyDictionary_Should_Throw_On_Remove_KeyValuePair()
        {
            Assert.Throws<NotSupportedException>(
                () => _readOnly.Remove(new KeyValuePair<string, string>("test", "test")));
        }

        [Test]
        public void ReadOnlyDictionary_Should_Throw_On_Clear()
        {
            Assert.Throws<NotSupportedException>(
                () => _readOnly.Clear());
        }

        [Test]
        public void ReadOnlyDictionary_WithCopy()
        {
            var dic = new Dictionary<string, string>(_original);
            var readOnlyDic = new ReadOnlyDictionary<string, string>(dic, false);
            var readOnlyCopy = new ReadOnlyDictionary<string, string>(dic, true);

            dic.Remove("test");
            dic.Add("foo", "bar");
            Assert.IsFalse(readOnlyDic.ContainsKey("test"));
            Assert.IsTrue(readOnlyDic.ContainsKey("foo"));
            Assert.IsTrue(readOnlyCopy.ContainsKey("test"));
            Assert.IsFalse(readOnlyCopy.ContainsKey("foo"));
        }

        [Test]
        public void Test_FromNonGenericDictionary()
        {
            var hashtable = new Hashtable();
            hashtable.Add("foo", 42);
            var readOnlyDic = ReadOnlyDictionary<string, int>.FromNonGenericDictionary(hashtable);
            Assert.IsTrue(readOnlyDic.IsReadOnly);
            Assert.IsTrue(readOnlyDic.ContainsKey("foo"));

            hashtable.Add(911, "bar");
            Assert.Throws<InvalidCastException>(
                () => readOnlyDic = ReadOnlyDictionary<string, int>.FromNonGenericDictionary(hashtable));
        }
    }
}