#nullable enable

using System;
using Barotrauma;
using Barotrauma.Networking;
using FluentAssertions;
using FsCheck;
using Microsoft.Xna.Framework;
using Xunit;

namespace TestProject
{
    // ReSharper disable UnusedMember.Local NotAccessedField.Local UnusedMember.Global
    public class INetSerializableStructTests
    {
        private class CustomGenerators
        {
            // no null strings!!!
            public static Arbitrary<string> StringGeneratorOverride() => Arb.Default.String().Generator.Where(s => s != null).ToArbitrary();
        }

        public INetSerializableStructTests()
        {
            Arb.Register<TestProject.CustomGenerators>();
            Arb.Register<CustomGenerators>();
        }

        [Fact]
        public void TestOptional()
        {
            Prop.ForAll<Option<Int32>>(SerializeDeserialize).QuickCheckThrowOnFailure();
            Prop.ForAll<Option<Byte[]>>(SerializeDeserialize).QuickCheckThrowOnFailure();
            Prop.ForAll<Option<String>>(SerializeDeserialize).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestNested()
        {
            Prop.ForAll<String, Int32, Boolean>((arg1, arg2, arg3) => SerializeDeserializeNullableTuple(arg1, new TupleNullableStruct<int, bool> { One = arg2, Two = arg3 })).QuickCheckThrowOnFailure();
            Prop.ForAll<Byte, UInt64>((arg1, arg2) => SerializeDeserialize(new TupleNullableStruct<byte, ulong> { One = arg1, Two = arg2 })).QuickCheckThrowOnFailure();
            Prop.ForAll<Int16, String>((arg1, arg2) => SerializeDeserialize(new TupleNullableStruct<short, string> { One = arg1, Two = arg2 })).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestVector2()
        {
            Prop.ForAll<Vector2>(SerializeDeserialize).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestColor()
        {
            Prop.ForAll<Color>(SerializeDeserialize).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestEnum()
        {
            Prop.ForAll<EnumTest>(SerializeDeserialize).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestArray()
        {
            Prop.ForAll<Int32[]>(SerializeDeserialize).QuickCheckThrowOnFailure();
            Prop.ForAll<Boolean[]>(SerializeDeserialize).QuickCheckThrowOnFailure();
            Prop.ForAll<String[]>(SerializeDeserialize).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestNullable()
        {
            Prop.ForAll<Int32?, String?>(SerializeDeserializeNullableTuple).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestBoolean()
        {
            Prop.ForAll<Boolean>(SerializeDeserialize).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestByte()
        {
            Prop.ForAll<Byte>(SerializeDeserialize).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestUInt16()
        {
            Prop.ForAll<UInt16>(SerializeDeserialize).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestInt16()
        {
            Prop.ForAll<Int16>(SerializeDeserialize).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestUInt32()
        {
            Prop.ForAll<UInt32>(SerializeDeserialize).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestInt32()
        {
            Prop.ForAll<Int32>(SerializeDeserialize).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestUInt64()
        {
            Prop.ForAll<UInt64>(SerializeDeserialize).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestInt64()
        {
            Prop.ForAll<Int64>(SerializeDeserialize).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestSingle()
        {
            Prop.ForAll<Single>(SerializeDeserialize).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestDouble()
        {
            Prop.ForAll<Double>(SerializeDeserialize).QuickCheckThrowOnFailure();
        }

        [Fact]
        public void TestString()
        {
            Prop.ForAll<String>(SerializeDeserialize).QuickCheckThrowOnFailure();
        }

        private enum EnumTest
        {
            One = 1,
            Two = 2,
            Three = 3,
            Thousand = 1000
        }

        private struct TestStruct<T> : INetSerializableStruct
        {
            [NetworkSerialize]
            public T Value;

            public T NotSerializedValue;

            public T NotSerializedFunction() => throw new NotImplementedException();
        }

        private struct TupleNullableStruct<T, U> : INetSerializableStruct
        {
            [NetworkSerialize]
            public T? One;

            [NetworkSerialize]
            public U? Two;

            public (T, U) NotSerializedValue;
            public (T, U) NotSerializedFunction() => throw new NotImplementedException();
        }

        private static void SerializeDeserialize<T>(T arg) where T : notnull
        {
            ReadWriteMessage msg = new ReadWriteMessage();
            TestStruct<T> writeStruct = new TestStruct<T>
            {
                Value = arg
            };

            ((INetSerializableStruct)writeStruct).Write(msg);
            msg.BitPosition = 0;

            TestStruct<T> readStruct = INetSerializableStruct.Read<TestStruct<T>>(msg);

            readStruct.Should().BeEquivalentTo(writeStruct, options => options.ComparingByMembers<TestStruct<T>>());
        }

        private static void SerializeDeserializeNullableTuple<T, U>(T arg1, U arg2)
        {
            ReadWriteMessage msg = new ReadWriteMessage();
            TupleNullableStruct<T, U> writeStruct = new TupleNullableStruct<T, U>
            {
                One = arg1,
                Two = arg2
            };

            ((INetSerializableStruct)writeStruct).Write(msg);
            msg.BitPosition = 0;

            TupleNullableStruct<T, U> readStruct = INetSerializableStruct.Read<TupleNullableStruct<T, U>>(msg);

            readStruct.Should().BeEquivalentTo(writeStruct, options => options.ComparingByMembers<TupleNullableStruct<T, U>>());
        }
    }
}