using System.Diagnostics.CodeAnalysis;
using System.Numerics;
using Shouldly;
using Xunit;

namespace Just.PreciseMath.Tests;

public sealed class GenericConversionTests
{
    [Theory]
    [InlineData("byte")]
    [InlineData("sbyte")]
    [InlineData("short")]
    [InlineData("ushort")]
    [InlineData("int")]
    [InlineData("uint")]
    [InlineData("long")]
    [InlineData("ulong")]
    [InlineData("nint")]
    [InlineData("nuint")]
    [InlineData("Int128")]
    [InlineData("UInt128")]
    [InlineData("char")]
    public void EveryBoundedIntegerCoversBothEndpointsAndAdjacentValues(string type)
    {
        switch (type)
        {
            case "byte": AssertIntegerBoundaries(byte.MinValue, byte.MaxValue); break;
            case "sbyte": AssertIntegerBoundaries(sbyte.MinValue, sbyte.MaxValue); break;
            case "short": AssertIntegerBoundaries(short.MinValue, short.MaxValue); break;
            case "ushort": AssertIntegerBoundaries(ushort.MinValue, ushort.MaxValue); break;
            case "int": AssertIntegerBoundaries(int.MinValue, int.MaxValue); break;
            case "uint": AssertIntegerBoundaries(uint.MinValue, uint.MaxValue); break;
            case "long": AssertIntegerBoundaries(long.MinValue, long.MaxValue); break;
            case "ulong": AssertIntegerBoundaries(ulong.MinValue, ulong.MaxValue); break;
            case "nint": AssertIntegerBoundaries(nint.MinValue, nint.MaxValue); break;
            case "nuint": AssertIntegerBoundaries(nuint.MinValue, nuint.MaxValue); break;
            case "Int128": AssertIntegerBoundaries(Int128.MinValue, Int128.MaxValue); break;
            case "UInt128": AssertIntegerBoundaries(UInt128.MinValue, UInt128.MaxValue); break;
            case "char": AssertIntegerBoundaries(char.MinValue, char.MaxValue); break;
            default: throw new ArgumentOutOfRangeException(nameof(type));
        }
    }

    private static void AssertIntegerBoundaries<T>(T minimum, T maximum) where T : struct, INumberBase<T>
    {
        BigInteger min = BigInteger.CreateChecked(minimum);
        BigInteger max = BigInteger.CreateChecked(maximum);
        BigInteger width = max - min + 1;

        // Integer inputs near these power-of-two endpoints have exact two-component
        // representations, even for Int128/UInt128. No round-trip is used as an oracle.
        foreach (BigInteger integer in new[] { min, min + 1, max - 1, max })
        {
            T input = T.CreateChecked(integer);
            foreach (int mode in new[] { 0, 1, 2 })
            {
                DoubleDouble direct = mode switch
                {
                    0 => DoubleDouble.CreateChecked(input),
                    1 => DoubleDouble.CreateSaturating(input),
                    _ => DoubleDouble.CreateTruncating(input),
                };
                AssertExactQuarters(direct, integer * 4);
                AssertExactQuarters(CreateInMode<DoubleDouble, T>(input, mode), integer * 4);
                DoubleDouble hooked;
                bool supported = mode switch
                {
                    0 => ConversionProbe<DoubleDouble>.FromChecked(input, out hooked),
                    1 => ConversionProbe<DoubleDouble>.FromSaturating(input, out hooked),
                    _ => ConversionProbe<DoubleDouble>.FromTruncating(input, out hooked),
                };
                supported.ShouldBeTrue();
                AssertExactQuarters(hooked, integer * 4);
            }
        }

        foreach (BigInteger endpoint in new[] { min, max })
        {
            // Whole-unit neighbors test range transitions; quarter-unit neighbors
            // prove truncation happens BEFORE range handling, on the exact sum.
            // Including +/-1.25 crosses the negative endpoint's truncation boundary.
            foreach (int offset in new[] { -5, -4, -3, -1, 0, 1, 3, 4, 5 })
            {
                BigInteger numerator = (endpoint * 4) + offset;
                DoubleDouble input = FromExactQuarters(numerator);
                BigInteger integer = numerator / 4;
                BigInteger clamped = BigInteger.Min(max, BigInteger.Max(min, integer));
                // Finite DD sources use BigInteger-style modular truncation, NOT
                // binary64's floating-to-integer clamping. Derive modulo independently.
                BigInteger wrapped = (((integer - min) % width) + width) % width + min;
                foreach (int mode in new[] { 0, 1, 2 })
                {
                    if (mode == 0 && (integer < min || integer > max))
                    {
                        Should.Throw<OverflowException>(() => CreateInMode<T, DoubleDouble>(input, mode));
                        Should.Throw<OverflowException>(() => ConvertToInMode<T>(input, mode));
                    }
                    else
                    {
                        BigInteger expected = mode == 0 ? integer : mode == 1 ? clamped : wrapped;
                        BigInteger.CreateChecked(CreateInMode<T, DoubleDouble>(input, mode)).ShouldBe(expected);
                        BigInteger.CreateChecked(ConvertToInMode<T>(input, mode)).ShouldBe(expected);
                    }
                }
            }
        }

        AssertNonfiniteIntegerPolicy<T>();
    }

    private static TTarget CreateInMode<TTarget, TSource>(TSource value, int mode)
        where TTarget : INumberBase<TTarget>
        where TSource : INumberBase<TSource>
    {
        return mode switch
        {
            0 => TTarget.CreateChecked(value),
            1 => TTarget.CreateSaturating(value),
            _ => TTarget.CreateTruncating(value),
        };
    }

    private static T ConvertToInMode<T>(DoubleDouble value, int mode) where T : struct, INumberBase<T>
    {
        T result;
        bool supported = mode switch
        {
            0 => ConversionProbe<DoubleDouble>.ToChecked(value, out result),
            1 => ConversionProbe<DoubleDouble>.ToSaturating(value, out result),
            _ => ConversionProbe<DoubleDouble>.ToTruncating(value, out result),
        };
        supported.ShouldBeTrue();
        return result;
    }

    private static DoubleDouble FromExactQuarters(BigInteger numerator)
    {
        // Choose the nearest signed power of two using exact integer distances.
        // A direct BigInteger-to-double cast can truncate rather than round, leaving
        // an inexact large residual at 128-bit endpoints. Powers of two cast exactly.
        BigInteger magnitude = BigInteger.Abs(numerator);
        BigInteger integral = magnitude / 4;
        BigInteger anchor = BigInteger.Zero;
        if (!integral.IsZero)
        {
            anchor = BigInteger.One << checked((int)integral.GetBitLength() - 1);
            if (BigInteger.Abs(magnitude - (anchor * 8)) < BigInteger.Abs(magnitude - (anchor * 4)))
            {
                anchor *= 2;
            }
        }
        double high = (double)(anchor * numerator.Sign);
        double low = (double)(numerator - (new BigInteger(high) * 4)) / 4.0;
        DoubleDouble result = DoubleDouble.FromComponents(high, low);
        AssertExactQuarters(result, numerator);
        return result;
    }

    private static void AssertExactQuarters(DoubleDouble value, BigInteger numerator)
    {
        double high = value.High * 4.0;
        double low = value.Low * 4.0;
        double.IsFinite(high).ShouldBeTrue();
        double.IsFinite(low).ShouldBeTrue();
        Math.Truncate(high).ShouldBe(high);
        Math.Truncate(low).ShouldBe(low);
        (new BigInteger(high) + new BigInteger(low)).ShouldBe(numerator);
    }

    private static void AssertNonfiniteIntegerPolicy<T>() where T : struct, INumberBase<T>
    {
        // Unlike finite DD inputs, NaN/infinities explicitly inherit the destination's
        // BCL binary64-source policy. Query that independent API, including exceptions;
        // do not assume every signed/unsigned/native target maps NaN identically.
        foreach (double special in new[] { double.NaN, double.NegativeInfinity, double.PositiveInfinity })
        {
            foreach (int mode in new[] { 0, 1, 2 })
            {
                T expected;
                try
                {
                    expected = CreateInMode<T, double>(special, mode);
                }
                catch (OverflowException)
                {
                    Should.Throw<OverflowException>(() => CreateInMode<T, DoubleDouble>(new DoubleDouble(special), mode));
                    Should.Throw<OverflowException>(() => ConvertToInMode<T>(new DoubleDouble(special), mode));
                    continue;
                }
                CreateInMode<T, DoubleDouble>(new DoubleDouble(special), mode).ShouldBe(expected);
                ConvertToInMode<T>(new DoubleDouble(special), mode).ShouldBe(expected);
            }
        }
    }

    [Fact]
    public void UnboundedIntegerUsesFloatingInputOverflowButHasNoFiniteOutputEndpoints()
    {
        foreach (int sign in new[] { -1, 1 })
        {
            BigInteger huge = sign * (BigInteger.One << 2000);
            foreach (int mode in new[] { 0, 1, 2 })
            {
                DoubleDouble created = CreateInMode<DoubleDouble, BigInteger>(huge, mode);
                created.High.ShouldBe(sign < 0 ? double.NegativeInfinity : double.PositiveInfinity);
                created.Low.ShouldBe(0.0);
                DoubleDouble hooked;
                bool supported = mode switch
                {
                    0 => ConversionProbe<DoubleDouble>.FromChecked(huge, out hooked),
                    1 => ConversionProbe<DoubleDouble>.FromSaturating(huge, out hooked),
                    _ => ConversionProbe<DoubleDouble>.FromTruncating(huge, out hooked),
                };
                supported.ShouldBeTrue();
                hooked.High.ShouldBe(created.High);
                hooked.Low.ShouldBe(0.0);

                // BigInteger has no endpoints: exact sparse integers beyond UInt128
                // still truncate without clamping or wrapping in every output mode.
                BigInteger integer = sign * ((BigInteger.One << 200) + 1);
                DoubleDouble finite = FromExactQuarters((integer * 4) + sign);
                CreateInMode<BigInteger, DoubleDouble>(finite, mode).ShouldBe(integer);
                ConvertToInMode<BigInteger>(finite, mode).ShouldBe(integer);
                AssertExactQuarters(CreateInMode<DoubleDouble, BigInteger>(integer, mode), integer * 4);
            }
        }
        AssertNonfiniteIntegerPolicy<BigInteger>();
    }

    [Fact]
    public void GenericCreationPreservesComponentsAndExactIntegers()
    {
        DoubleDouble value = DoubleDouble.FromComponents(1.0, double.Epsilon);
        DoubleDouble.CreateChecked(value).Low.ShouldBe(double.Epsilon);
        DoubleDouble.CreateSaturating(value).Low.ShouldBe(double.Epsilon);
        DoubleDouble.CreateTruncating(value).Low.ShouldBe(double.Epsilon);
        DoubleDouble.CreateChecked(ulong.MaxValue).High.ShouldBe(Math.ScaleB(1.0, 64));
        DoubleDouble.CreateChecked(ulong.MaxValue).Low.ShouldBe(-1.0);
        DoubleDouble.CreateChecked(decimal.MaxValue).Low.ShouldBe(-1.0);
        BigInteger integer = (BigInteger.One << 100) + 1;
        BigInteger.CreateChecked(DoubleDouble.CreateChecked(integer)).ShouldBe(integer);
        BitConverter.DoubleToInt64Bits(DoubleDouble.CreateChecked(-0.0).High).ShouldBe(long.MinValue);
    }

    [Fact]
    public void IntegerTargetsTruncateTheExactSumBeforeApplyingRangePolicy()
    {
        int.CreateChecked(DoubleDouble.FromComponents(1.0, -double.Epsilon)).ShouldBe(0);
        int.CreateChecked(DoubleDouble.FromComponents(-1.0, double.Epsilon)).ShouldBe(0);
        long.CreateChecked(DoubleDouble.FromComponents(Math.ScaleB(1.0, 63), -1.0)).ShouldBe(long.MaxValue);
        ulong.CreateChecked(DoubleDouble.FromComponents(Math.ScaleB(1.0, 64), -1.0)).ShouldBe(ulong.MaxValue);
        DoubleDouble overflow = new(256.75);
        Should.Throw<OverflowException>(() => byte.CreateChecked(overflow));
        byte.CreateSaturating(overflow).ShouldBe(byte.MaxValue);
        byte.CreateTruncating(overflow).ShouldBe((byte)0);
        byte.CreateSaturating(new DoubleDouble(-1.0)).ShouldBe((byte)0);
        byte.CreateTruncating(new DoubleDouble(-1.0)).ShouldBe(byte.MaxValue);
    }

    [Fact]
    public void HugeIntegerInputsUseFloatingOverflowAndExactRatioRounding()
    {
        BigInteger huge = BigInteger.One << 2000;
        double.IsPositiveInfinity(DoubleDouble.CreateChecked(huge).High).ShouldBeTrue();
        double.IsPositiveInfinity(DoubleDouble.CreateSaturating(huge).High).ShouldBeTrue();
        double.IsNegativeInfinity(DoubleDouble.CreateTruncating(-huge).High).ShouldBeTrue();
        // A sparse exact integer must retain its low component rather than pass through double.
        DoubleDouble sparse = DoubleDouble.CreateChecked((BigInteger.One << 100) + 1);
        sparse.High.ShouldBe(Math.ScaleB(1.0, 100));
        sparse.Low.ShouldBe(1.0);
    }

    [Fact]
    public void FloatingAndDecimalTargetsRetainResidualRounding()
    {
        DoubleDouble aboveFloatMidpoint = DoubleDouble.FromComponents(1.0 + Math.ScaleB(1.0, -24), double.Epsilon);
        float.CreateChecked(aboveFloatMidpoint).ShouldBe(float.BitIncrement(1.0f));
        DoubleDouble aboveHalfMidpoint = DoubleDouble.FromComponents(1.0 + Math.ScaleB(1.0, -11), double.Epsilon);
        Half.CreateChecked(aboveHalfMidpoint).ShouldBe(Half.BitIncrement((Half)1));
        decimal.CreateChecked(DoubleDouble.CreateChecked(0.1m)).ShouldBe(0.1m);
        Should.Throw<OverflowException>(() => decimal.CreateChecked(new DoubleDouble(double.PositiveInfinity)));
        decimal.CreateSaturating(new DoubleDouble(double.PositiveInfinity)).ShouldBe(decimal.MaxValue);
        decimal.CreateTruncating(DoubleDouble.NaN).ShouldBe(0m);
        int.CreateSaturating(DoubleDouble.NaN).ShouldBe(0);
        int.CreateTruncating(new DoubleDouble(double.PositiveInfinity)).ShouldBe(int.MaxValue);
        Should.Throw<OverflowException>(() => int.CreateChecked(DoubleDouble.NaN));
    }

    [Fact]
    public void BuiltInNumericFamiliesRoundTripThroughAllCreationModes()
    {
        RoundTrip((byte)123);
        RoundTrip((sbyte)-123);
        RoundTrip((short)-12345);
        RoundTrip((ushort)54321);
        RoundTrip(int.MinValue);
        RoundTrip(uint.MaxValue);
        RoundTrip(long.MinValue);
        RoundTrip(ulong.MaxValue);
        RoundTrip((nint)(-12345));
        RoundTrip((nuint)54321);
        RoundTrip((Int128.One << 100) + 1);
        RoundTrip((UInt128.One << 100) + 1);
        RoundTrip('A');
        RoundTrip((Half)1.25);
        RoundTrip(1.25f);
        RoundTrip(1.25);
        RoundTrip(1.25m);
    }

    private static void RoundTrip<T>(T value) where T : INumberBase<T>
    {
        T.CreateChecked(DoubleDouble.CreateChecked(value)).ShouldBe(value);
        T.CreateSaturating(DoubleDouble.CreateSaturating(value)).ShouldBe(value);
        T.CreateTruncating(DoubleDouble.CreateTruncating(value)).ShouldBe(value);
    }

    [Fact]
    public void UnsupportedHooksReturnFalseWithoutTwoSidedRecursion()
    {
        ConversionProbe<DoubleDouble>.FromChecked(Complex.One, out DoubleDouble from).ShouldBeFalse();
        from.ShouldBe(DoubleDouble.Zero);
        ConversionProbe<DoubleDouble>.FromSaturating(Complex.One, out _).ShouldBeFalse();
        ConversionProbe<DoubleDouble>.FromTruncating(Complex.One, out _).ShouldBeFalse();
        ConversionProbe<DoubleDouble>.ToChecked(DoubleDouble.One, out Complex to).ShouldBeFalse();
        to.ShouldBe(default);
        ConversionProbe<DoubleDouble>.ToSaturating(DoubleDouble.One, out Complex _).ShouldBeFalse();
        ConversionProbe<DoubleDouble>.ToTruncating(DoubleDouble.One, out Complex _).ShouldBeFalse();
    }

    private interface ConversionProbe<T> : INumberBase<T> where T : INumberBase<T>
    {
        public static bool FromChecked<TOther>(TOther value, [MaybeNullWhen(false)] out T result) where TOther : INumberBase<TOther>
        {
            return T.TryConvertFromChecked(value, out result);
        }

        public static bool FromSaturating<TOther>(TOther value, [MaybeNullWhen(false)] out T result) where TOther : INumberBase<TOther>
        {
            return T.TryConvertFromSaturating(value, out result);
        }

        public static bool FromTruncating<TOther>(TOther value, [MaybeNullWhen(false)] out T result) where TOther : INumberBase<TOther>
        {
            return T.TryConvertFromTruncating(value, out result);
        }

        public static bool ToChecked<TOther>(T value, [MaybeNullWhen(false)] out TOther result) where TOther : INumberBase<TOther>
        {
            return T.TryConvertToChecked(value, out result);
        }

        public static bool ToSaturating<TOther>(T value, [MaybeNullWhen(false)] out TOther result) where TOther : INumberBase<TOther>
        {
            return T.TryConvertToSaturating(value, out result);
        }

        public static bool ToTruncating<TOther>(T value, [MaybeNullWhen(false)] out TOther result) where TOther : INumberBase<TOther>
        {
            return T.TryConvertToTruncating(value, out result);
        }
    }

    [Fact]
    public void UnsupportedComplexConversionTerminatesWithNotSupported()
    {
        Should.Throw<NotSupportedException>(() => DoubleDouble.CreateChecked(Complex.One));
        Should.Throw<NotSupportedException>(() => DoubleDouble.CreateSaturating(Complex.One));
        Should.Throw<NotSupportedException>(() => DoubleDouble.CreateTruncating(Complex.One));
    }
}