sql-utilities/tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/RecursiveCTETests.cs

using Strata.SqlTools.Breakdowns.PostgreSql;
using Strata.SqlTools.SqlBreakdown.Classes;

namespace Strata.SqlTools.SqlBreakdown.Tests.PostgreSql;

[TestFixture]
public class RecursiveCTETests
{
    #region Recursive CTE Structure Tests

    [Test]
    public void RecursiveCTE_WithIsRecursiveTrue_CreatesRecursiveStructure()
    {
        // Arrange
        var anchorQuery = new QueryBreakdown(
            "employee_id, manager_id, name, 1 as level",
            "employees",
            "manager_id IS NULL"
        );

        var recursiveQuery = new QueryBreakdown(
            "e.employee_id, e.manager_id, e.name, org.level + 1",
            "employees e INNER JOIN org_hierarchy org ON e.manager_id = org.employee_id"
        );

        var withClause = new WithClause("org_hierarchy", anchorQuery)
        {
            IsRecursive = true,
            RecursiveQuery = recursiveQuery
        };

        // Act
        var isRecursive = withClause.IsRecursive;
        var hasRecursiveQuery = withClause.RecursiveQuery != null;

        // Assert
        Assert.That(isRecursive, Is.True);
        Assert.That(hasRecursiveQuery, Is.True);
    }

    [Test]
    public void GetSql_WithRecursiveCTE_GeneratesRecursiveKeyword()
    {
        // Arrange
        var anchorQuery = new QueryBreakdown("id, manager_id, name, 1 as level", "employees", "manager_id IS NULL");
        var recursiveQuery = new QueryBreakdown(
            "e.id, e.manager_id, e.name, h.level + 1",
            "employees e INNER JOIN org_hierarchy h ON e.manager_id = h.id"
        );

        var mainQuery = new QueryBreakdown("*", "org_hierarchy");
        var withClause = new WithClause("org_hierarchy", anchorQuery)
        {
            IsRecursive = true,
            RecursiveQuery = recursiveQuery
        };
        mainQuery.AddWithClause(withClause);

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

        // Assert
        Assert.That(sql, Contains.Substring("WITH RECURSIVE"), "SQL should contain WITH RECURSIVE keyword");
    }

    [Test]
    public void GetSql_WithRecursiveCTE_ContainsUnionAll()
    {
        // Arrange
        var anchorQuery = new QueryBreakdown("id, parent_id, value", "nodes", "parent_id IS NULL");
        var recursiveQuery = new QueryBreakdown(
            "c.id, c.parent_id, c.value",
            "nodes c INNER JOIN tree t ON c.parent_id = t.id"
        );

        var mainQuery = new QueryBreakdown("*", "tree");
        var withClause = new WithClause("tree", anchorQuery)
        {
            IsRecursive = true,
            RecursiveQuery = recursiveQuery
        };
        mainQuery.AddWithClause(withClause);

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

        // Assert
        Assert.That(sql, Contains.Substring("UNION ALL"), "Recursive CTE should contain UNION ALL");
    }

    [Test]
    public void GetSql_WithNonRecursiveCTE_DoesNotGenerateRecursiveKeyword()
    {
        // Arrange
        var cte = new QueryBreakdown("id, name", "employees", "status = 'active'");
        var mainQuery = new QueryBreakdown("*", "active_employees");

        var withClause = new WithClause("active_employees", cte)
        {
            IsRecursive = false  // Explicitly non-recursive
        };
        mainQuery.AddWithClause(withClause);

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

        // Assert
        Assert.That(sql, Contains.Substring("WITH"), "SQL should contain WITH keyword");
        Assert.That(sql, Does.Not.Contain("WITH RECURSIVE"), "Non-recursive CTE should not have RECURSIVE keyword");
    }

    #endregion

    #region Recursive CTE Parameter Tests

    [Test]
    public void GetMergedParameters_WithRecursiveCTE_MergesAnchorAndRecursiveParams()
    {
        // Arrange
        var anchorQuery = new QueryBreakdown("id, manager_id, name", "employees", "manager_id IS NULL");
        anchorQuery.AddParameter("AnchorStatus", "active");

        var recursiveQuery = new QueryBreakdown(
            "e.id, e.manager_id, e.name",
            "employees e INNER JOIN org_hierarchy h ON e.manager_id = h.id",
            "e.status = 'active'"
        );
        recursiveQuery.AddParameter("RecursiveLevel", 10);
        recursiveQuery.AddParameter("RecursiveStatus", "active");

        var mainQuery = new QueryBreakdown("*", "org_hierarchy");
        mainQuery.AddParameter("MainLimit", 100);

        var withClause = new WithClause("org_hierarchy", anchorQuery)
        {
            IsRecursive = true,
            RecursiveQuery = recursiveQuery
        };
        mainQuery.AddWithClause(withClause);

        // Act
        var merged = mainQuery.GetMergedParameters();

        // Assert
        var keys = merged.Keys.ToList();
        Assert.That(keys.Any(k => k.Contains("AnchorStatus")), "Should include anchor query parameters");
        Assert.That(keys.Any(k => k.Contains("RecursiveLevel")), "Should include recursive query parameters");
        Assert.That(keys.Any(k => k.Contains("RecursiveStatus")), "Should include recurring query parameters");
        Assert.That(keys.Any(k => k.Contains("MainLimit")), "Should include main query parameters");
    }

    [Test]
    [Ignore("Pre-existing: parameter key search needs refinement for positional $ parameters")]
    public void GetMergedParameters_WithRecursiveCTE_MainQueryParamTakesPrecedence()
    {
        // Arrange
        var anchorQuery = new QueryBreakdown("id, name", "employees");
        anchorQuery.AddParameter("Status", "inactive"); // CTE version

        var recursiveQuery = new QueryBreakdown("e.id, e.name", "employees e");
        recursiveQuery.AddParameter("Status", "inactive"); // Recursive version

        var mainQuery = new QueryBreakdown("*", "hierarchy");
        mainQuery.AddParameter("Status", "active"); // Main query version (should win)

        var withClause = new WithClause("hierarchy", anchorQuery)
        {
            IsRecursive = true,
            RecursiveQuery = recursiveQuery
        };
        mainQuery.AddWithClause(withClause);

        // Act
        var merged = mainQuery.GetMergedParameters();

        // Assert
        // PostgreSQL stores parameters with positional syntax
        var statusKey = merged.Keys.FirstOrDefault(k => k.Contains("Status") && !k.StartsWith('$'));
        Assert.That(statusKey, Is.Not.Null);
        Assert.That(merged[statusKey], Is.EqualTo("active"), "Main query parameter should take precedence");
    }

    #endregion

    #region Complex Recursive CTE Tests

    [Test]
    public void GetSql_WithMultipleRecursiveCTEs_GeneratesAllRecursiveClauses()
    {
        // Arrange
        // First recursive CTE: Employee hierarchy
        var emp_anchor = new QueryBreakdown("id, manager_id, name, 1 as level", "employees", "manager_id IS NULL");
        var emp_recursive = new QueryBreakdown(
            "e.id, e.manager_id, e.name, h.level + 1",
            "employees e INNER JOIN emp_hierarchy h ON e.manager_id = h.id"
        );
        var emp_withClause = new WithClause("emp_hierarchy", emp_anchor)
        {
            IsRecursive = true,
            RecursiveQuery = emp_recursive
        };

        // Second CTE: Department hierarchy (non-recursive)
        var dept_cte = new QueryBreakdown("id, name", "departments", "active = 1");
        var dept_withClause = new WithClause("dept_list", dept_cte)
        {
            IsRecursive = false
        };

        var mainQuery = new QueryBreakdown("*", "results");
        mainQuery.AddWithClause(emp_withClause);
        mainQuery.AddWithClause(dept_withClause);

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

        // Assert
        Assert.That(sql, Contains.Substring("WITH RECURSIVE"), "Should have RECURSIVE keyword for mixed CTEs");
        Assert.That(sql, Contains.Substring("emp_hierarchy AS"), "Should have first CTE");
        Assert.That(sql, Contains.Substring("dept_list AS"), "Should have second CTE");
    }

    [Test]
    public void RecursiveCTE_WithMixedRecursiveAndNonRecursive_MixedStructureWorks()
    {
        // Arrange
        var nonRecursiveCte = new QueryBreakdown("id, name", "base_data");
        var withClause1 = new WithClause("base", nonRecursiveCte) { IsRecursive = false };

        var anchor = new QueryBreakdown("id, parent_id", "tree_data", "parent_id IS NULL");
        var recursive = new QueryBreakdown(
            "t.id, t.parent_id",
            "tree_data t INNER JOIN tree_hierarchy h ON t.parent_id = h.id"
        );
        var withClause2 = new WithClause("tree_hierarchy", anchor)
        {
            IsRecursive = true,
            RecursiveQuery = recursive
        };

        var mainQuery = new QueryBreakdown("*", "results");
        mainQuery.AddWithClause(withClause1);
        mainQuery.AddWithClause(withClause2);

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

        // Assert
        Assert.That(sql, Contains.Substring("WITH RECURSIVE"));
        Assert.That(sql, Does.Contain("base AS"), "Non-recursive CTE should be included");
        Assert.That(sql, Does.Contain("tree_hierarchy AS"), "Recursive CTE should be included");
    }

    [Test]
    public void RecursiveCTE_WithoutRecursiveQuery_UsesOnlyAnchor()
    {
        // Arrange
        var anchorQuery = new QueryBreakdown("id, name", "employees");
        var withClause = new WithClause("employees_cte", anchorQuery)
        {
            IsRecursive = true,
            RecursiveQuery = null  // No recursive query provided
        };

        var mainQuery = new QueryBreakdown("*", "results");
        mainQuery.AddWithClause(withClause);

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

        // Assert
        // Should still generate WITH RECURSIVE (IsRecursive = true)
        // but only include the anchor query
        Assert.That(sql, Contains.Substring("WITH RECURSIVE"));
        Assert.That(sql, Contains.Substring("employees_cte AS"));
    }

    #endregion

    #region Recursive CTE Edge Cases

    [Test]
    public void RecursiveCTE_IsRecursiveProperty_CanBeToggled()
    {
        // Arrange
        var cte = new QueryBreakdown("id, name", "data");
        var withClause = new WithClause("cte_name", cte);

        // Act & Assert
        Assert.That(withClause.IsRecursive, Is.False, "Default should be non-recursive");

        withClause.IsRecursive = true;
        Assert.That(withClause.IsRecursive, Is.True, "Should be toggleable to recursive");

        withClause.IsRecursive = false;
        Assert.That(withClause.IsRecursive, Is.False, "Should be toggleable back to non-recursive");
    }

    [Test]
    public void RecursiveCTE_RecursiveQueryProperty_CanBeSet()
    {
        // Arrange
        var anchor = new QueryBreakdown("id, parent", "data");
        var recursive = new QueryBreakdown("c.id, c.parent", "data c INNER JOIN tree h ON c.parent = h.id");

        var withClause = new WithClause("tree", anchor);

        // Act
        Assert.That(withClause.RecursiveQuery, Is.Null, "Should start as null");

        withClause.IsRecursive = true;
        withClause.RecursiveQuery = recursive;

        // Assert
        Assert.That(withClause.RecursiveQuery, Is.EqualTo(recursive));
    }

    #endregion
}