using Strata.SqlTools.Breakdowns.Snowflake;

namespace Strata.SqlTools.SqlBreakdown.Tests.Snowflake;

[TestFixture]
public class DeleteBreakdownTests
{
    #region Constructor Tests

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

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

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

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.FromClause.Clause, Is.EqualTo("USERS"));
            Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("ID = :ID"));
            Assert.That(breakdown.IsUsingWhereClause, Is.True);
        });
    }

    #endregion

    #region GetSql Tests

    [Test]
    public void GetSql_WithWhere_RendersDeleteFromWhere()
    {
        // Arrange - Snowflake overrides the formatter with simplified DELETE FROM syntax
        var breakdown = new DeleteBreakdown("USERS", "ID = :ID");

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

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(sql, Does.Contain("DELETE FROM"));
            Assert.That(sql, Does.Contain("USERS"));
            Assert.That(sql, Does.Contain("WHERE"));
            Assert.That(sql, Does.Contain("ID = :ID"));
        });
    }

    [Test]
    public void GetSql_WithoutWhere_OmitsWhereKeyword()
    {
        // Arrange
        var breakdown = new DeleteBreakdown("USERS", string.Empty);

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

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(sql, Does.Contain("DELETE FROM"));
            Assert.That(sql, Does.Not.Contain("WHERE"));
        });
    }

    #endregion

    #region Parse Tests

    [Test]
    public void Parse_SnowflakeDelete_PopulatesClauses()
    {
        // Arrange
        var input = "DELETE FROM USERS WHERE ID = 1";

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

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.FromClause.Clause, Is.EqualTo("USERS"));
            Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("ID = 1"));
        });
    }

    [Test]
    public void Parse_DeleteWithoutWhere_LeavesWhereEmpty()
    {
        // Act
        var breakdown = DeleteBreakdown.Parse("DELETE FROM USERS");

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.FromClause.Clause, Is.EqualTo("USERS"));
            Assert.That(breakdown.IsUsingWhereClause, Is.False);
        });
    }

    [Test]
    public void Parse_MicrosoftSqlMode_DelegatesToBase()
    {
        // Act - T-SQL DELETE with alias is supported through the base breakdown
        var breakdown = DeleteBreakdown.Parse("DELETE FROM Users WHERE Id = 1", isMicrosoftSql: true);

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

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

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

    [Test]
    public void TryParse_MicrosoftSqlMode_ReturnsSnowflakeInstance()
    {
        // Act
        var success = DeleteBreakdown.TryParse("DELETE FROM Users WHERE Id = 1", out var breakdown, isMicrosoftSql: true);

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

    [Test]
    public void TryParse_WrongPrefix_ReturnsFalse()
    {
        // Act
        var success = DeleteBreakdown.TryParse("UPDATE USERS SET ID = 1", out _, out var error);

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

    #endregion
}