using System;
using System.Diagnostics;
using System.Threading;
using System.Windows;

namespace Standard;

internal static class Assert
{
    private static void _Break()
    {
        Debugger.Break();
    }

    [Conditional("DEBUG")]
    public static void Evaluate(Assert.EvaluateFunction argument)
    {
        argument();
    }

    [Obsolete("Use Assert.AreEqual instead of Assert.Equals", false)]
    [Conditional("DEBUG")]
    public static void Equals<T>(T expected, T actual)
    {
    }

    [Conditional("DEBUG")]
    public static void AreEqual<T>(T expected, T actual)
    {
        if (expected == null)
        {
            if (actual != null && !actual.Equals(expected))
            {
                Assert._Break();
                return;
            }
        }
        else if (!expected.Equals(actual))
        {
            Assert._Break();
        }
    }

    [Conditional("DEBUG")]
    public static void AreNotEqual<T>(T notExpected, T actual)
    {
        if (notExpected == null)
        {
            if (actual == null || actual.Equals(notExpected))
            {
                Assert._Break();
                return;
            }
        }
        else if (notExpected.Equals(actual))
        {
            Assert._Break();
        }
    }

    [Conditional("DEBUG")]
    public static void Implies(bool condition, bool result)
    {
        if (condition && !result)
        {
            Assert._Break();
        }
    }

    [Conditional("DEBUG")]
    public static void Implies(bool condition, Assert.ImplicationFunction result)
    {
        if (condition && !result())
        {
            Assert._Break();
        }
    }

    [Conditional("DEBUG")]
    public static void IsNeitherNullNorEmpty(string value)
    {
    }

    [Conditional("DEBUG")]
    public static void IsNeitherNullNorWhitespace(string value)
    {
        if (string.IsNullOrEmpty(value))
        {
            Assert._Break();
        }
        if (value.Trim().Length == 0)
        {
            Assert._Break();
        }
    }

    [Conditional("DEBUG")]
    public static void IsNotNull<T>(T value) where T : class
    {
        if (value == null)
        {
            Assert._Break();
        }
    }

    [Conditional("DEBUG")]
    public static void IsDefault<T>(T value) where T : struct
    {
        value.Equals(default(T));
    }

    [Conditional("DEBUG")]
    public static void IsNotDefault<T>(T value) where T : struct
    {
        value.Equals(default(T));
    }

    [Conditional("DEBUG")]
    public static void IsFalse(bool condition)
    {
        if (condition)
        {
            Assert._Break();
        }
    }

    [Conditional("DEBUG")]
    public static void IsFalse(bool condition, string message)
    {
        if (condition)
        {
            Assert._Break();
        }
    }

    [Conditional("DEBUG")]
    public static void IsTrue(bool condition)
    {
        if (!condition)
        {
            Assert._Break();
        }
    }

    [Conditional("DEBUG")]
    public static void IsTrue(bool condition, string message)
    {
        if (!condition)
        {
            Assert._Break();
        }
    }

    [Conditional("DEBUG")]
    public static void Fail()
    {
        Assert._Break();
    }

    [Conditional("DEBUG")]
    public static void Fail(string message)
    {
        Assert._Break();
    }

    [Conditional("DEBUG")]
    public static void IsNull<T>(T item) where T : class
    {
        if (item != null)
        {
            Assert._Break();
        }
    }

    [Conditional("DEBUG")]
    public static void BoundedDoubleInc(double lowerBoundInclusive, double value, double upperBoundInclusive)
    {
        if (value < lowerBoundInclusive || value > upperBoundInclusive)
        {
            Assert._Break();
        }
    }

    [Conditional("DEBUG")]
    public static void BoundedInteger(int lowerBoundInclusive, int value, int upperBoundExclusive)
    {
        if (value < lowerBoundInclusive || value >= upperBoundExclusive)
        {
            Assert._Break();
        }
    }

    [Conditional("DEBUG")]
    public static void IsApartmentState(ApartmentState expectedState)
    {
        if (Thread.CurrentThread.GetApartmentState() != expectedState)
        {
            Assert._Break();
        }
    }

    [Conditional("DEBUG")]
    public static void NullableIsNotNull<T>(T? value) where T : struct
    {
        if (value == null)
        {
            Assert._Break();
        }
    }

    [Conditional("DEBUG")]
    public static void NullableIsNull<T>(T? value) where T : struct
    {
        if (value != null)
        {
            Assert._Break();
        }
    }

    [Conditional("DEBUG")]
    public static void IsNotOnMainThread()
    {
        if (Application.Current.Dispatcher.CheckAccess())
        {
            Assert._Break();
        }
    }

    public delegate void EvaluateFunction();

    public delegate bool ImplicationFunction();
}