using Strata.SqlTools.Breakdowns.Snowflake;

namespace Strata.SqlTools.SqlBreakdown.Tests.Snowflake;

[TestFixture]
public class UpdateBreakdownTests
{
    #region Constructor Tests

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

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

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

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

    #endregion

    #region GetSql Tests

    [Test]
    public void GetSql_RendersUpdateSetWhere()
    {
        // Arrange - Snowflake inherits the SQL Server UPDATE formatter
        var breakdown = new UpdateBreakdown("USERS", "NAME = :NAME", "ID = :ID");

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

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(sql, Does.Contain("UPDATE"));
            Assert.That(sql, Does.Contain("USERS"));
            Assert.That(sql, Does.Contain("SET"));
            Assert.That(sql, Does.Contain("NAME = :NAME"));
            Assert.That(sql, Does.Contain("WHERE"));
        });
    }

    #endregion

    #region Parse Tests

    [Test]
    public void Parse_SnowflakeUpdate_PopulatesClauses()
    {
        // Arrange
        var input = "UPDATE USERS SET NAME = 'BOB' WHERE ID = 1";

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

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

    [Test]
    public void Parse_UpdateWithFrom_PopulatesFromClause()
    {
        // Arrange
        var input = "UPDATE T SET T.NAME = S.NAME FROM TARGET T INNER JOIN SOURCE S ON T.ID = S.ID WHERE S.ACTIVE = 1";

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

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.IsUsingFromClause, Is.True);
            Assert.That(breakdown.FromClause.Clause, Does.Contain("INNER JOIN SOURCE"));
            Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("S.ACTIVE = 1"));
        });
    }

    [Test]
    public void Parse_MicrosoftSqlMode_DelegatesToBase()
    {
        // Act
        var breakdown = UpdateBreakdown.Parse("UPDATE Users SET Name = 'Bob' WHERE Id = 1", isMicrosoftSql: true);

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

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

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

    [Test]
    public void TryParse_MicrosoftSqlMode_ReturnsSnowflakeInstance()
    {
        // Act
        var success = UpdateBreakdown.TryParse("UPDATE Users SET Name = 'Bob'", out var breakdown, isMicrosoftSql: true);

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

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

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

    #endregion
}