using Strata.SqlTools.Breakdowns.SqlServer;

namespace Strata.SqlTools.SqlBreakdown.Tests.SqlServer;

[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.FromClause.Clause, Is.EqualTo(string.Empty));
            Assert.That(breakdown.WhereClause.Clause, Is.EqualTo(string.Empty));
            Assert.That(breakdown.IsUsingFromClause, Is.False);
            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"));
            Assert.That(breakdown.IsUsingWhereClause, Is.True);
        });
    }

    #endregion

    #region GetSql Tests

    [Test]
    public void GetSql_WithWhere_RendersUpdateSetWhere()
    {
        // Arrange
        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"));
            Assert.That(sql, Does.Contain("Id = @Id"));
        });
    }

    [Test]
    public void GetSql_WithoutWhere_OmitsWhereKeyword()
    {
        // Arrange
        var breakdown = new UpdateBreakdown("Users", "Name = @Name", string.Empty);

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

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

    [Test]
    public void GetSql_WithFromClause_RendersFromSection()
    {
        // Arrange
        var breakdown = new UpdateBreakdown("u", "u.Name = s.Name", "u.Id = s.Id")
        {
            FromClause = { Clause = "Users u INNER JOIN Staging s ON u.Id = s.Id" }
        };

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

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.IsUsingFromClause, Is.True);
            Assert.That(sql, Does.Contain("FROM"));
            Assert.That(sql, Does.Contain("INNER JOIN Staging"));
        });
    }

    #endregion

    #region Parse Tests

    [Test]
    public void Parse_SimpleUpdate_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 u SET u.Name = s.Name FROM Users u INNER JOIN Staging s ON u.Id = s.Id WHERE s.Active = 1";

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

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.TableName.Clause, Is.EqualTo("u"));
            Assert.That(breakdown.IsUsingFromClause, Is.True);
            Assert.That(breakdown.FromClause.Clause, Does.Contain("INNER JOIN Staging"));
            Assert.That(breakdown.WhereClause.Clause, Is.EqualTo("s.Active = 1"));
        });
    }

    [Test]
    public void Parse_UpdateWithoutWhere_LeavesWhereEmpty()
    {
        // Arrange
        var input = "UPDATE Users SET Name = 'Bob'";

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

        Assert.Multiple(() =>
        {
            // Assert
            Assert.That(breakdown.SetClause.Clause, Is.EqualTo("Name = 'Bob'"));
            Assert.That(breakdown.IsUsingWhereClause, Is.False);
        });
    }

    [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("DELETE FROM Users"));
    }

    [Test]
    public void TryParse_WrongPrefix_ReturnsFalseWithMessage()
    {
        // Act
        var success = UpdateBreakdown.TryParse("SELECT * FROM Users", out _, out var error);

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

    [Test]
    public void TryParse_ValidUpdate_ReturnsTrue()
    {
        // Act
        var success = UpdateBreakdown.TryParse("UPDATE Users SET Name = 'Bob' WHERE Id = 1", out var breakdown);

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

    #endregion
}