using System.Collections;
using Strata.SqlTools.SqlBreakdown.Utilities;

namespace Strata.SqlTools.SqlBreakdown.Tests.Utilities;

[TestFixture]
public class ArrayUtilsTests
{
    private static readonly Guid GuidA = new("11111111-1111-1111-1111-111111111111");
    private static readonly Guid GuidB = new("22222222-2222-2222-2222-222222222222");
    private static readonly Guid GuidC = new("33333333-3333-3333-3333-333333333333");

    #region NewArray / Coalesce

    [Test]
    public void NewArray_ReturnsArrayOfValues()
    {
        // Act
        var result = ArrayUtils.NewArray(1, 2, 3);

        // Assert
        Assert.That(result, Is.EqualTo(new[] { 1, 2, 3 }));
    }

    [Test]
    public void Coalesce_ReturnsFirstNonNull()
    {
        // Act & Assert
        Assert.That(ArrayUtils.Coalesce(null!, null!, "x", "y"), Is.EqualTo("x"));
    }

    [Test]
    public void Coalesce_AllNull_ReturnsNull()
    {
        // Act & Assert
        Assert.That(ArrayUtils.Coalesce(null!, null!), Is.Null);
    }

    #endregion

    #region CSV -> Collection

    [Test]
    public void GetArrayListFromCsv_TrimsAndSplits()
    {
        // Act
        var result = ArrayUtils.GetArrayListFromCsv("a, b, c");

        // Assert
        Assert.That(result, Is.EqualTo(new ArrayList { "a", "b", "c" }));
    }

    [Test]
    public void GetArrayListFromCsv_Empty_ReturnsEmptyList()
    {
        // Act & Assert
        Assert.That(ArrayUtils.GetArrayListFromCsv(string.Empty), Is.Empty);
    }

    [Test]
    public void GetGenericListFromCsv_TrimsEntries()
    {
        // Act
        var result = ArrayUtils.GetGenericListFromCsv("a, b ,c");

        // Assert
        Assert.That(result, Is.EqualTo(new List<string> { "a", "b", "c" }));
    }

    [Test]
    public void GetGenericListFromCsv_Empty_ReturnsEmpty()
    {
        // Act & Assert
        Assert.That(ArrayUtils.GetGenericListFromCsv(string.Empty), Is.Empty);
    }

    [Test]
    public void GetIntegerListFromCsv_SkipsNonIntegers()
    {
        // Act
        var result = ArrayUtils.GetIntegerListFromCsv("1,2,x,3");

        // Assert
        Assert.That(result, Is.EqualTo(new List<int> { 1, 2, 3 }));
    }

    [Test]
    public void GetGuidListFromCsv_ParsesValidSkipsInvalid()
    {
        // Act
        var result = ArrayUtils.GetGuidListFromCsv($"{GuidA},not-a-guid,{GuidB}");

        // Assert
        Assert.That(result, Is.EqualTo(new List<Guid> { GuidA, GuidB }));
    }

    [Test]
    public void GetGuidListFromCsv_Empty_ReturnsEmpty()
    {
        // Act & Assert
        Assert.That(ArrayUtils.GetGuidListFromCsv(string.Empty), Is.Empty);
    }

    [Test]
    public void GetGuidArrayFromCsv_ParsesGuids()
    {
        // Act
        var result = ArrayUtils.GetGuidArrayFromCsv($"{GuidA},{GuidB}");

        // Assert
        Assert.That(result, Is.EqualTo(new[] { GuidA, GuidB }));
    }

    #endregion

    #region Collection -> CSV

    [Test]
    public void GetCsvFromArrayList_JoinsWithCommas()
    {
        // Act
        var result = ArrayUtils.GetCsvFromArrayList(new ArrayList { "a", "b", "c" });

        // Assert
        Assert.That(result, Is.EqualTo("a,b,c"));
    }

    [Test]
    public void GetCsvFromGenericList_JoinsWithCommas()
    {
        // Act & Assert
        Assert.That(ArrayUtils.GetCsvFromGenericList(new List<string> { "a", "b" }), Is.EqualTo("a,b"));
    }

    [Test]
    public void GetCsvFromGenericList_SingleQuotes_WrapsEachValue()
    {
        // Act
        var result = ArrayUtils.GetCsvFromGenericList(new List<string> { "a", "b" }, ArrayUtils.QuoteType.Single);

        // Assert
        Assert.That(result, Is.EqualTo("'a','b'"));
    }

    [Test]
    public void GetCsvFromGenericList_DoubleQuotes_WrapsEachValue()
    {
        // Act
        var result = ArrayUtils.GetCsvFromGenericList(new List<string> { "a", "b" }, ArrayUtils.QuoteType.Double);

        // Assert
        Assert.That(result, Is.EqualTo("\"a\",\"b\""));
    }

    [Test]
    public void GetCsvFromGenericList_NoneQuoteType_BehavesLikePlainJoin()
    {
        // Act & Assert
        Assert.That(ArrayUtils.GetCsvFromGenericList(new List<string> { "a", "b" }, ArrayUtils.QuoteType.None), Is.EqualTo("a,b"));
    }

    [Test]
    public void GetCsvFromGenericListOfGuids_Null_ReturnsEmpty()
    {
        // Act & Assert
        Assert.That(ArrayUtils.GetCsvFromGenericListOfGuids(null!), Is.EqualTo(string.Empty));
    }

    [Test]
    public void GetCsvFromGenericListOfGuids_NoQuotes_JoinsGuids()
    {
        // Act
        var result = ArrayUtils.GetCsvFromGenericListOfGuids(new List<Guid> { GuidA, GuidB });

        // Assert
        Assert.That(result, Is.EqualTo($"{GuidA},{GuidB}"));
    }

    [Test]
    public void GetCsvFromGenericListOfGuids_SingleQuotes_WrapsEachGuid()
    {
        // Act
        var result = ArrayUtils.GetCsvFromGenericListOfGuids(new List<Guid> { GuidA }, ArrayUtils.QuoteType.Single);

        // Assert
        Assert.That(result, Is.EqualTo($"'{GuidA}'"));
    }

    #endregion

    #region Encode

    [Test]
    public void Encode_NoInternalDelimiters_JoinsWithCommas()
    {
        // Act & Assert
        Assert.That(ArrayUtils.Encode(new List<string> { "x", "y", "z" }), Is.EqualTo("x,y,z"));
    }

    [Test]
    public void Encode_InternalComma_ReplacedWithIllegalCharacter()
    {
        // Arrange - internal commas are swapped for char(8) so they survive the comma join
        const char illegal = (char)8;

        // Act
        var result = ArrayUtils.Encode(new List<string> { "a,b", "c" });

        // Assert
        Assert.That(result, Is.EqualTo($"a{illegal}b,c"));
    }

    #endregion

    #region Guid List <-> String

    [Test]
    public void ConvertGuidStringToList_Empty_ReturnsEmpty()
    {
        // Act & Assert
        Assert.That(ArrayUtils.ConvertGuidStringToList(string.Empty), Is.Empty);
    }

    [Test]
    public void ConvertGuidStringToList_ParsesAll()
    {
        // Act
        var result = ArrayUtils.ConvertGuidStringToList($"{GuidA},{GuidB}");

        // Assert
        Assert.That(result, Is.EqualTo(new List<Guid> { GuidA, GuidB }));
    }

    [Test]
    public void ConvertToGuidArray_ParsesStrings()
    {
        // Act
        var result = ArrayUtils.ConvertToGuidArray(new[] { GuidA.ToString(), GuidB.ToString() });

        // Assert
        Assert.That(result, Is.EqualTo(new[] { GuidA, GuidB }));
    }

    [Test]
    public void ConvertToGuidList_ParsesStrings()
    {
        // Act
        var result = ArrayUtils.ConvertToGuidList(new[] { GuidA.ToString() });

        // Assert
        Assert.That(result, Is.EqualTo(new List<Guid> { GuidA }));
    }

    [Test]
    public void ConvertGuidListToString_Null_ReturnsEmpty()
    {
        // Act & Assert
        Assert.That(ArrayUtils.ConvertGuidListToString(null!), Is.EqualTo(string.Empty));
    }

    [Test]
    public void ConvertGuidListToString_NoSurround_JoinsWithCommas()
    {
        // Act & Assert
        Assert.That(ArrayUtils.ConvertGuidListToString(new[] { GuidA, GuidB }), Is.EqualTo($"{GuidA},{GuidB}"));
    }

    [Test]
    public void ConvertGuidListToString_WithSurroundChar_WrapsEachGuid()
    {
        // Act
        var result = ArrayUtils.ConvertGuidListToString(new[] { GuidA }, "'");

        // Assert
        Assert.That(result, Is.EqualTo($"'{GuidA}'"));
    }

    [Test]
    public void ConvertGuidListToStringList_ReturnsStringRepresentations()
    {
        // Act
        var result = ArrayUtils.ConvertGuidListToStringList(new[] { GuidA, GuidB });

        // Assert
        Assert.That(result, Is.EqualTo(new List<string> { GuidA.ToString(), GuidB.ToString() }));
    }

    #endregion

    #region Intersection

    [Test]
    public void GetGuidListsIntersection_ReturnsCommonGuids()
    {
        // Act
        var result = ArrayUtils.GetGuidListsIntersection(
            new List<Guid> { GuidA, GuidB },
            new List<Guid> { GuidB, GuidC });

        // Assert
        Assert.That(result, Is.EqualTo(new List<Guid> { GuidB }));
    }

    [Test]
    public void GetGuidListsIntersection_NoOverlap_ReturnsEmpty()
    {
        // Act
        var result = ArrayUtils.GetGuidListsIntersection(
            new List<Guid> { GuidA },
            new List<Guid> { GuidB });

        // Assert
        Assert.That(result, Is.Empty);
    }

    [Test]
    public void GetGuidListsIntersection_NullArguments_ReturnEmpty()
    {
        // Act & Assert
        Assert.That(ArrayUtils.GetGuidListsIntersection(null!, null!), Is.Empty);
    }

    #endregion
}