using System.Runtime.Serialization;
using System.Text;
using Strata.SqlTools.SqlBreakdown.Classes;
using Strata.SqlTools.SqlBreakdown.Interfaces;

namespace Strata.SqlTools.Breakdowns.Snowflake;

/// <summary>
/// Snowflake SQL-specific collection for managing multiple QueryBreakdown objects.
/// </summary>
/// <remarks>
/// This class extends SqlBreakdownCollection with Snowflake-specific functionality,
/// including support for Snowflake features like semi-structured data, stage references,
/// time travel, snowflake-specific parameters (:parameter and @parameter syntax),
/// and proper batch handling.
/// </remarks>
[Serializable]
public class QueryBreakdownCollection : SqlBreakdownCollection
{
    private readonly List<QueryBreakdown> _queryBreakdowns;

    /// <summary>
    /// Initializes a new instance of the <see cref="QueryBreakdownCollection"/> class for Snowflake.
    /// </summary>
    public QueryBreakdownCollection() : base()
    {
        _queryBreakdowns = new List<QueryBreakdown>();
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="QueryBreakdownCollection"/> class with initial query breakdowns.
    /// </summary>
    /// <param name="queryBreakdowns">The initial collection of query breakdowns.</param>
    public QueryBreakdownCollection(IEnumerable<QueryBreakdown> queryBreakdowns)
        : base(queryBreakdowns?.Cast<ISqlBreakdown>() ?? Enumerable.Empty<ISqlBreakdown>())
    {
        _queryBreakdowns = new List<QueryBreakdown>(queryBreakdowns ?? Enumerable.Empty<QueryBreakdown>());
    }

    /// <summary>
    /// Validates that the backing list survived deserialization, since deserialization bypasses
    /// the constructors that normally initialize it (SonarQube rule S5766).
    /// </summary>
    /// <param name="context">The streaming context for the deserialization operation.</param>
    [OnDeserialized]
    private void OnDeserialized(StreamingContext context)
    {
        if (_queryBreakdowns is null)
        {
            throw new SerializationException("Deserialized QueryBreakdownCollection is missing its backing list.");
        }
    }

    /// <summary>
    /// Gets the collection of QueryBreakdown objects.
    /// </summary>
    public IReadOnlyList<QueryBreakdown> QueryBreakdowns => _queryBreakdowns.AsReadOnly();

    /// <summary>
    /// Adds a QueryBreakdown to the collection.
    /// </summary>
    /// <param name="queryBreakdown">The query breakdown to add.</param>
    /// <exception cref="ArgumentNullException">Thrown when queryBreakdown is null.</exception>
    public void Add(QueryBreakdown queryBreakdown)
    {
        if (queryBreakdown == null)
        {
            throw new ArgumentNullException(nameof(queryBreakdown));
        }

        _queryBreakdowns.Add(queryBreakdown);
        base.Add(queryBreakdown);
    }

    /// <summary>
    /// Adds multiple QueryBreakdowns to the collection.
    /// </summary>
    /// <param name="queryBreakdowns">The query breakdowns to add.</param>
    /// <exception cref="ArgumentNullException">Thrown when queryBreakdowns is null.</exception>
    public void AddRange(IEnumerable<QueryBreakdown> queryBreakdowns)
    {
        if (queryBreakdowns == null)
        {
            throw new ArgumentNullException(nameof(queryBreakdowns));
        }

        foreach (var breakdown in queryBreakdowns)
        {
            Add(breakdown);
        }
    }

    /// <summary>
    /// Removes a QueryBreakdown from the collection.
    /// </summary>
    /// <param name="queryBreakdown">The query breakdown to remove.</param>
    /// <returns>True if removed; otherwise, false.</returns>
    public bool Remove(QueryBreakdown queryBreakdown)
    {
        var removed = _queryBreakdowns.Remove(queryBreakdown);
        if (removed)
        {
            base.Remove(queryBreakdown);
        }
        return removed;
    }

    /// <summary>
    /// Clears all query breakdowns from the collection.
    /// </summary>
    public new void Clear()
    {
        _queryBreakdowns.Clear();
        base.Clear();
    }

    /// <summary>
    /// Gets the Snowflake SQL batch representation with Snowflake-specific formatting.
    /// </summary>
    /// <remarks>
    /// Generates Snowflake SQL with proper statement separation and optional session setup.
    /// Snowflake uses semicolons as statement separators instead of GO.
    /// </remarks>
    /// <param name="includeSetupFinish">Whether to include setup and finish clauses.</param>
    /// <param name="includeSessionSetup">Whether to include session context setup statements.</param>
    /// <returns>The formatted Snowflake SQL batch.</returns>
    public string GetSnowflakeBatch(bool includeSetupFinish = true, bool includeSessionSetup = false)
    {
        var sb = new StringBuilder();

        // Add session setup if requested
        if (includeSessionSetup)
        {
            sb.AppendLine("-- Snowflake Session Setup");
            sb.AppendLine("ALTER SESSION SET NULLABLE_AS_NULL = FALSE;");
            sb.AppendLine("ALTER SESSION SET ERROR_ON_NONDETERMINISTIC_UPDATE = FALSE;");
            sb.AppendLine();
        }

        // Add all queries with semicolon separators
        if (_queryBreakdowns.Count > 0)
        {
            for (int i = 0; i < _queryBreakdowns.Count; i++)
            {
                var query = _queryBreakdowns[i];
                var sql = query.GetSql(includeSetupFinish);

                // Ensure proper termination
                var trimmed = sql.TrimEnd();
                sb.Append(trimmed);

                if (!trimmed.EndsWith(';'))
                {
                    sb.Append(";");
                }

                // Add spacing between statements
                if (i < _queryBreakdowns.Count - 1)
                {
                    sb.AppendLine();
                    sb.AppendLine();
                }
            }
        }

        return sb.ToString();
    }

    /// <summary>
    /// Filters queries that reference Snowflake stages (using @ or @~ syntax).
    /// </summary>
    /// <remarks>
    /// Stage references use the pattern @stage_name/ or @~/stage_name/.
    /// This specifically matches stage references and avoids false positives from @parameter syntax.
    /// </remarks>
    /// <param name="stageName">Optional stage name to filter by. If null, returns all queries using any stage.</param>
    /// <returns>Query breakdowns that reference stages.</returns>
    public IEnumerable<QueryBreakdown> WhereUseStageReference(string? stageName = null)
    {
        return _queryBreakdowns.Where(q =>
        {
            var sql = q.GetSql();

            // Use regex to match stage references: @stage_name/ or @~/stage_name/
            // This avoids false positives from @parameter syntax
            var stagePattern = @"@[\w~]+/";

            if (!System.Text.RegularExpressions.Regex.IsMatch(sql, stagePattern, System.Text.RegularExpressions.RegexOptions.None, Strata.SqlTools.SqlBreakdown.Utilities.RegexDefaults.MatchTimeout))
            {
                return false;
            }

            if (stageName == null)
            {
                return true;
            }

            var specificPattern = stageName.Contains("~")
                ? $@"@~/{System.Text.RegularExpressions.Regex.Escape(stageName.TrimStart('@', '~', '/'))}/"
                : $@"@{System.Text.RegularExpressions.Regex.Escape(stageName.TrimStart('@'))}/";

            return System.Text.RegularExpressions.Regex.IsMatch(sql, specificPattern, System.Text.RegularExpressions.RegexOptions.IgnoreCase, Strata.SqlTools.SqlBreakdown.Utilities.RegexDefaults.MatchTimeout);
        });
    }

    /// <summary>
    /// Filters queries that reference JSON/semi-structured data using Snowflake's JSON operators.
    /// </summary>
    /// <returns>Query breakdowns that use JSON functions or colon notation.</returns>
    public IEnumerable<QueryBreakdown> WhereUseSemiStructuredData()
    {
        return _queryBreakdowns.Where(q =>
        {
            var sql = q.GetSql().ToUpperInvariant();

            // Check for JSON functions or colon notation used in semi-structured data
            return sql.Contains("JSON_") ||
                   sql.Contains("OBJECT_") ||
                   sql.Contains("ARRAY_") ||
                   sql.Contains("FLATTEN(") ||
                   sql.Contains(":VALUE") ||
                   sql.Contains(":NAME") ||
                   sql.Contains(":TYPE");
        });
    }

    /// <summary>
    /// Filters queries that use Snowflake-specific parameter syntax (:param or @param).
    /// </summary>
    /// <param name="parameterName">The parameter name (with or without : or @).</param>
    /// <returns>Query breakdowns using the specified Snowflake parameter.</returns>
    public IEnumerable<QueryBreakdown> WhereUseSnowflakeParameter(string parameterName)
    {
        if (string.IsNullOrWhiteSpace(parameterName))
        {
            throw new ArgumentNullException(nameof(parameterName));
        }

        // Normalize parameter name (remove : or @)
        var cleanName = parameterName.TrimStart(':', '@');

        return _queryBreakdowns.Where(q =>
        {
            var sql = q.GetSql();
            return sql.Contains($":{cleanName}", StringComparison.OrdinalIgnoreCase) ||
                   sql.Contains($"@{cleanName}", StringComparison.OrdinalIgnoreCase);
        });
    }

    /// <summary>
    /// Filters queries that use Snowflake time travel features.
    /// </summary>
    /// <remarks>
    /// Detects use of BEFORE, AT, or MATCH_CONDITION clauses for time travel queries.
    /// </remarks>
    /// <returns>Query breakdowns using time travel syntax.</returns>
    public IEnumerable<QueryBreakdown> WhereUseTimeTravelFeature()
    {
        return _queryBreakdowns.Where(q =>
        {
            var sql = q.GetSql().ToUpperInvariant();

            return sql.Contains("BEFORE (") ||
                   sql.Contains("AT (") ||
                   sql.Contains("MATCH_CONDITION");
        });
    }

    /// <summary>
    /// Filters queries that use Snowflake functions (PARSE_JSON, OBJECT_INSERT, ARRAY, etc.).
    /// </summary>
    /// <returns>Query breakdowns using Snowflake-specific functions.</returns>
    public IEnumerable<QueryBreakdown> WhereUseSnowflakeFunctions()
    {
        return _queryBreakdowns.Where(q =>
        {
            var sql = q.GetSql().ToUpperInvariant();

            var snowflakeFunctions = new[]
            {
                "PARSE_JSON", "OBJECT_INSERT", "ARRAY_CONSTRUCT", "ARRAY_AGG",
                "FLATTEN", "GET_PATH", "TRY_PARSE_JSON", "JSON_EXTRACT_PATH_TEXT",
                "JSON_EXTRACT_PATH_WITH_DEFAULT", "HASHAGGREGATE", "LISTAGG",
                "APPROX_COUNT_DISTINCT", "APPROX_PERCENTILE", "GREATEST", "LEAST",
                "NULLIF", "ZEROIFNULL", "STRTOK", "SPLIT_PART", "PIVOT", "UNPIVOT"
            };

            return snowflakeFunctions.Any(func => sql.Contains(func));
        });
    }

    /// <summary>
    /// Filters queries that reference temporary or dynamic tables.
    /// </summary>
    /// <returns>Query breakdowns using temporary tables.</returns>
    public IEnumerable<QueryBreakdown> WhereUseTemporaryTables()
    {
        return _queryBreakdowns.Where(q =>
        {
            var sql = q.GetSql().ToUpperInvariant();

            return sql.Contains("TEMPORARY TABLE") ||
                   sql.Contains("TEMP TABLE") ||
                   sql.Contains("CREATE TEMP ") ||
                   sql.Contains("DYNAMIC TABLE");
        });
    }

    /// <summary>
    /// Filters queries that reference external tables or stages.
    /// </summary>
    /// <returns>Query breakdowns using external data sources.</returns>
    public IEnumerable<QueryBreakdown> WhereUseExternalData()
    {
        return _queryBreakdowns.Where(q =>
        {
            var sql = q.GetSql().ToUpperInvariant();

            return sql.Contains("EXTERNAL TABLE") ||
                   sql.Contains(" FROM @") ||
                   sql.Contains("COPY INTO @");
        });
    }

    /// <summary>
    /// Filters queries by the SELECT clause content using Snowflake's format.
    /// </summary>
    /// <param name="selectContains">The text to find in the SELECT clause.</param>
    /// <returns>Filtered query breakdowns.</returns>
    public IEnumerable<QueryBreakdown> WhereSelectContains(string selectContains)
    {
        if (string.IsNullOrWhiteSpace(selectContains))
        {
            throw new ArgumentNullException(nameof(selectContains));
        }

        return _queryBreakdowns.Where(q =>
            q.SelectClause?.Clause?.Contains(selectContains, StringComparison.OrdinalIgnoreCase) ?? false);
    }

    /// <summary>
    /// Filters queries that reference specific tables or schemas.
    /// </summary>
    /// <param name="tableNameContains">The table name or schema pattern to find.</param>
    /// <returns>Filtered query breakdowns.</returns>
    public IEnumerable<QueryBreakdown> WhereTableContains(string tableNameContains)
    {
        if (string.IsNullOrWhiteSpace(tableNameContains))
        {
            throw new ArgumentNullException(nameof(tableNameContains));
        }

        return _queryBreakdowns.Where(q =>
            q.FromClause?.Clause?.Contains(tableNameContains, StringComparison.OrdinalIgnoreCase) ?? false);
    }

    /// <summary>
    /// Filters queries that have WHERE clauses.
    /// </summary>
    /// <returns>Query breakdowns with WHERE clauses.</returns>
    public IEnumerable<QueryBreakdown> WhereHaveWhereClause()
    {
        return _queryBreakdowns.Where(q =>
            !string.IsNullOrWhiteSpace(q.WhereClause?.Clause));
    }

    /// <summary>
    /// Filters queries without WHERE clauses (potentially risky for full table scans).
    /// </summary>
    /// <returns>Query breakdowns without WHERE clauses.</returns>
    public IEnumerable<QueryBreakdown> WhereHaveNoWhereClause()
    {
        return _queryBreakdowns.Where(q =>
            string.IsNullOrWhiteSpace(q.WhereClause?.Clause));
    }

    /// <summary>
    /// Filters queries that have GROUP BY clauses.
    /// </summary>
    /// <returns>Query breakdowns with GROUP BY clauses.</returns>
    public IEnumerable<QueryBreakdown> WhereHaveGroupByClause()
    {
        return _queryBreakdowns.Where(q =>
            !string.IsNullOrWhiteSpace(q.GroupByClause?.Clause));
    }

    /// <summary>
    /// Filters queries that have ORDER BY clauses.
    /// </summary>
    /// <returns>Query breakdowns with ORDER BY clauses.</returns>
    public IEnumerable<QueryBreakdown> WhereHaveOrderByClause()
    {
        return _queryBreakdowns.Where(q =>
            !string.IsNullOrWhiteSpace(q.OrderByClause?.Clause));
    }

    /// <summary>
    /// Gets a comprehensive analysis of all queries in the collection.
    /// </summary>
    /// <returns>Analysis summary for each query.</returns>
    public IEnumerable<SnowflakeQueryAnalysis> AnalyzeQueries()
    {
        return _queryBreakdowns.Select((q, index) => new SnowflakeQueryAnalysis
        {
            Index = index,
            HasSelectClause = !string.IsNullOrWhiteSpace(q.SelectClause?.Clause),
            HasFromClause = !string.IsNullOrWhiteSpace(q.FromClause?.Clause),
            HasWhereClause = !string.IsNullOrWhiteSpace(q.WhereClause?.Clause),
            HasGroupByClause = !string.IsNullOrWhiteSpace(q.GroupByClause?.Clause),
            HasOrderByClause = !string.IsNullOrWhiteSpace(q.OrderByClause?.Clause),
            UsesSemiStructuredData = UseSemiStructuredData(q),
            UsesStageReference = UsesStageReference(q),
            UsesTimeTravelFeature = UsesTimeTravelFeature(q),
            UsesSnowflakeFunctions = UsesSnowflakeFunctions(q),
            UsesExternalData = UsesExternalData(q),
            ColumnCount = !string.IsNullOrWhiteSpace(q.SelectClause?.Clause) ? q.SelectClause.Clause.Split(',').Length : 0,
            ParameterCount = q.ParameterList.Count()
        });
    }

    /// <summary>
    /// Gets the combined Snowflake SQL from all breakdowns.
    /// </summary>
    /// <param name="includeSetupFinish">Whether to include setup and finish clauses.</param>
    /// <returns>The combined Snowflake SQL.</returns>
    public string GetCombinedSql(bool includeSetupFinish = true)
    {
        return GetSnowflakeBatch(includeSetupFinish);
    }

    /// <summary>
    /// Helper method to check if a query uses semi-structured data.
    /// </summary>
    private static bool UseSemiStructuredData(QueryBreakdown query)
    {
        var sql = query.GetSql().ToUpperInvariant();
        return sql.Contains("JSON_") ||
               sql.Contains("OBJECT_") ||
               sql.Contains("ARRAY_") ||
               sql.Contains("FLATTEN(");
    }

    /// <summary>
    /// Helper method to check if a query uses stage references.
    /// </summary>
    private static bool UsesStageReference(QueryBreakdown query)
    {
        return query.GetSql().Contains("@") &&
               (query.GetSql().Contains("FROM @") || query.GetSql().Contains(" @"));
    }

    /// <summary>
    /// Helper method to check if a query uses time travel features.
    /// </summary>
    private static bool UsesTimeTravelFeature(QueryBreakdown query)
    {
        var sql = query.GetSql().ToUpperInvariant();
        return sql.Contains("BEFORE (") ||
               sql.Contains("AT (") ||
               sql.Contains("MATCH_CONDITION");
    }

    /// <summary>
    /// Helper method to check if a query uses Snowflake-specific functions.
    /// </summary>
    private static bool UsesSnowflakeFunctions(QueryBreakdown query)
    {
        var sql = query.GetSql().ToUpperInvariant();
        var snowflakeFunctions = new[]
        {
            "PARSE_JSON", "OBJECT_INSERT", "ARRAY_CONSTRUCT", "FLATTEN",
            "LISTAGG", "APPROX_COUNT_DISTINCT", "HASH", "ZEROIFNULL"
        };
        return snowflakeFunctions.Any(func => sql.Contains(func));
    }

    /// <summary>
    /// Helper method to check if a query uses external data.
    /// </summary>
    private static bool UsesExternalData(QueryBreakdown query)
    {
        var sql = query.GetSql().ToUpperInvariant();
        return sql.Contains("EXTERNAL TABLE") ||
               sql.Contains(" FROM @") ||
               sql.Contains("COPY INTO @");
    }

    /// <summary>
    /// Synchronizes parameter values across all queries in the collection.
    /// Ensures that if a parameter with the same name exists in multiple queries, they all have the same value.
    /// </summary>
    public void SynchronizeParameters()
    {
        // Get all unique parameter names across all queries
        var allParameterNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        foreach (var query in _queryBreakdowns)
        {
            foreach (var paramName in query.Parameters.Keys)
            {
                allParameterNames.Add(paramName);
            }
        }

        // For each parameter, use the last query's value and sync to all queries that have it
        foreach (var paramName in allParameterNames)
        {
            object? lastValue = null;
            bool parameterFound = false;

            // Find the last query that has this parameter and get its value
            for (int i = _queryBreakdowns.Count - 1; i >= 0; i--)
            {
                if (_queryBreakdowns[i].Parameters.ContainsKey(paramName))
                {
                    lastValue = _queryBreakdowns[i].Parameters[paramName];
                    parameterFound = true;
                    break;
                }
            }

            // Synchronize the parameter value to all queries that have it
            if (parameterFound)
            {
                foreach (var query in _queryBreakdowns.Where(q => q.Parameters.ContainsKey(paramName)))
                {
                    query.Parameters[paramName] = lastValue!;
                }
            }
        }
    }

    /// <summary>
    /// Adds a parameter with a specific value to all queries in the collection.
    /// </summary>
    /// <param name="parameterName">The name of the parameter (without the : or @ prefix).</param>
    /// <param name="value">The value to assign to the parameter. Can be null.</param>
    public void AddParameterToAll(string parameterName, object? value)
    {
        if (string.IsNullOrWhiteSpace(parameterName))
        {
            throw new ArgumentException("Parameter name cannot be null or empty.", nameof(parameterName));
        }

        foreach (var query in _queryBreakdowns)
        {
            query.Parameters[parameterName] = value!;
        }
    }

    /// <summary>
    /// Gets all unique parameters from all queries in the collection as a combined dictionary.
    /// </summary>
    /// <returns>A dictionary containing all unique parameters across all queries.</returns>
    protected Dictionary<string, object?> GetCombinedParameterDictionary()
    {
        var combinedParams = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);

        foreach (var query in _queryBreakdowns)
        {
            // Add from ParameterList (parsed parameters)
            foreach (var param in query.ParameterList)
            {
                combinedParams[param.Name] = param.Value;
            }

            // Add/override from Parameters dictionary (manually added parameters)
            foreach (var param in query.Parameters)
            {
                combinedParams[param.Key] = param.Value;
            }
        }

        return combinedParams;
    }

    /// <summary>
    /// Gets a formatted string representation of all unique parameters with Snowflake-specific syntax.
    /// </summary>
    /// <param name="includeDataTypes">If true, includes Snowflake data types in the output format.</param>
    /// <returns>
    /// A formatted string such as ":paramName = value" or ":paramName = value -- VARIANT"
    /// for each unique parameter.
    /// </returns>
    public string GetParametersAsString(bool includeDataTypes = false)
    {
        var parameters = GetCombinedParameterDictionary();
        if (parameters.Count == 0)
        {
            return string.Empty;
        }

        var sb = new StringBuilder();
        var isFirst = true;

        foreach (var param in parameters.OrderBy(p => p.Key, StringComparer.OrdinalIgnoreCase))
        {
            if (!isFirst)
            {
                sb.AppendLine(",");
            }

            sb.Append($":{param.Key} = {FormatParameterValue(param.Value)}");

            if (includeDataTypes)
            {
                var dataType = GetSnowflakeDataType(param.Value);
                sb.Append($" -- {dataType}");
            }

            isFirst = false;
        }

        return sb.ToString();
    }

    /// <summary>
    /// Gets a detailed usage report for all parameters across the queries in the collection.
    /// </summary>
    /// <returns>An enumerable of ParameterUsageReport objects with usage statistics.</returns>
    /// <summary>
    /// Gets a report of parameter usage across all queries.
    /// </summary>
    /// <returns>Parameter usage information.</returns>
    public IEnumerable<ParameterUsageReport> GetParameterUsageReport()
    {
        // Collect all unique parameter names from both ParameterList and Parameters dictionary
        var allParamNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

        foreach (var query in _queryBreakdowns)
        {
            // Add from ParameterList (parsed parameters)
            foreach (var param in query.ParameterList)
            {
                allParamNames.Add(param.Name);
            }

            // Add from Parameters dictionary (manually added parameters)
            foreach (var paramName in query.Parameters.Keys)
            {
                allParamNames.Add(paramName);
            }
        }

        foreach (var paramName in allParamNames)
        {
            var queriesUsing = 0;
            object? lastValue = null;

            foreach (var query in _queryBreakdowns)
            {
                // Check ParameterList first (parsed)
                var param = query.ParameterList.FirstOrDefault(p => p.Name.Equals(paramName, StringComparison.OrdinalIgnoreCase));
                if (param != null)
                {
                    queriesUsing++;
                    lastValue = param.Value;
                }
                // Also check Parameters dictionary (manually added)
                else if (query.Parameters.TryGetValue(paramName, out var dictValue))
                {
                    queriesUsing++;
                    lastValue = dictValue;
                }
            }

            yield return new ParameterUsageReport
            {
                ParameterName = paramName,
                Value = lastValue,
                UsedInQueryCount = queriesUsing,
                TotalQueries = _queryBreakdowns.Count
            };
        }
    }

    /// <summary>
    /// Gets the total number of columns selected across all queries.
    /// </summary>
    /// <returns>Total column count.</returns>
    public int GetTotalSelectedColumns()
    {
        return _queryBreakdowns.Sum(q =>
            !string.IsNullOrWhiteSpace(q.SelectClause?.Clause)
                ? q.SelectClause.Clause.Split(',').Length
                : 0);
    }

    /// <summary>
    /// Gets all unique table names referenced across all queries.
    /// </summary>
    /// <remarks>
    /// This provides a quick overview of which tables are being queried.
    /// Note: This is a best-effort extraction and may not capture all table references,
    /// especially in complex subqueries or with aliasing.
    /// </remarks>
    /// <returns>List of unique table names.</returns>
    public IEnumerable<string> GetUniqueTableReferences()
    {
        var tables = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

        var tableNames = _queryBreakdowns
            .Where(q => !string.IsNullOrWhiteSpace(q.FromClause?.Clause))
            .SelectMany(q => ExtractTableNames(q.FromClause!.Clause!));

        foreach (var table in tableNames)
        {
            tables.Add(table);
        }

        return tables;
    }

    /// <summary>
    /// Gets a summary of all queries including their types and basic composition.
    /// </summary>
    /// <returns>Summary information for each query.</returns>
    public IEnumerable<SnowflakeQueryAnalysis> GetQuerySummaries()
    {
        var stageQueries = WhereUseStageReference().ToHashSet();
        var semiStructuredQueries = WhereUseSemiStructuredData().ToHashSet();

        return _queryBreakdowns.Select((q, index) => new SnowflakeQueryAnalysis
        {
            Index = index,
            HasSelectClause = !string.IsNullOrWhiteSpace(q.SelectClause?.Clause),
            HasFromClause = !string.IsNullOrWhiteSpace(q.FromClause?.Clause),
            HasWhereClause = !string.IsNullOrWhiteSpace(q.WhereClause?.Clause),
            HasGroupByClause = !string.IsNullOrWhiteSpace(q.GroupByClause?.Clause),
            HasOrderByClause = !string.IsNullOrWhiteSpace(q.OrderByClause?.Clause),
            HasCTE = q.WithClauses.Count > 0,
            UsesSemiStructuredData = semiStructuredQueries.Contains(q),
            UsesStageReference = stageQueries.Contains(q),
            UsesTimeTravelFeature = UsesTimeTravelFeature(q),
            UsesSnowflakeFunctions = false,
            UsesExternalData = false,
            ColumnCount = !string.IsNullOrWhiteSpace(q.SelectClause?.Clause) ? q.SelectClause.Clause.Split(',').Length : 0,
            ParameterCount = q.ParameterList.Count()
        });
    }

    /// <summary>
    /// Helper method to extract table names from a FROM clause.
    /// </summary>
    private static IEnumerable<string> ExtractTableNames(string fromClause)
    {
        if (string.IsNullOrWhiteSpace(fromClause))
        {
            yield break;
        }

        var parts = fromClause.Split(',');
        foreach (var part in parts)
        {
            var trimmed = part.Trim();
            var tokens = trimmed.Split(new[] { " AS ", " " }, StringSplitOptions.RemoveEmptyEntries);
            if (tokens.Length > 0)
            {
                var tableName = tokens[0].Trim();
                if (!string.IsNullOrWhiteSpace(tableName))
                {
                    yield return tableName;
                }
            }
        }
    }

    /// <summary>
    /// Helper method to convert a .NET object to its corresponding Snowflake data type string.
    /// </summary>
    private static string GetSnowflakeDataType(object? value)
    {
        return value switch
        {
            null => "VARIANT",
            bool => "BOOLEAN",
            byte or sbyte or short or ushort or int or uint or long or ulong => "NUMBER",
            float or double or decimal => "NUMBER",
            DateTime or DateTimeOffset => "TIMESTAMP_NTZ",
            TimeSpan => "TIME",
            string => value.ToString()!.Length > 255 ? "VARCHAR(MAX)" : "VARCHAR(255)",
            byte[] => "BINARY",
            _ => "VARIANT"
        };
    }

    /// <summary>
    /// Helper method to format a parameter value for safe inclusion in Snowflake SQL statements.
    /// </summary>
    private static string FormatParameterValue(object? value)
    {
        return value switch
        {
            null => "NULL",
            bool b => b ? "TRUE" : "FALSE",
            string s => $"'{s.Replace("'", "''")}'",
            DateTime dt => $"'{dt:yyyy-MM-dd HH:mm:ss}'",
            DateTimeOffset dto => $"'{dto:yyyy-MM-dd HH:mm:ss}'",
            _ => value.ToString() ?? "NULL"
        };
    }
}

/// <summary>
/// Analysis information about a Snowflake query.
/// </summary>
public class SnowflakeQueryAnalysis
{
    /// <summary>
    /// Gets or sets the index of the query in the collection.
    /// </summary>
    public int Index { get; set; }

    /// <summary>
    /// Gets or sets whether the query has a SELECT clause.
    /// </summary>
    public bool HasSelectClause { get; set; }

    /// <summary>
    /// Gets or sets whether the query has a FROM clause.
    /// </summary>
    public bool HasFromClause { get; set; }

    /// <summary>
    /// Gets or sets whether the query has a WHERE clause.
    /// </summary>
    public bool HasWhereClause { get; set; }

    /// <summary>
    /// Gets or sets whether the query has a GROUP BY clause.
    /// </summary>
    public bool HasGroupByClause { get; set; }

    /// <summary>
    /// Gets or sets whether the query has an ORDER BY clause.
    /// </summary>
    public bool HasOrderByClause { get; set; }

    /// <summary>
    /// Gets or sets whether the query has Common Table Expressions (CTEs).
    /// </summary>
    public bool HasCTE { get; set; }

    /// <summary>
    /// Gets or sets whether the query uses semi-structured data functions.
    /// </summary>
    public bool UsesSemiStructuredData { get; set; }

    /// <summary>
    /// Gets or sets whether the query references Snowflake stages.
    /// </summary>
    public bool UsesStageReference { get; set; }

    /// <summary>
    /// Gets or sets whether the query uses Snowflake time travel features.
    /// </summary>
    public bool UsesTimeTravelFeature { get; set; }

    /// <summary>
    /// Gets or sets whether the query uses Snowflake-specific functions.
    /// </summary>
    public bool UsesSnowflakeFunctions { get; set; }

    /// <summary>
    /// Gets or sets whether the query uses external data sources.
    /// </summary>
    public bool UsesExternalData { get; set; }

    /// <summary>
    /// Gets or sets the number of columns in the SELECT clause.
    /// </summary>
    public int ColumnCount { get; set; }

    /// <summary>
    /// Gets or sets the number of parameters used.
    /// </summary>
    public int ParameterCount { get; set; }

    /// <summary>
    /// Returns a string representation of the query analysis.
    /// </summary>
    public override string ToString()
    {
        var sb = new StringBuilder();
        sb.AppendLine($"Snowflake Query #{Index}");
        sb.AppendLine($"  Basic Structure:");
        sb.AppendLine($"    SELECT: {(HasSelectClause ? "Yes" : "No")} ({ColumnCount} columns)");
        sb.AppendLine($"    FROM: {(HasFromClause ? "Yes" : "No")}");
        sb.AppendLine($"    WHERE: {(HasWhereClause ? "Yes" : "No")}");
        sb.AppendLine($"    GROUP BY: {(HasGroupByClause ? "Yes" : "No")}");
        sb.AppendLine($"    ORDER BY: {(HasOrderByClause ? "Yes" : "No")}");
        sb.AppendLine($"  Snowflake Features:");
        sb.AppendLine($"    Semi-Structured Data: {(UsesSemiStructuredData ? "Yes" : "No")}");
        sb.AppendLine($"    Stage Reference: {(UsesStageReference ? "Yes" : "No")}");
        sb.AppendLine($"    Time Travel: {(UsesTimeTravelFeature ? "Yes" : "No")}");
        sb.AppendLine($"    Snowflake Functions: {(UsesSnowflakeFunctions ? "Yes" : "No")}");
        sb.AppendLine($"    External Data: {(UsesExternalData ? "Yes" : "No")}");
        sb.Append($"    Parameters: {ParameterCount}");
        return sb.ToString();
    }
}

/// <summary>
/// Reports parameter usage statistics across queries in a Snowflake collection.
/// </summary>
public class ParameterUsageReport
{
    /// <summary>
    /// Gets or sets the name of the parameter.
    /// </summary>
    public string ParameterName { get; set; } = string.Empty;

    /// <summary>
    /// Gets or sets the current value of the parameter.
    /// </summary>
    public object? Value { get; set; }

    /// <summary>
    /// Gets or sets the number of queries using this parameter.
    /// </summary>
    public int UsedInQueryCount { get; set; }

    /// <summary>
    /// Gets or sets the total number of queries in the collection.
    /// </summary>
    public int TotalQueries { get; set; }

    /// <summary>
    /// Gets a value indicating whether this parameter is used in all queries.
    /// </summary>
    public bool IsUsedInAllQueries => UsedInQueryCount == TotalQueries && TotalQueries > 0;

    /// <summary>
    /// Returns a string representation of the parameter usage report.
    /// </summary>
    public override string ToString()
    {
        if (TotalQueries == 0)
        {
            return $"{ParameterName}: No queries";
        }

        var percentage = (UsedInQueryCount * 100.0) / TotalQueries;
        var valueStr = Value switch
        {
            null => "NULL",
            string s => $"'{s}'",
            _ => Value.ToString() ?? "NULL"
        };

        return $"{ParameterName} = {valueStr} ({UsedInQueryCount}/{TotalQueries} queries - {percentage:F1}%)";
    }
}