// Source: https://github.com/dotnet/runtime/blob/v9.0.1/src/libraries/System.Memory/tests/TestHelpers.cs
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;

namespace Lucene.Net
{
    public static class TestHelpers
    {
        public static void Validate<T>(this Span<T> span, params T[] expected) where T : struct, IEquatable<T>
        {
            Assert.True(span.SequenceEqual(expected));
        }

        public static void ValidateReferenceType<T>(this Span<T> span, params T[] expected) where T : class
        {
            Assert.AreEqual(span.Length, expected.Length);
            for (int i = 0; i < expected.Length; i++)
            {
                T actual = span[i];
                Assert.AreSame(expected[i], actual);
            }

            T ignore;
            AssertThrows<IndexOutOfRangeException, T>(span, (_span) => ignore = _span[expected.Length]);
        }

        public static unsafe void ValidateNonNullEmpty<T>(this Span<T> span)
        {
            Assert.True(span.IsEmpty);

            // Validate that empty Span is not normalized to null
            Assert.True(Unsafe.AsPointer(ref MemoryMarshal.GetReference(span)) != null);
        }

        public delegate void AssertThrowsAction<T>(Span<T> span);

        // Cannot use standard Assert.Throws() when testing Span - Span and closures don't get along.
        public static void AssertThrows<E, T>(Span<T> span, AssertThrowsAction<T> action) where E : Exception
        {
            try
            {
                action(span);
                Assert.False(true, "Expected exception: " + typeof(E).GetType());
            }
            catch (E)
            {
            }
            catch (Exception wrongException)
            {
                Assert.False(true, "Wrong exception thrown: Expected " + typeof(E).GetType() + ": Actual: " + wrongException.GetType());
            }
        }

        //
        // The innocent looking construct:
        //
        //    Assert.Throws<E>( () => new Span() );
        //
        // generates a hidden box of the Span as the return value of the lambda. This makes the IL illegal and unloadable on
        // runtimes that enforce the actual Span rules (never mind that we expect never to reach the box instruction...)
        //
        // The workaround is to code it like this:
        //
        //    Assert.Throws<E>( () => new Span().DontBox() );
        //
        // which turns the lambda return type back to "void" and eliminates the troublesome box instruction.
        //
        public static void DontBox<T>(this Span<T> span)
        {
            // This space intentionally left blank.
        }

        public static void Validate<T>(this ReadOnlySpan<T> span, params T[] expected) where T : struct, IEquatable<T>
        {
            Assert.True(span.SequenceEqual(expected));
        }

        public static void ValidateReferenceType<T>(this ReadOnlySpan<T> span, params T[] expected) where T : class
        {
            Assert.AreEqual(span.Length, expected.Length);
            for (int i = 0; i < expected.Length; i++)
            {
                T actual = span[i];
                Assert.AreSame(expected[i], actual);
            }

            T ignore;
            AssertThrows<IndexOutOfRangeException, T>(span, (_span) => ignore = _span[expected.Length]);
        }

        public static unsafe void ValidateNonNullEmpty<T>(this ReadOnlySpan<T> span)
        {
            Assert.True(span.IsEmpty);

            // Validate that empty Span is not normalized to null
            Assert.True(Unsafe.AsPointer(ref MemoryMarshal.GetReference(span)) != null);
        }

        public delegate void AssertThrowsActionReadOnly<T>(ReadOnlySpan<T> span);

        // Cannot use standard Assert.Throws() when testing Span - Span and closures don't get along.
        public static void AssertThrows<E, T>(ReadOnlySpan<T> span, AssertThrowsActionReadOnly<T> action) where E : Exception
        {
            try
            {
                action(span);
                Assert.False(true, "Expected exception: " + typeof(E).GetType());
            }
            catch (E)
            {
            }
            catch (Exception wrongException)
            {
                Assert.False(true, "Wrong exception thrown: Expected " + typeof(E).GetType() + ": Actual: " + wrongException.GetType());
            }
        }

        //
        // The innocent looking construct:
        //
        //    Assert.Throws<E>( () => new Span() );
        //
        // generates a hidden box of the Span as the return value of the lambda. This makes the IL illegal and unloadable on
        // runtimes that enforce the actual Span rules (never mind that we expect never to reach the box instruction...)
        //
        // The workaround is to code it like this:
        //
        //    Assert.Throws<E>( () => new Span().DontBox() );
        //
        // which turns the lambda return type back to "void" and eliminates the troublesome box instruction.
        //
        public static void DontBox<T>(this ReadOnlySpan<T> span)
        {
            // This space intentionally left blank.
        }

        public static void Validate<T>(this Memory<T> memory, params T[] expected) where T : IEquatable<T>
        {
            Assert.True(memory.Span.SequenceEqual(expected));
        }

        public static void ValidateReferenceType<T>(this Memory<T> memory, params T[] expected) where T : class
        {
            T[] bufferArray = memory.ToArray();
            Assert.AreEqual(memory.Length, expected.Length);
            for (int i = 0; i < expected.Length; i++)
            {
                T actual = bufferArray[i];
                Assert.AreSame(expected[i], actual);
            }
        }

        public static void Validate<T>(this ReadOnlyMemory<T> memory, params T[] expected) where T : IEquatable<T>
        {
            Assert.True(memory.Span.SequenceEqual(expected));
        }

        public static void ValidateReferenceType<T>(this ReadOnlyMemory<T> memory, params T[] expected) where T : class
        {
            T[] bufferArray = memory.ToArray();
            Assert.AreEqual(memory.Length, expected.Length);
            for (int i = 0; i < expected.Length; i++)
            {
                T actual = bufferArray[i];
                Assert.AreSame(expected[i], actual);
            }
        }

        public static void Validate<T>(Span<byte> span, T value) where T : struct
        {
            T read = MemoryMarshal.Read<T>(span);
            Assert.AreEqual(value, read);
            span.Clear();
        }

        public static TestStructExplicit s_testExplicitStruct = new TestStructExplicit
        {
            S0 = short.MaxValue,
            I0 = int.MaxValue,
            L0 = long.MaxValue,
            US0 = ushort.MaxValue,
            UI0 = uint.MaxValue,
            UL0 = ulong.MaxValue,
            S1 = short.MinValue,
            I1 = int.MinValue,
            L1 = long.MinValue,
            US1 = ushort.MinValue,
            UI1 = uint.MinValue,
            UL1 = ulong.MinValue
        };

        //public static Span<byte> GetSpanBE()
        //{
        //    Span<byte> spanBE = new byte[Unsafe.SizeOf<TestStructExplicit>()];

        //    WriteInt16BigEndian(spanBE, s_testExplicitStruct.S0);
        //    WriteInt32BigEndian(spanBE.Slice(2), s_testExplicitStruct.I0);
        //    WriteInt64BigEndian(spanBE.Slice(6), s_testExplicitStruct.L0);
        //    WriteUInt16BigEndian(spanBE.Slice(14), s_testExplicitStruct.US0);
        //    WriteUInt32BigEndian(spanBE.Slice(16), s_testExplicitStruct.UI0);
        //    WriteUInt64BigEndian(spanBE.Slice(20), s_testExplicitStruct.UL0);
        //    WriteInt16BigEndian(spanBE.Slice(28), s_testExplicitStruct.S1);
        //    WriteInt32BigEndian(spanBE.Slice(30), s_testExplicitStruct.I1);
        //    WriteInt64BigEndian(spanBE.Slice(34), s_testExplicitStruct.L1);
        //    WriteUInt16BigEndian(spanBE.Slice(42), s_testExplicitStruct.US1);
        //    WriteUInt32BigEndian(spanBE.Slice(44), s_testExplicitStruct.UI1);
        //    WriteUInt64BigEndian(spanBE.Slice(48), s_testExplicitStruct.UL1);

        //    Assert.Equal(56, spanBE.Length);
        //    return spanBE;
        //}

        //public static Span<byte> GetSpanLE()
        //{
        //    Span<byte> spanLE = new byte[Unsafe.SizeOf<TestStructExplicit>()];

        //    WriteInt16LittleEndian(spanLE, s_testExplicitStruct.S0);
        //    WriteInt32LittleEndian(spanLE.Slice(2), s_testExplicitStruct.I0);
        //    WriteInt64LittleEndian(spanLE.Slice(6), s_testExplicitStruct.L0);
        //    WriteUInt16LittleEndian(spanLE.Slice(14), s_testExplicitStruct.US0);
        //    WriteUInt32LittleEndian(spanLE.Slice(16), s_testExplicitStruct.UI0);
        //    WriteUInt64LittleEndian(spanLE.Slice(20), s_testExplicitStruct.UL0);
        //    WriteInt16LittleEndian(spanLE.Slice(28), s_testExplicitStruct.S1);
        //    WriteInt32LittleEndian(spanLE.Slice(30), s_testExplicitStruct.I1);
        //    WriteInt64LittleEndian(spanLE.Slice(34), s_testExplicitStruct.L1);
        //    WriteUInt16LittleEndian(spanLE.Slice(42), s_testExplicitStruct.US1);
        //    WriteUInt32LittleEndian(spanLE.Slice(44), s_testExplicitStruct.UI1);
        //    WriteUInt64LittleEndian(spanLE.Slice(48), s_testExplicitStruct.UL1);

        //    Assert.Equal(56, spanLE.Length);
        //    return spanLE;
        //}

        public static string BuildString(int length, int seed)
        {
            Random rnd = new Random(seed);
            var builder = new StringBuilder();
            for (int i = 0; i < length; i++)
            {
                builder.Append((char)rnd.Next(65, 91));
            }
            return builder.ToString();
        }

        [StructLayout(LayoutKind.Explicit)]
        public struct TestStructExplicit
        {
            [FieldOffset(0)]
            public short S0;
            [FieldOffset(2)]
            public int I0;
            [FieldOffset(6)]
            public long L0;
            [FieldOffset(14)]
            public ushort US0;
            [FieldOffset(16)]
            public uint UI0;
            [FieldOffset(20)]
            public ulong UL0;
            [FieldOffset(28)]
            public short S1;
            [FieldOffset(30)]
            public int I1;
            [FieldOffset(34)]
            public long L1;
            [FieldOffset(42)]
            public ushort US1;
            [FieldOffset(44)]
            public uint UI1;
            [FieldOffset(48)]
            public ulong UL1;
        }

        [StructLayout(LayoutKind.Sequential)]
        public sealed class TestClass
        {
            private double _d;
            public char C0;
            public char C1;
            public char C2;
            public char C3;
            public char C4;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct TestValueTypeWithReference
        {
            public int I;
            public string S;
        }

#pragma warning disable 0649 //Field 'SpanTests.InnerStruct.J' is never assigned to, and will always have its default value 0
        internal struct StructWithReferences
        {
            public int I;
            public InnerStruct Inner;
        }

        internal struct InnerStruct
        {
            public int J;
            public object O;
        }
#pragma warning restore 0649 //Field 'SpanTests.InnerStruct.J' is never assigned to, and will always have its default value 0

        public enum TestEnum
        {
            E0,
            E1,
            E2,
            E3,
            E4,
        }

#pragma warning disable LuceneDev4001
        [MethodImpl(MethodImplOptions.NoInlining)]
#pragma warning restore LuceneDev4001
        public static void DoNotIgnore<T>(T value, int consumed)
        {
        }

        //
        // { text, start, length } triplets. A "-1" in start or length means "test the overload that doesn't have that parameter."
        //
        public static IEnumerable<object[]> StringSliceTestData
        {
            get
            {
                foreach (string text in new string[] { string.Empty, "012" })
                {
                    yield return new object[] { text, -1, -1 };
                    for (int start = 0; start <= text.Length; start++)
                    {
                        yield return new object[] { text, start, -1 };

                        for (int length = 0; length <= text.Length - start; length++)
                        {
                            yield return new object[] { text, start, length };
                        }
                    }
                }
            }
        }

        public static IEnumerable<object[]> StringSlice2ArgTestOutOfRangeData
        {
            get
            {
                foreach (string text in new string[] { string.Empty, "012" })
                {
                    yield return new object[] { text, -1 };
                    yield return new object[] { text, int.MinValue };

                    yield return new object[] { text, text.Length + 1 };
                    yield return new object[] { text, int.MaxValue };
                }
            }
        }

        public static IEnumerable<object[]> StringSlice3ArgTestOutOfRangeData
        {
            get
            {
                foreach (string text in new string[] { string.Empty, "012" })
                {
                    yield return new object[] { text, -1, 0 };
                    yield return new object[] { text, int.MinValue, 0 };

                    yield return new object[] { text, text.Length + 1, 0 };
                    yield return new object[] { text, int.MaxValue, 0 };

                    yield return new object[] { text, 0, -1 };
                    yield return new object[] { text, 0, int.MinValue };

                    yield return new object[] { text, 0, text.Length + 1 };
                    yield return new object[] { text, 0, int.MaxValue };

                    yield return new object[] { text, 1, text.Length };
                    yield return new object[] { text, 1, int.MaxValue };

                    yield return new object[] { text, text.Length - 1, 2 };
                    yield return new object[] { text, text.Length - 1, int.MaxValue };

                    yield return new object[] { text, text.Length, 1 };
                    yield return new object[] { text, text.Length, int.MaxValue };
                }
            }
        }

        /// <summary>Creates a <see cref="Memory{T}"/> with the specified values in its backing field.</summary>
        public static Memory<T> DangerousCreateMemory<T>(object obj, int offset, int length)
        {
            Memory<T> mem = default;
            object boxedMemory = mem;

            typeof(Memory<T>).GetField("_object", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(boxedMemory, obj);
            typeof(Memory<T>).GetField("_index", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(boxedMemory, offset);
            typeof(Memory<T>).GetField("_length", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(boxedMemory, length);

            return (Memory<T>)boxedMemory;
        }

        /// <summary>Creates a <see cref="ReadOnlyMemory{T}"/> with the specified values in its backing field.</summary>
        public static ReadOnlyMemory<T> DangerousCreateReadOnlyMemory<T>(object obj, int offset, int length) =>
            DangerousCreateMemory<T>(obj, offset, length);

        //public static TheoryData<string[], bool> ContainsNullData => new TheoryData<string[], bool>()
        //{
        //    { new string[] { "1", null, "2" }, true},
        //    { new string[] { "1", "3", "2" }, false},
        //    { null, false},
        //    { new string[] { "1", null, null }, true},
        //    { new string[] { null, null, null }, true},
        //};

        //public static TheoryData<string[], string[], bool> SequenceEqualsNullData => new TheoryData<string[], string[], bool>()
        //{
        //    { new string[] { "1", null, "2" }, new string[] { "1", null, "2" } , true},
        //    { new string[] { "1", null, "2" }, new string[] { "1", "3", "2" } , false},
        //    { new string[] { "1", null, "2" }, new string[] { null, "3", "2" } , false},
        //    { new string[] { "1", null, "2" }, new string[] { null } , false},
        //    { new string[] { "1", null, "2" }, null , false},

        //    { new string[] { null, "2", "1" }, new string[] { null, "2" } , false},

        //    { null, new string[] { null }, false},
        //    { null, null , true},
        //    { null, new string[] { "1", "3", "2" } , false},
        //    { null, new string[] { "1", null, "2" } , false},

        //    { new string[] { "1", null, null }, new string[] { "1", null, null }, true},
        //    { new string[] { null, null, null }, new string[] { null, null, null }, true},
        //};

        //public static TheoryData<string[], int> IndexOfNullData => new TheoryData<string[], int>()
        //{
        //    { new string[] { "1", null, "2" }, 1},
        //    { new string[] { "1", "3", "2" }, -1},
        //    { null, -1},
        //    { new string[] { "1", null, null }, 1},
        //    { new string[] { null, null, null }, 0},
        //};

        //public static TheoryData<string[], string[], int> IndexOfNullSequenceData => new TheoryData<string[], string[], int>()
        //{
        //    { new string[] { "1", null, "2" }, new string[] { "1", null, "2" }, 0},
        //    { new string[] { "1", null, "2" }, new string[] { null }, 1},
        //    { new string[] { "1", null, "2" }, (string[])null, 0},

        //    { new string[] { "1", "3", "2" }, new string[] { "1", null, "2" }, -1},
        //    { new string[] { "1", "3", "2" }, new string[] { null }, -1},
        //    { new string[] { "1", "3", "2" }, (string[])null, 0},

        //    { null, new string[] { "1", null, "2" }, -1},

        //    { new string[] { "1", null, null }, new string[] { null, null, "2" }, -1},
        //    { new string[] { null, null, null }, new string[] { null, null }, 0},
        //};

        //public static TheoryData<string[], string[], int> IndexOfAnyNullSequenceData => new TheoryData<string[], string[], int>()
        //{
        //    { new string[] { "1", null, "2" }, new string[] { "1", null, "2" }, 0},
        //    { new string[] { "1", null, "2" }, new string[] { null, null }, 1},

        //    { new string[] { "1", null, "2" }, new string[] { "3", null }, 1},
        //    { new string[] { "1", null, "2" }, new string[] { "1", "2" }, 0},
        //    { new string[] { "1", null, "2" }, new string[] { "3", "4" }, -1},

        //    { new string[] { null, null, "2" }, new string[] { "3", null }, 0},
        //    { new string[] { null, null, "2" }, new string[] { null, "1" }, 0},
        //    { new string[] { null, null, "2" }, new string[] { null, "1" }, 0},

        //    { new string[] { "1", "3", "2" }, new string[] { "1", null, "2" }, 0},
        //    { new string[] { "1", "3", "2" }, new string[] { null, null }, -1},

        //    { new string[] { "1", "3", "2" }, new string[] { null, "1" }, 0},

        //    { null, new string[] { "1", null, "2" }, -1},

        //    { new string[] { "1", null, null }, new string[] { null, null, "2" }, 1},
        //    { new string[] { null, null, null }, new string[] { null, null }, 0},

        //    { new string[] { "1", "3", "2" }, null, -1},
        //    { new string[] { "1", null, "2" }, null, -1},
        //};

        //public static TheoryData<string[], int> LastIndexOfNullData => new TheoryData<string[], int>()
        //{
        //    { new string[] { "1", null, "2" }, 1},
        //    { new string[] { "1", "3", "2" }, -1},
        //    { null, -1},
        //    { new string[] { "1", null, null }, 2},
        //    { new string[] { null, null, null }, 2},
        //    { new string[] { null, null, "3" }, 1},
        //};

        //public static TheoryData<string[], string[], int> LastIndexOfNullSequenceData => new TheoryData<string[], string[], int>()
        //{
        //    { new string[] { "1", null, "2" }, new string[] { "1", null, "2" }, 0},
        //    { new string[] { "1", null, "2" }, new string[] { null }, 1},
        //    { new string[] { "1", null, "2" }, (string[])null, 3},

        //    { new string[] { "1", "3", "1" }, new string[] { "1", null, "2" }, -1},
        //    { new string[] { "1", "3", "1" }, new string[] { "1" }, 2},
        //    { new string[] { "1", "3", "1" }, new string[] { null }, -1},
        //    { new string[] { "1", "3", "1" }, (string[])null, 3},

        //    { null, new string[] { "1", null, "2" }, -1},

        //    { new string[] { "1", null, null }, new string[] { null, null, "2" }, -1},
        //    { new string[] { null, null, null }, new string[] { null, null }, 1},
        //};

        //public static TheoryData<string[], string[], int> LastIndexOfAnyNullSequenceData => new TheoryData<string[], string[], int>()
        //{
        //    { new string[] { "1", null, "2" }, new string[] { "1", null, "3" }, 1},
        //    { new string[] { "1", null, "2" }, new string[] { null, null }, 1},
        //    { new string[] { "1", null, "2" }, new string[] { "3", "4" }, -1},
        //    { new string[] { "1", null, "2" }, new string[] { "3", null }, 1},
        //    { new string[] { "1", null, "2" }, new string[] { "1", null }, 1},
        //    { new string[] { "1", null, "2" }, new string[] { null, null }, 1},
        //    { new string[] { "1", null, "2" }, new string[] { "1", "2" }, 2},
        //    { null, new string[] { "1", null, "2" }, -1},

        //    { new string[] { null, null, "2" }, new string[] { "3", null }, 1},
        //    { new string[] { null, null, "2" }, new string[] { null, "1" }, 1},
        //    { new string[] { null, null, "2" }, new string[] { null, "1" }, 1},

        //    { new string[] { "1", "3", "2" }, new string[] { null, "1" }, 0},
        //    { new string[] { "1", "3", "2" }, new string[] { "1", "2", null }, 2},
        //    { new string[] { "1", "3", "2" }, new string[] { null, null }, -1},

        //    { null, new string[] { null, "1" }, -1},

        //    { new string[] { "1", null, null }, new string[] { null, null, "2" }, 2},
        //    { new string[] { null, null, null }, new string[] { null, null }, 2},

        //    { new string[] { "1", null, "2" }, null, -1},
        //    { new string[] { "1", "3", "2" }, null, -1},
        //};
    }

}