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

namespace Developpez.Dotnet.Tests.Collections
{
    [TestFixture]
    public class DictionaryExtensionsTests
    {
        private Dictionary<string, string> _dictionary;

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

        [Test]
        public void Test_GetValueOrDefault_NoDefault()
        {
            string expected = "test";
            string actual = _dictionary.GetValueOrDefault("test");
            Assert.AreEqual(expected, actual);

            expected = null;
            actual = _dictionary.GetValueOrDefault("toto");
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_GetValueOrDefault_WithDefault()
        {
            string expected = "test";
            string actual = _dictionary.GetValueOrDefault("test", "default");
            Assert.AreEqual(expected, actual);

            expected = "default";
            actual = _dictionary.GetValueOrDefault("toto", "default");
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_GetOrAdd()
        {
            var dict = new Dictionary<string, string>();
            dict.Add("foo", "test");
            int generatedCount = 0;
            Func<string, string> valueFactory = key =>
                                                {
                                                    generatedCount++;
                                                    return "**" + key;
                                                };
            string expected = "test";
            string actual = dict.GetOrAdd("foo", valueFactory);
            Assert.AreEqual(expected, actual);
            Assert.AreEqual(0, generatedCount);

            expected = "**bar";
            actual = dict.GetOrAdd("bar", valueFactory);
            Assert.AreEqual(expected, actual);
            Assert.IsTrue(dict.ContainsKey("bar"));
            Assert.AreEqual(1, generatedCount);

            actual = dict.GetOrAdd("bar", valueFactory);
            Assert.AreEqual(expected, actual);
            Assert.IsTrue(dict.ContainsKey("bar"));
            Assert.AreEqual(1, generatedCount);

        }

        [Test]
        public void Test_GetOrCreate()
        {
            var dict = new Dictionary<string, string>();
            dict.Add("foo", "test");
            int generatedCount = 0;
            Func<string, string> valueFactory = key =>
            {
                generatedCount++;
                return "**" + key;
            };
            string expected = "test";
            string actual = dict.GetOrCreate("foo", valueFactory);
            Assert.AreEqual(expected, actual);
            Assert.AreEqual(0, generatedCount);

            expected = "**bar";
            actual = dict.GetOrCreate("bar", valueFactory);
            Assert.AreEqual(expected, actual);
            Assert.IsFalse(dict.ContainsKey("bar"));
            Assert.AreEqual(1, generatedCount);

            actual = dict.GetOrCreate("bar", valueFactory);
            Assert.AreEqual(expected, actual);
            Assert.IsFalse(dict.ContainsKey("bar"));
            Assert.AreEqual(2, generatedCount);

        }

        [Test]
        public void Test_AsReadOnly()
        {
            var dic = _dictionary.AsReadOnly();
            Assert.IsTrue(dic.IsReadOnly);
        }

        [Test]
        public void Test_AsReadOnly_WithCopy()
        {
            var dic = new Dictionary<string, string>(_dictionary);
            var readOnlyDic = dic.AsReadOnly(false);
            var readOnlyCopy = dic.AsReadOnly(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_ToDictionary()
        {
            var d1 = new Dictionary<string, int>
            {
                { "a", 1 },
                { "b", 2 },
                { "c", 3 }
            };

            var d2 = new Dictionary<string, int>
            {
                { "d", 4 },
                { "e", 5 }
            };

            var expected = new Dictionary<string, int>
            {
                { "a", 1 },
                { "b", 2 },
                { "c", 3 },
                { "d", 4 },
                { "e", 5 }
            };

            var actual = d1.Concat(d2).ToDictionary();

            //    expected.OrderBy(kvp => kvp.Key),
            //    actual.OrderBy(kvp => kvp.Key));
            CollectionAssert.AreEquivalent(expected, actual);
        }
    }
}