QueriesGen.cs

using Microsoft.CodeAnalysis.CSharp.Syntax;
using Plugin;
using SqlcGenCsharp.Drivers;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;


namespace SqlcGenCsharp.Generators;

internal partial class QueriesGen(DbDriver dbDriver, string namespaceName)
{
    private static readonly string[] ResharperDisables =
    [
        "UnusedAutoPropertyAccessor.Global",
        "NotAccessedPositionalProperty.Global",
        "ConvertToUsingDeclaration",
        "UseAwaitUsing",
        "UseObjectOrCollectionInitializer"
    ];

    private RootGen RootGen { get; } = new(dbDriver.Options);

    private DataClassesGen DataClassesGen { get; } = new(dbDriver);

    public File GenerateFile(IEnumerable<Query> queries, string className)
    {
        var (usingDirectives, classDeclaration) = GenerateClass(queries, className);
        var root = RootGen.CompilationRootGen(
            IdentifierName(namespaceName), usingDirectives, [classDeclaration]);
        root = AddResharperDisables(root);
        root = root.AddCommentOnTop(Consts.AutoGeneratedComment);

        return new File
        {
            Name = $"{className}.cs",
            Contents = root.ToByteString()
        };
    }

    private static CompilationUnitSyntax AddResharperDisables(CompilationUnitSyntax compilationUnit)
    {
        return ResharperDisables
            .Aggregate(compilationUnit, (current, resharperDisable) =>
                current.AddCommentOnTop($"// ReSharper disable {resharperDisable}"));
    }

    private (UsingDirectiveSyntax[], MemberDeclarationSyntax) GenerateClass(IEnumerable<Query> queries,
        string className)
    {
        var usingDirectives = dbDriver
            .GetUsingDirectivesForQueries()
            .OrderBy(x => x)
            .Select(x => UsingDirective(ParseName(x)))
            .ToArray();
        var classMembers = queries.SelectMany(GetMembersForSingleQuery);
        return (usingDirectives, GetClassDeclaration(className, classMembers));
    }

    private ClassDeclarationSyntax GetClassDeclaration(string className, IEnumerable<MemberDeclarationSyntax> classMembers)
    {
        var dapperStatements = dbDriver.Options.UseDapper
            ? $$"""
                Utils.ConfigureSqlMapper();
                DefaultTypeMap.MatchNamesWithUnderscores = true;
              """
            : string.Empty;

        var baseTypes = dbDriver.GetClassBaseTypes();
        var baseTypesStr = baseTypes.Length > 0 ? $" : {string.Join(", ", baseTypes)}" : string.Empty;

        var classDeclaration = (ClassDeclarationSyntax)ParseMemberDeclaration(
                $$"""
                  public class {{className}}{{baseTypesStr}}
                  {
                      public {{className}}()
                      {
                          {{dapperStatements}}
                      }

                      public {{className}}(string {{Variable.ConnectionString.AsVarName()}}) : this()
                      {
                          {{dbDriver.GetConstructorStatements().JoinByNewLine()}}
                      }

                      private {{className}}({{dbDriver.TransactionClassName}} {{Variable.Transaction.AsVarName()}}) : this()
                      {
                          {{dbDriver.GetTransactionConstructorStatements().JoinByNewLine()}}
                      }

                      public static {{className}} WithTransaction({{dbDriver.TransactionClassName}} {{Variable.Transaction.AsVarName()}})
                      {
                          return new {{className}}({{Variable.Transaction.AsVarName()}});
                      }

                      private {{dbDriver.AddNullableSuffixIfNeeded(dbDriver.TransactionClassName, false)}} {{Variable.Transaction.AsPropertyName()}} { get; }
                      private {{dbDriver.AddNullableSuffixIfNeeded("string", false)}} {{Variable.ConnectionString.AsPropertyName()}} { get; }
                  }
                """)!;

        return classDeclaration.AddMembers(
            [.. dbDriver.GetAdditionalClassMembers()
                .AddRangeExcludeNulls(classMembers)]
        );
    }

    private IEnumerable<MemberDeclarationSyntax> GetMembersForSingleQuery(Query query)
    {
        try
        {
            return new List<MemberDeclarationSyntax>()
                .AddRangeExcludeNulls(
                    [
                        GetQueryTextConstant(query),
                        GetQueryColumnsDataclass(query),
                        GetQueryParamsDataclass(query),
                        AddMethodDeclaration(query)
                    ]
                );
        }
        catch (NotSupportedException e)
        {
            throw new SystemException($"Failed to get members for query: {query.Name}", e);
        }
    }

    private MemberDeclarationSyntax? GetQueryColumnsDataclass(Query query)
    {
        if (query.Columns.Count <= 0) return null;
        return DataClassesGen.Generate(query.Name, ClassMember.Row, query.Columns, dbDriver.Options, query);
    }

    private MemberDeclarationSyntax? GetQueryParamsDataclass(Query query)
    {
        if (query.Params.Count <= 0) return null;
        var columns = query.Params.Select(p => dbDriver.GetColumnFromParam(p, query)).ToList();
        return DataClassesGen.Generate(query.Name, ClassMember.Args, columns, dbDriver.Options, query);
    }

    private MemberDeclarationSyntax? GetQueryTextConstant(Query query)
    {
        var transformedQueryText = dbDriver.TransformQueryText(query);
        if (transformedQueryText == string.Empty)
            return null;

        var memberName = ClassMember.Sql.Name(query.Name);
        if (transformedQueryText.IndexOfAny(['\r', '\n']) >= 0)
        {
            var queryText = transformedQueryText.Replace("\"", "\"\"");
            var lines = queryText.TrimEnd().Split(["\r\n", "\r", "\n"], StringSplitOptions.None);

            // The indentation of the constant declaration itself. for legacy generation it 8 indents and for modern it 4.
            string memberIndentPrefix = dbDriver.Options.DotnetFramework.IsDotnetLegacy() ? "        " : "    ";
            var declaration = $"private const string {memberName} = @\"";

            // We need to calculate the indentation for subsequent lines so they align with the first.
            // This is based on the member indent, the declaration length, and any leading space on the first SQL line.
            var firstLineLeadingSpaceCount = lines[0].TakeWhile(char.IsWhiteSpace).Count();
            var subsequentLineIndent = new string(' ', memberIndentPrefix.Length + declaration.Length + firstLineLeadingSpaceCount);

            var indentedLines = lines.Skip(1).Select(line => subsequentLineIndent + line);
            var fullQueryString = string.Join(Environment.NewLine, [lines[0], .. indentedLines]);

            return ParseMemberDeclaration(
                $"{memberIndentPrefix}{declaration}{fullQueryString}\";")!;
        }

        var singleLineQueryText = LongWhitespaceRegex().Replace(transformedQueryText, " ");
        return ParseMemberDeclaration(
                $"""private const string {memberName} = "{singleLineQueryText}";""")!
            .AppendNewLine();
    }


    [GeneratedRegex(@"\s{1,}")]
    private static partial Regex LongWhitespaceRegex();

    private MemberDeclarationSyntax AddMethodDeclaration(Query query)
    {
        var queryTextConstant = ClassMember.Sql.Name(query.Name);
        var argInterface = ClassMember.Args.Name(query.Name);
        var returnInterface = ClassMember.Row.Name(query.Name);

        try
        {
            return query.Cmd switch
            {
                ":exec" => ((IExec)dbDriver).ExecDeclare(queryTextConstant, argInterface, query),
                ":one" => ((IOne)dbDriver).OneDeclare(queryTextConstant, argInterface, returnInterface, query),
                ":many" => ((IMany)dbDriver).ManyDeclare(queryTextConstant, argInterface, returnInterface, query),
                ":execrows" => ((IExecRows)dbDriver).ExecRowsDeclare(queryTextConstant, argInterface, query),
                ":execlastid" => ((IExecLastId)dbDriver).ExecLastIdDeclare(queryTextConstant, argInterface, query),
                ":copyfrom" => ((ICopyFrom)dbDriver).CopyFromDeclare(queryTextConstant, argInterface, query),
                _ => throw new NotSupportedException($"{query.Cmd} is not supported")
            };
        }
        catch (Exception e)
        {
            throw new SystemException($"Failed to add method declaration for query: {query.Name}", e);
        }
    }
}