// 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.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.IO;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Text;
using System.Diagnostics;

namespace Microsoft.DotNet.CodeAnalysis.Analyzers;

[DiagnosticAnalyzer(LanguageNames.CSharp)]
public class PinvokeAnalyzer : BaseAnalyzer
{
    private const string Title = "Invalid Pinvoke call";
    private const string MessageFormat = @"{0} is not supported on one\more targeted platforms.{1}";
    private const string Description = "The Pinvoke call should be removed.";
    private const string AnalyzerName = "PinvokeAnalyzer";

    private static DiagnosticDescriptor InvalidPinvokeCall = new DiagnosticDescriptor(DiagnosticIds.BCL0015.ToString(), Title, MessageFormat, AnalyzerName, DiagnosticSeverity.Error, isEnabledByDefault: true, description: Description);

    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get { return ImmutableArray.Create(InvalidPinvokeCall); } }

    public override void OnCompilationStart(CompilationStartAnalysisContext obj)
    {
        _allowedPinvokeFile = obj.Options.AdditionalFiles.FirstOrDefault(f => Path.GetFileName(f.Path).IndexOf("PinvokeAnalyzer_", StringComparison.OrdinalIgnoreCase) >= 0);
        _exceptionFile = obj.Options.AdditionalFiles.FirstOrDefault(f => Path.GetFileName(f.Path).IndexOf("PinvokeAnalyzerExceptionList.analyzerdata", StringComparison.OrdinalIgnoreCase) >= 0);
        obj.RegisterSymbolAction(AnalyzeMethod, SymbolKind.Method);
    }

    private Dictionary<string, string> _allowedPinvokes;
    private Dictionary<string, string> _exceptionPinvokes;

    private Dictionary<string, string> AllowedPinvokes
    {
        get
        {
            if (_allowedPinvokes == null)
            {
                _allowedPinvokes = ParseAdditionalFile(_allowedPinvokeFile);
            }

            return _allowedPinvokes;
        }
    }

    private Dictionary<string, string> ExceptionPinvokes
    {
        get
        {
            if (_exceptionPinvokes == null)
            {
                _exceptionPinvokes = ParseAdditionalFile(_exceptionFile);
            }

            return _exceptionPinvokes;
        }
    }

    private AdditionalText _exceptionFile;
    private AdditionalText _allowedPinvokeFile;

    private HashSet<string> _isNotSupportedOnWin7 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);


    private Dictionary<string, string> ParseAdditionalFile(AdditionalText additionalFile)
    {
        Dictionary<string, string> parsedPinvokes = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

        if (additionalFile == null) return parsedPinvokes;

        SourceText fileContents = additionalFile.GetText();
        foreach (TextLine line in fileContents.Lines)
        {
            string lineStr = line.ToString();
            if (!string.IsNullOrWhiteSpace(lineStr) && !lineStr.StartsWith("<!--"))
            {
                string[] splitCount = lineStr.Split('!');

                if (splitCount.Length == 2 || splitCount.Length == 3)
                {
                    parsedPinvokes[splitCount[1]] = splitCount[0];
                    if (splitCount.Length == 3)
                    {
                        _isNotSupportedOnWin7.Add(splitCount[1]);
                    }
                }
            }
        }

        return parsedPinvokes;
    }

    private const string AltMsgString = @"Consider using {0} instead.";
    private const string NotSupportedOnWin7 = @"{0} is not supported on win7";


    // This method looks at the additional lists passed to ensure if the method call is valid.
    // This is the algorithm used by the method
    // 1. a. Check whether the moduleName!methodName is present as-is in the allowed list.
    //    b. If present validate whether it is also present on win7.
    // 2. Check if the moduleName!methodName is present in exception list.
    // 3. If not, check whether the methodName is present in another module than what is referenced.
    //    if so, make sure the error msg gives this as a suggestion to the user.
    private bool CheckIfMemberPresent(string methodName, string moduleName, ref string altMsg)
    {
        if (AllowedPinvokes.ContainsKey(methodName))
        {
            if (AllowedPinvokes[methodName].Equals(moduleName, StringComparison.OrdinalIgnoreCase))
            {
                if (_isNotSupportedOnWin7.Contains(methodName))
                {
                    altMsg = String.Format(NotSupportedOnWin7, AllowedPinvokes[methodName] + "!" + methodName);
                    return false;
                }

                return true;
            }
            else
            {
                if (String.IsNullOrEmpty(altMsg))
                    altMsg = String.Format(AltMsgString, AllowedPinvokes[methodName] + "!" + methodName);
            }
        }

        return (ExceptionPinvokes.ContainsKey(methodName) && ExceptionPinvokes[methodName].Equals(moduleName, StringComparison.OrdinalIgnoreCase));
    }

    private void AnalyzeMethod(SymbolAnalysisContext context)
    {
        var methodSymbol = context.Symbol as IMethodSymbol;
        if (methodSymbol == null) return;

        DllImportData data = methodSymbol.GetDllImportData();
        if (data == null) return;

        // Ignore QCall
        if (data.ModuleName.Equals("QCall", StringComparison.OrdinalIgnoreCase)) return;

        bool isPresent = false;
        string altMsg = string.Empty;

        // 1. If the method has an explicit entry point defined we validate if the moduleName!entryPoint is a valid combination.
        // 2. If not, we check whether the moduleName!methodName is valid or moduleName!methodNameW (we only support Unicode) is valid.
        if (data.EntryPointName != null)
        {
            isPresent = CheckIfMemberPresent(data.EntryPointName, data.ModuleName, ref altMsg);
        }
        else
        {
            isPresent = CheckIfMemberPresent(methodSymbol.Name, data.ModuleName, ref altMsg)
                || CheckIfMemberPresent(methodSymbol.Name + 'W', data.ModuleName, ref altMsg);
        }

        if (!isPresent)
        {
            foreach (SyntaxReference synref in methodSymbol.DeclaringSyntaxReferences)
            {
                context.ReportDiagnostic(Diagnostic.Create(InvalidPinvokeCall, synref.GetSyntax().GetLocation(), data.ModuleName + "!" + (data.EntryPointName ?? methodSymbol.Name), altMsg));
            }
        }
    }
}