namespace Raliway.Tests.ReflectionHelper;

// --- Test types ---

file sealed record EquatableRecord(string Name, int Value);

file sealed class NonEquatableClass
{
    public string Name { get; }
    public NonEquatableClass(string name) => Name = name;
    public override bool Equals(object? obj) => obj is NonEquatableClass other && Name == other.Name;
    public override int GetHashCode() => Name.GetHashCode();
}

file readonly struct EquatableStruct : IEquatable<EquatableStruct>
{
    public int Value { get; }
    public EquatableStruct(int value) => Value = value;
    public bool Equals(EquatableStruct other) => Value == other.Value;
    public override bool Equals(object? obj) => obj is EquatableStruct s && Equals(s);
    public override int GetHashCode() => Value;
}

// --- IsEqual tests ---

public class IsEqual_Tests
{
    public class ValueType_IEquatable
    {
        [Fact] public void Equal_values() =>
            Just.Railway.ReflectionHelper.IsEqual(42, 42).ShouldBeTrue();

        [Fact] public void Different_values() =>
            Just.Railway.ReflectionHelper.IsEqual(42, 43).ShouldBeFalse();

        [Fact] public void Null_args() =>
            Just.Railway.ReflectionHelper.IsEqual(default(int), default(int)).ShouldBeTrue();
    }

    public class NullableValueType_IEquatable
    {
        [Fact] public void Both_have_same_value() =>
            Just.Railway.ReflectionHelper.IsEqual<int?>(42, 42).ShouldBeTrue();

        [Fact] public void Different_values() =>
            Just.Railway.ReflectionHelper.IsEqual<int?>(42, 43).ShouldBeFalse();

        [Fact] public void Both_null() =>
            Just.Railway.ReflectionHelper.IsEqual<int?>(null, null).ShouldBeTrue();

        [Fact] public void One_null_one_value() =>
            Just.Railway.ReflectionHelper.IsEqual<int?>(42, null).ShouldBeFalse();

        [Fact] public void Null_and_value_reversed() =>
            Just.Railway.ReflectionHelper.IsEqual<int?>(null, 42).ShouldBeFalse();
    }

    public class ReferenceType_IEquatable_String
    {
        [Fact] public void Equal_strings() =>
            Just.Railway.ReflectionHelper.IsEqual("hello", "hello").ShouldBeTrue();

        [Fact] public void Different_strings() =>
            Just.Railway.ReflectionHelper.IsEqual("hello", "world").ShouldBeFalse();

        [Fact] public void Both_null() =>
            Just.Railway.ReflectionHelper.IsEqual<string>(null, null).ShouldBeTrue();

        [Fact] public void Left_null_right_value() =>
            Just.Railway.ReflectionHelper.IsEqual<string>(null, "hello").ShouldBeFalse();

        [Fact] public void Left_value_right_null() =>
            Just.Railway.ReflectionHelper.IsEqual("hello", null).ShouldBeFalse();
    }

    public class ReferenceType_IEquatable_Error
    {
        [Fact] public void Equal_errors() =>
            Just.Railway.ReflectionHelper.IsEqual(
                Error.New("type", "msg"),
                Error.New("type", "msg")
            ).ShouldBeTrue();

        [Fact] public void Different_errors() =>
            Just.Railway.ReflectionHelper.IsEqual(
                Error.New("type_a", "msg"),
                Error.New("type_b", "msg")
            ).ShouldBeFalse();

        [Fact] public void Both_null() =>
            Just.Railway.ReflectionHelper.IsEqual<Error>(null, null).ShouldBeTrue();

        [Fact] public void One_null() =>
            Just.Railway.ReflectionHelper.IsEqual(Error.New("type", "msg"), null).ShouldBeFalse();
    }

    public class RecordType_IEquatable
    {
        [Fact] public void Equal_records() =>
            Just.Railway.ReflectionHelper.IsEqual(
                new EquatableRecord("a", 1),
                new EquatableRecord("a", 1)
            ).ShouldBeTrue();

        [Fact] public void Different_records() =>
            Just.Railway.ReflectionHelper.IsEqual(
                new EquatableRecord("a", 1),
                new EquatableRecord("b", 2)
            ).ShouldBeFalse();

        [Fact] public void Both_null() =>
            Just.Railway.ReflectionHelper.IsEqual<EquatableRecord>(null, null).ShouldBeTrue();
    }

    public class NonIEquatable_Fallback
    {
        [Fact] public void Equal_by_Equals_override() =>
            Just.Railway.ReflectionHelper.IsEqual(
                new NonEquatableClass("a"),
                new NonEquatableClass("a")
            ).ShouldBeTrue();

        [Fact] public void Not_equal() =>
            Just.Railway.ReflectionHelper.IsEqual(
                new NonEquatableClass("a"),
                new NonEquatableClass("b")
            ).ShouldBeFalse();

        [Fact] public void Both_null() =>
            Just.Railway.ReflectionHelper.IsEqual<NonEquatableClass>(null, null).ShouldBeTrue();

        [Fact] public void Left_null() =>
            Just.Railway.ReflectionHelper.IsEqual<NonEquatableClass>(null, new NonEquatableClass("a"))
                .ShouldBeFalse();
    }

    public class CustomEquatableStruct
    {
        [Fact] public void Equal() =>
            Just.Railway.ReflectionHelper.IsEqual(
                new EquatableStruct(1),
                new EquatableStruct(1)
            ).ShouldBeTrue();

        [Fact] public void Not_equal() =>
            Just.Railway.ReflectionHelper.IsEqual(
                new EquatableStruct(1),
                new EquatableStruct(2)
            ).ShouldBeFalse();
    }

    public class CustomNullableEquatableStruct
    {
        [Fact] public void Both_have_same_value() =>
            Just.Railway.ReflectionHelper.IsEqual<EquatableStruct?>(
                new EquatableStruct(1),
                new EquatableStruct(1)
            ).ShouldBeTrue();

        [Fact] public void Different_values() =>
            Just.Railway.ReflectionHelper.IsEqual<EquatableStruct?>(
                new EquatableStruct(1),
                new EquatableStruct(2)
            ).ShouldBeFalse();

        [Fact] public void Both_null() =>
            Just.Railway.ReflectionHelper.IsEqual<EquatableStruct?>(null, null).ShouldBeTrue();

        [Fact] public void One_null() =>
            Just.Railway.ReflectionHelper.IsEqual<EquatableStruct?>(new EquatableStruct(1), null)
                .ShouldBeFalse();
    }
}