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

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()
        {
            bool wasRaised = false;
            try
            {
                Assert.AreNotEqual("test", readOnly["test1"]);
            }
            catch (KeyNotFoundException)
            {
                wasRaised = true;
            }

            Assert.IsTrue(wasRaised);
        }

        [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()
        {
            bool wasRaised = false;
            try
            {
                readOnly.Add("titi", "toto");
            }
            catch (InvalidOperationException)
            {
                wasRaised = true;
            }
            Assert.IsTrue(wasRaised);
        }

        [Test]
        public void ReadOnlyDictionary_Should_Throw_On_Add_VeyValuePair()
        {
            bool wasRaised = false;
            try
            {
                readOnly.Add(new KeyValuePair<string, string>("titi", "toto"));
            }
            catch (InvalidOperationException)
            {
                wasRaised = true;
            }
            Assert.IsTrue(wasRaised);
        }

        [Test]
        public void ReadOnlyDictionary_Should_Throw_On_SetIndexer()
        {
            bool wasRaised = false;
            try
            {
                readOnly["titi"] = "toto";
            }
            catch (InvalidOperationException)
            {
                wasRaised = true;
            }
            Assert.IsTrue(wasRaised);
        }

        [Test]
        public void ReadOnlyDictionary_Should_Throw_On_Remove()
        {
            bool wasRaised = false;
            try
            {
                readOnly.Remove("test");
            }
            catch (InvalidOperationException)
            {
                wasRaised = true;
            }
            Assert.IsTrue(wasRaised);
        }

        [Test]
        public void ReadOnlyDictionary_Should_Throw_On_Remove_VeyValuePair()
        {
            bool wasRaised = false;
            try
            {
                readOnly.Remove(new KeyValuePair<string, string>("test", "test"));
            }
            catch (InvalidOperationException)
            {
                wasRaised = true;
            }
            Assert.IsTrue(wasRaised);
        }

        [Test]
        public void ReadOnlyDictionary_Should_Throw_On_Clear()
        {
            bool wasRaised = false;
            try
            {
                readOnly.Clear();
            }
            catch (InvalidOperationException)
            {
                wasRaised = true;
            }
            Assert.IsTrue(wasRaised);
        }

        [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"));
        }
    }
}