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

namespace Developpez.Dotnet.Tests
{
    public class Assert2
    {
        public static void Throws<TException>(Action action)
            where TException : Exception
        {
            Throws<TException>(action, null);
        }

        public static void Throws<TException>(Action action, Func<TException, bool> exceptionPredicate)
            where TException : Exception
        {
            bool wasRaised = false;
            try
            {
                action();
            }
            catch (TException ex)
            {
                wasRaised = true;
                if (exceptionPredicate != null)
                    Assert.IsTrue(exceptionPredicate(ex));
            }
            Assert.IsTrue(wasRaised, "A '{0}' was expected but was not thrown.", typeof(TException).Name);
        }

        public static void AreSequenceEqual<T>(IEnumerable<T> expected, IEnumerable<T> actual)
        {
            AreSequenceEqual(expected, actual, null);
        }
        
        public static void AreSequenceEqual<T>(IEnumerable<T> expected, IEnumerable<T> actual, IEqualityComparer<T> comparer)
        {
            const string errorShorter = "Actual sequence is shorter than expected sequence";
            const string errorLonger = "Actual sequence is longer than expected sequence";
            comparer = comparer ?? EqualityComparer<T>.Default;
            int n = 0;
            using (var expectedEnumerator = expected.GetEnumerator())
            using (var actualEnumerator = actual.GetEnumerator())
            {
                bool expectedHasNext = expectedEnumerator.MoveNext();
                bool actualHasNext = actualEnumerator.MoveNext();

                if (expectedHasNext && !actualHasNext)
                    Assert.Fail(errorShorter);
                if (actualHasNext && !expectedHasNext)
                    Assert.Fail(errorLonger);

                while (expectedHasNext)
                {
                    if (!comparer.Equals(expectedEnumerator.Current, actualEnumerator.Current))
                        Assert.Fail("Sequences differ at position {0} - expected: {1}, actual: {2}",
                                    n, expectedEnumerator.Current, actualEnumerator.Current);
                    n++;

                    expectedHasNext = expectedEnumerator.MoveNext();
                    actualHasNext = actualEnumerator.MoveNext();

                    if (expectedHasNext && !actualHasNext)
                        Assert.Fail(errorShorter);
                    if (actualHasNext && !expectedHasNext)
                        Assert.Fail(errorLonger);
                }
            }
        }

        public static void AreSequenceEqual<T, TKey>(IEnumerable<T> expected, IEnumerable<T> actual, Func<T, TKey> sortKeySelector)
        {
            AreSequenceEqual(
                expected.OrderBy(sortKeySelector),
                actual.OrderBy(sortKeySelector));
        }
    }
}