using Strata.SqlTools.Breakdowns.SqlServer;

namespace Strata.SqlTools.SqlBreakdown.Tests.SqlServer;

[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));
            Assert.That(breakdown.SetupClauses, Is.Empty);
            Assert.That(breakdown.FinishClauses, Is.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_WithClauses_ExtractsComments()
    {
        // Arrange & Act
        var breakdown = new InsertBreakdown("Users /* target */", "Id, Name", "@Id, @Name");

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.TableName.Clause, Is.EqualTo("Users"));
            Assert.That(breakdown.TableName.Comment, Does.Contain("target"));
        });
    }

    [Test]
    public void Constructor_WithColumnNames_GeneratesBracketedColumnsAndAtParameters()
    {
        // Arrange & Act
        var breakdown = new InsertBreakdown("Users", new List<string> { "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"));
        });
    }

    #endregion

    #region GetSql Tests

    [Test]
    public void GetSql_RendersInsertIntoTableColumnsValues()
    {
        // Arrange
        var breakdown = new InsertBreakdown("Users", "Id, Name", "@Id, @Name");

        // Act
        var sql = breakdown.GetSql();

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(sql, Does.Contain("INSERT INTO"));
            Assert.That(sql, Does.Contain("Users"));
            Assert.That(sql, Does.Contain("Id, Name"));
            Assert.That(sql, Does.Contain("VALUES"));
            Assert.That(sql, Does.Contain("@Id, @Name"));
        });
    }

    [Test]
    public void ToString_ReturnsGeneratedSql()
    {
        // Arrange
        var breakdown = new InsertBreakdown("Users", "Id", "@Id");

        // Act & Assert
        Assert.That(breakdown.ToString(), Does.Contain("INSERT INTO"));
    }

    #endregion

    #region Parse Tests

    [Test]
    public void Parse_ValidInsert_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_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_WrongPrefix_ReturnsFalseWithMessage()
    {
        // Act
        var success = InsertBreakdown.TryParse("UPDATE Users SET Id = 1", out _, out var error);

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

    [Test]
    public void TryParse_MalformedInsert_ReturnsFalse()
    {
        // Act - matches the INSERT INTO prefix but not the column/values grammar
        var success = InsertBreakdown.TryParse("INSERT INTO Users", out _, out var error);

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(success, Is.False);
            Assert.That(error, Is.Not.Null.And.Not.Empty);
        });
    }

    [Test]
    public void GetSql_IncludeSetupFinish_RendersSetupAndFinishClauses()
    {
        // Arrange
        var breakdown = new InsertBreakdown("Users", "Id", "@Id")
        {
            SetupClauses = { "SET NOCOUNT ON" },
            FinishClauses = { "SELECT SCOPE_IDENTITY()" }
        };

        // Act
        var withClauses = breakdown.GetSql(includeSetupFinish: true);
        var withoutClauses = breakdown.GetSql(includeSetupFinish: false);

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(withClauses, Does.Contain("SET NOCOUNT ON"));
            Assert.That(withClauses, Does.Contain("SELECT SCOPE_IDENTITY()"));
            Assert.That(withClauses, Does.Contain("INSERT INTO"));
            Assert.That(withoutClauses, Does.Not.Contain("SET NOCOUNT ON"));
            Assert.That(withoutClauses, Does.Not.Contain("SELECT SCOPE_IDENTITY()"));
        });
    }

    #endregion
}