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

namespace Developpez.Dotnet.Tests
{
    [TestFixture(Description = "Tests unitaires pour la classe CoreExtensions")]
    public class CoreExtensionsTests
    {
        [Test(Description = "Vérifie le bon fonctionnement de la méthode Default")]
        public void Test_Default()
        {
            string defaultString = "foo";
            string nullString = null;
            string notNullString = "bar";

            string s1 = nullString.Default(defaultString);
            Assert.AreEqual(s1, defaultString);
            string s2 = notNullString.Default(defaultString);
            Assert.AreEqual(s2, notNullString);

        }

        [Test(Description = "Vérifie le bon fonctionnement de la méthode IfNotNull")]
        public void Test_IfNotNull_calls_function_when_not_null()
        {
            string notNullString = "foo";
            int defaultValue = 10;

            int i3 = notNullString.IfNotNull(s => s.Length);
            Assert.AreEqual(i3, notNullString.Length);

            int i4 = notNullString.IfNotNull(s => s.Length, defaultValue);
            Assert.AreEqual(i4, notNullString.Length);
        }

        [Test(Description = "Vérifie le bon fonctionnement de la méthode IfNotNull")]
        public void Test_IfNotNull_Does_Not_calls_function_when_null_passed()
        {

            int defaultValue = 10;
            string nullString = null;

            int i3 = nullString.IfNotNull(s => s.Length);
            Assert.AreEqual(i3, 0);

            int i4 = nullString.IfNotNull(s => s.Length, defaultValue);
            Assert.AreEqual(i4, defaultValue);
        }

        [Test]
        public void Test_Between()
        {
            string min = "hello";
            string max = "world";

            // Borne inférieure
            string input = "hello";
            bool expected = true;
            bool actual = input.Between(min, max);
            Assert.AreEqual(expected, actual);

            // Borne supérieure
            input = "world";
            expected = true;
            actual = input.Between(min, max);
            Assert.AreEqual(expected, actual);

            // Entre les bornes
            input = "homer";
            expected = true;
            actual = input.Between(min, max);
            Assert.AreEqual(expected, actual);

            // Inférieur à borne min
            input = "donut";
            expected = false;
            actual = input.Between(min, max);
            Assert.AreEqual(expected, actual);

            // Supérieur à borne max
            input = "zoo";
            expected = false;
            actual = input.Between(min, max);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_StrictlyBetween()
        {
            string min = "hello";
            string max = "world";

            // Borne inférieure
            string input = "hello";
            bool expected = false;
            bool actual = input.StrictlyBetween(min, max);
            Assert.AreEqual(expected, actual);

            // Borne supérieure
            input = "world";
            expected = false;
            actual = input.StrictlyBetween(min, max);
            Assert.AreEqual(expected, actual);

            // Entre les bornes
            input = "homer";
            expected = true;
            actual = input.StrictlyBetween(min, max);
            Assert.AreEqual(expected, actual);

            // Inférieur à borne min
            input = "donut";
            expected = false;
            actual = input.StrictlyBetween(min, max);
            Assert.AreEqual(expected, actual);

            // Supérieur à borne max
            input = "zoo";
            expected = false;
            actual = input.StrictlyBetween(min, max);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_In()
        {
            string apple = "apple";
            string peach = "peach";
            string strawberry = "strawberry";

            var fruits = new List<string> { apple, peach, strawberry };

            string fruit = apple;
            bool expected = true;
            bool actual = fruit.In(apple, peach, strawberry);
            Assert.AreEqual(expected, actual);
            actual = fruit.In(fruits);
            Assert.AreEqual(expected, actual);

            fruit = "mango";
            expected = false;
            actual = fruit.In(apple, peach, strawberry);
            Assert.AreEqual(expected, actual);
            actual = fruit.In(fruits);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_ConvertTo()
        {
            string s = "2";
            int i = 2;
            double d = 2.0;
            DayOfWeek day = DayOfWeek.Tuesday;

            int i2 = s.ConvertTo<int>();
            Assert.AreEqual(i, i2);
            int i3 = d.ConvertTo<int>();
            Assert.AreEqual(i, i3);
            int i4 = day.ConvertTo<int>();
            Assert.AreEqual(i, i4);
            
            double d2 = s.ConvertTo<double>();
            Assert.AreEqual(d, d2);
            double d3 = i.ConvertTo<double>();
            Assert.AreEqual(d, d3);
            double d4 = day.ConvertTo<double>();
            Assert.AreEqual(d, d4);
        }

        [Test]
        public void Test_SafeEquals()
        {
            object obj1 = null;
            object obj2 = null;
            object obj3 = new object();
            object obj4 = obj3;
            object obj5 = new object();

            Assert.IsTrue(obj1.SafeEquals(obj1));
            Assert.IsTrue(obj3.SafeEquals(obj3));
            Assert.IsTrue(obj5.SafeEquals(obj5));

            Assert.IsTrue(obj1.SafeEquals(obj2));
            Assert.IsFalse(obj1.SafeEquals(obj3));
            Assert.IsFalse(obj3.SafeEquals(obj1));
            Assert.IsTrue(obj3.SafeEquals(obj4));
            Assert.IsTrue(obj4.SafeEquals(obj3));
            Assert.IsFalse(obj3.SafeEquals(obj5));
            Assert.IsFalse(obj5.SafeEquals(obj3));
        }

        [Test]
        public void Test_Switch()
        {
            Func<string, int> valueFromCard =
                c =>
                    c.Switch<string, int>()
                    .Case("J", 11)
                    .Case("Q", 12)
                    .Case("K", 13)
                    .Case("A", 1)
                    .Case("10", 10)
                    .Case(s => s.Length == 1 && char.IsDigit(s[0]),
                          s => int.Parse(s))
                    .Else(0)
                    .Result;

            Assert.AreEqual(11, valueFromCard("J"));
            Assert.AreEqual(12, valueFromCard("Q"));
            Assert.AreEqual(13, valueFromCard("K"));
            Assert.AreEqual(1, valueFromCard("A"));
            Assert.AreEqual(5, valueFromCard("5"));
            Assert.AreEqual(10, valueFromCard("10"));
            Assert.AreEqual(00, valueFromCard("100"));
        }

        [Test]
        public void Test_MakeHashCode()
        {
            int seed1 = 983;
            int seed2 = 457;
            var values = new[] { 4, 8, 15, 16, 23, 42 };
            int hash = seed1;
            foreach (var item in values)
            {
                hash = seed2 * hash ^ item.GetHashCode();
            }
            int expected = hash;
            int actual = this.MakeHashCode(values);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_ToHexString()
        {
            var bytes = Enumerable.Range(0, 256).Select(i => (byte) i).ToArray();
            string expected = BitConverter.ToString(bytes).Replace("-", string.Empty).ToLowerInvariant();
            string actual = bytes.ToHexString();
            Assert.AreEqual(expected, actual);
        }
    }
}