using Strata.SqlTools.Breakdowns.Snowflake;

namespace Strata.SqlTools.SqlBreakdown.Tests.Snowflake;

[TestFixture]
public class InsertBreakdownTests
{
    #region Constructor Tests

    [Test]
    public void Constructor_Default_InitializesEmptyClauses()
    {
        // Arrange & Act
        var breakdown = new InsertBreakdown();

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.TableName.Clause, Is.EqualTo(string.Empty));
            Assert.That(breakdown.InsertIntoClause.Clause, Is.EqualTo(string.Empty));
            Assert.That(breakdown.ValuesClause.Clause, Is.EqualTo(string.Empty));
        });
    }

    [Test]
    public void Constructor_WithClauses_SetsProperties()
    {
        // Arrange & Act
        var breakdown = new InsertBreakdown("USERS", "ID, NAME", ":ID, :NAME");

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.TableName.Clause, Is.EqualTo("USERS"));
            Assert.That(breakdown.InsertIntoClause.Clause, Is.EqualTo("ID, NAME"));
            Assert.That(breakdown.ValuesClause.Clause, Is.EqualTo(":ID, :NAME"));
        });
    }

    [Test]
    public void Constructor_WithColumnNames_GeneratesColonPrefixedParameters()
    {
        // Arrange & Act - Snowflake uses :parameter syntax (vs SQL Server's @parameter)
        var breakdown = new InsertBreakdown("USERS", new List<string> { "ID", "NAME" });

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.InsertIntoClause.Clause, Is.EqualTo("[ID],[NAME]"));
            Assert.That(breakdown.ValuesClause.Clause, Is.EqualTo(":ID,:NAME"));
        });
    }

    #endregion

    #region Parse Tests

    [Test]
    public void Parse_SnowflakeInsert_PopulatesClauses()
    {
        // Arrange
        var input = "INSERT INTO USERS (ID, NAME) VALUES (1, 'BOB')";

        // Act
        var breakdown = InsertBreakdown.Parse(input);

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.TableName.Clause, Is.EqualTo("USERS"));
            Assert.That(breakdown.InsertIntoClause.Clause, Is.EqualTo("ID, NAME"));
            Assert.That(breakdown.ValuesClause.Clause, Is.EqualTo("1, 'BOB'"));
        });
    }

    [Test]
    public void Parse_MicrosoftSqlMode_DelegatesToBaseAndSucceeds()
    {
        // Arrange
        var input = "INSERT INTO Users (Id) VALUES (1)";

        // Act
        var breakdown = InsertBreakdown.Parse(input, isMicrosoftSql: true);

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown, Is.InstanceOf<InsertBreakdown>());
            Assert.That(breakdown.TableName.Clause, Is.EqualTo("Users"));
            Assert.That(breakdown.InsertIntoClause.Clause, Is.EqualTo("Id"));
        });
    }

    [Test]
    public void Parse_NullOrWhitespace_ThrowsArgumentNullException()
    {
        // Act & Assert
        Assert.Throws<ArgumentNullException>(() => InsertBreakdown.Parse("  "));
    }

    [Test]
    public void Parse_NotAnInsertStatement_ThrowsFormatException()
    {
        // Act & Assert
        Assert.Throws<FormatException>(() => InsertBreakdown.Parse("SELECT * FROM USERS"));
    }

    [Test]
    public void TryParse_ValidInsert_ReturnsTrue()
    {
        // Act
        var success = InsertBreakdown.TryParse("INSERT INTO USERS (ID) VALUES (1)", out var breakdown);

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(success, Is.True);
            Assert.That(breakdown.TableName.Clause, Is.EqualTo("USERS"));
        });
    }

    [Test]
    public void TryParse_MicrosoftSqlMode_ReturnsSnowflakeInstance()
    {
        // Act
        var success = InsertBreakdown.TryParse("INSERT INTO Users (Id) VALUES (1)", out var breakdown, isMicrosoftSql: true);

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(success, Is.True);
            Assert.That(breakdown, Is.InstanceOf<InsertBreakdown>());
        });
    }

    [Test]
    public void TryParse_WrongPrefix_ReturnsFalse()
    {
        // Act
        var success = InsertBreakdown.TryParse("DELETE FROM USERS", out _, out var error);

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(success, Is.False);
            Assert.That(error, Does.Contain("INSERT INTO"));
        });
    }

    #endregion
}