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

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
using System;
using System.Collections.Immutable;
using System.Linq;

namespace Microsoft.DotNet.CodeAnalysis.Analyzers;

[DiagnosticAnalyzer(LanguageNames.CSharp)]
public class AppContextDefaultsAnalyzer : BaseAnalyzer
{
    private const string HowToDisableWarning = "If this is intentional consider using '#pragma warning disable {0}' to suppress the warning.";

    private static string s_title = @"Ensure AppContext defaults are correctly setup";
    private static string s_analyzerName = "AppContextDefaults";
    private static string s_description = @"Ensures AppContext default values are correctly setup.";
    private static string s_defaultValueNotInitializedToTrue = @"AppContext default value expected to be 'true' in the call: '{0}'.";
    private static string s_defaultValueInsideUnexpectedIfCondition = @"AppContext default value is defined inside an if statement that does not use the '<=' pattern.";
    private static string s_defaultValueDefinedOutsideIfCondition = @"AppContext default value should be defined inside an if statement at the root of the switch case.";

    private static readonly DiagnosticDescriptor s_appContextDefaultNotInitializedToTrueDiagnostic =
        new DiagnosticDescriptor(DiagnosticIds.BCL0010.ToString(), s_title, CreateDiagnosticMessage(s_defaultValueNotInitializedToTrue, DiagnosticIds.BCL0010.ToString()), s_analyzerName, DiagnosticSeverity.Error, isEnabledByDefault: true, description: s_description);

    private static readonly DiagnosticDescriptor s_appContextDefaultUsedUnexpectedIfStatementDiagnostic =
        new DiagnosticDescriptor(DiagnosticIds.BCL0011.ToString(), s_title, CreateDiagnosticMessage(s_defaultValueInsideUnexpectedIfCondition, DiagnosticIds.BCL0011.ToString()), s_analyzerName, DiagnosticSeverity.Error, isEnabledByDefault: true, description: s_description);

    private static readonly DiagnosticDescriptor s_appContextDefaultValueDefinedOutsideIfConditionDiagnostic =
        new DiagnosticDescriptor(DiagnosticIds.BCL0012.ToString(), s_title, CreateDiagnosticMessage(s_defaultValueDefinedOutsideIfCondition, DiagnosticIds.BCL0012.ToString()), s_analyzerName, DiagnosticSeverity.Error, isEnabledByDefault: true, description: s_description);

    /// <summary>
    /// This method combines information about what the actual error is with a suggested way on how to suppress the warning.
    /// </summary>
    private static string CreateDiagnosticMessage(string diagnosticMessage, string diagnosticId)
    {
        return string.Format("{0} {1}", diagnosticMessage, string.Format(HowToDisableWarning, diagnosticId));
    }


    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
    {
        get
        {
            return ImmutableArray.Create(
                s_appContextDefaultNotInitializedToTrueDiagnostic,
                s_appContextDefaultUsedUnexpectedIfStatementDiagnostic,
                s_appContextDefaultValueDefinedOutsideIfConditionDiagnostic);
        }
    }

    public override void OnCompilationStart(CompilationStartAnalysisContext context)
    {
        context.RegisterSyntaxNodeAction(AnalyzeCodeBlock, SyntaxKind.InvocationExpression);
    }

    private void AnalyzeCodeBlock(SyntaxNodeAnalysisContext context)
    {
        InvocationExpressionSyntax call = context.Node as InvocationExpressionSyntax;
        if (call == null)
            return;

        // If we are not calling the DefineSwitchDefault methods on LocalAppContext then we can safely ignore this.
        if (!IsCallToDefineSwitchDefault(call, context.SemanticModel))
        {
            return;
        }

        // Validate that the second argument is true. 
        ArgumentSyntax args = call.ArgumentList.Arguments[1];
        if (args.Expression.Kind() != SyntaxKind.TrueLiteralExpression)
        {
            context.ReportDiagnostic(Diagnostic.Create(s_appContextDefaultNotInitializedToTrueDiagnostic, args.GetLocation(), call));
        }

        // check that we are doing this inside an if statement
        var containingIfStatement = call.Ancestors().FirstOrDefault(n => n.IsKind(SyntaxKind.IfStatement)) as IfStatementSyntax;
        if (containingIfStatement == null)
        {
            context.ReportDiagnostic(Diagnostic.Create(s_appContextDefaultValueDefinedOutsideIfConditionDiagnostic, args.GetLocation(), call));
        }
        else
        {
            // are we inside the switch? either as a block or as a switchcase?
            if (!(containingIfStatement.Parent.IsKind(SyntaxKind.SwitchSection) ||
                containingIfStatement.Parent.Parent.IsKind(SyntaxKind.SwitchSection)))
            {
                context.ReportDiagnostic(Diagnostic.Create(s_appContextDefaultValueDefinedOutsideIfConditionDiagnostic, args.GetLocation(), call));
            }
        }

        // Validate that the if statement is using the appropriate expression
        if (containingIfStatement.Condition.Kind() != SyntaxKind.LessThanOrEqualExpression)
        {
            context.ReportDiagnostic(Diagnostic.Create(s_appContextDefaultUsedUnexpectedIfStatementDiagnostic, containingIfStatement.GetLocation()));
        }
    }


    /// <summary>
    /// Check to see if the call is to this method: System.LocalAppContext.DefineSwitchDefault(string, boolean);
    /// </summary>
    private bool IsCallToDefineSwitchDefault(InvocationExpressionSyntax call, SemanticModel model)
    {
        // we are going to do a quick check to avoid doing a lot of computations at this point:
        // -- does the invocation expression have the 'DefineSwitchDefault' method name
        // -- does the call have 2 arguments
        if (call.Expression.ToString().IndexOf("DefineSwitchDefault") == -1)
            return false;

        if (call.ArgumentList.Arguments.Count != 2)
            return false;

        // If we got to this point, our fast checks indicate a possible real call that we need 
        // to further check
        var symInfo = model.GetSymbolInfo(call);

        if (symInfo.Symbol == null)
            return false;

        return IsMethodTheDefineSwitchDefaultOne(symInfo.Symbol as IMethodSymbol);
    }

    private bool IsMethodTheDefineSwitchDefaultOne(IMethodSymbol methodSym)
    {
        if (methodSym == null)
            return false;

        // We allow calls on both LocalAppContext (for non-mscorlib) and AppContext (for mscorlib)
        if (!StringComparer.Ordinal.Equals(methodSym.ContainingType.Name, "LocalAppContext") &&
            !StringComparer.Ordinal.Equals(methodSym.ContainingType.Name, "AppContext"))
            return false;

        if (!StringComparer.Ordinal.Equals(methodSym.ContainingNamespace.Name, "System"))
            return false;

        if (!StringComparer.Ordinal.Equals(methodSym.Name, "DefineSwitchDefault"))
            return false;

        //check parameter type.
        if (methodSym.Parameters.Length != 2)
            return false;

        if (methodSym.Parameters[0].Type.SpecialType != SpecialType.System_String)
            return false;

        if (methodSym.Parameters[1].Type.SpecialType != SpecialType.System_Boolean)
            return false;

        return true;
    }
}