// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System;
using System.Collections.Immutable;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Operations;

namespace Microsoft.AspNetCore.Analyzers
{
    [DiagnosticAnalyzer(LanguageNames.CSharp)]
    public partial class StartupAnalyzer : DiagnosticAnalyzer
    {
        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => Diagnostics.SupportedDiagnostics;

        public override void Initialize(AnalysisContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
            context.RegisterCompilationStartAction(OnCompilationStart);
        }

        private void OnCompilationStart(CompilationStartAnalysisContext context)
        {
            var symbols = new StartupSymbols(context.Compilation);

            // Don't run analyzer if ASP.NET Core types cannot be found
            if (!symbols.HasRequiredSymbols)
            {
                return;
            }

            var entryPoint = context.Compilation.GetEntryPoint(context.CancellationToken);

            context.RegisterSymbolStartAction(context =>
            {
                var type = (INamedTypeSymbol)context.Symbol;
                if (!StartupFacts.IsStartupClass(symbols, type) && !SymbolEqualityComparer.Default.Equals(entryPoint?.ContainingType, type))
                {
                    // Not a startup class, nothing to do.
                    return;
                }

                // This analyzer fans out a bunch of jobs. The context will capture the results of doing analysis
                // on the startup code, so that other analyzers that run later can examine them.
                var builder = new StartupAnalysisBuilder(this, symbols);

                var services = new ServicesAnalyzer(builder);
                var options = new OptionsAnalyzer(builder);
                var middleware = new MiddlewareAnalyzer(builder);

                context.RegisterOperationBlockStartAction(context =>
                {
                    if (context.OwningSymbol.Kind != SymbolKind.Method)
                    {
                        return;
                    }

                    var method = (IMethodSymbol)context.OwningSymbol;
                    var isConfigureServices = StartupFacts.IsConfigureServices(symbols, method);
                    if (isConfigureServices)
                    {
                        OnConfigureServicesMethodFound(method);
                    }

                    // In the future we can consider looking at more methods, but for now limit to Main, implicit Main, and Configure* methods
                    var isMain = SymbolEqualityComparer.Default.Equals(entryPoint, context.OwningSymbol);

                    if (isConfigureServices || isMain)
                    {
                        services.AnalyzeConfigureServices(context);
                        options.AnalyzeConfigureServices(context);
                    }

                    var isConfigure = StartupFacts.IsConfigure(symbols, method);
                    if (isConfigure)
                    {
                        OnConfigureMethodFound(method);
                    }
                    if (isConfigure || isMain)
                    {
                        middleware.AnalyzeConfigureMethod(context);
                    }
                });

                // Run after analyses have had a chance to finish to add diagnostics.
                context.RegisterSymbolEndAction(context =>
                {
                    var analysis = builder.Build();
                    new UseMvcAnalyzer(analysis).AnalyzeSymbol(context);
                    new BuildServiceProviderAnalyzer(analysis).AnalyzeSymbol(context);
                    new UseAuthorizationAnalyzer(analysis).AnalyzeSymbol(context);
                });

            }, SymbolKind.NamedType);
        }
    }
}
