// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using Roslyn.Utilities;
using MSB = Microsoft.Build;
 
namespace Microsoft.CodeAnalysis.MSBuild;
 
internal abstract class CommandLineArgumentReader
{
    protected readonly MSB.Execution.ProjectInstance Project;
    private readonly ImmutableArray<string>.Builder _builder;
 
    protected CommandLineArgumentReader(MSB.Execution.ProjectInstance project)
    {
        Project = project;
        _builder = ImmutableArray.CreateBuilder<string>();
    }
 
    protected abstract void ReadCore();
 
    private static void ValidateName(string name)
    {
        if (string.IsNullOrEmpty(name) || name.Any(char.IsWhiteSpace))
        {
            throw new ArgumentException(WorkspaceMSBuildBuildHostResources.Parameter_cannot_be_null_empty_or_contain_whitespace, nameof(name));
        }
    }
 
    protected void Add(string name)
    {
        ValidateName(name);
 
        _builder.Add($"/{name}");
    }
 
    protected void Add(string name, string? value, bool addQuoteIfValueContainsWhitespace = true)
    {
        ValidateName(name);
 
        if (string.IsNullOrEmpty(value) || (addQuoteIfValueContainsWhitespace && value.Any(char.IsWhiteSpace)))
        {
            _builder.Add($"/{name}:\"{value}\"");
        }
        else
        {
            _builder.Add($"/{name}:{value}");
        }
    }
 
    protected void Add(string name, int value)
    {
        Add(name, value.ToString());
    }
 
    protected void AddIfNotNullOrWhiteSpace(string name, string? value, bool addQuoteIfValueContainsWhitespace = true)
    {
        if (!RoslynString.IsNullOrWhiteSpace(value))
        {
            Add(name, value, addQuoteIfValueContainsWhitespace);
        }
    }
 
    protected void AddIfTrue(string name, bool condition)
    {
        if (condition)
        {
            Add(name);
        }
    }
 
    protected void AddIfTrue(string name, string value, bool condition)
    {
        if (condition)
        {
            Add(name, value);
        }
    }
 
    protected void AddIfFalse(string name, bool condition)
    {
        if (!condition)
        {
            Add(name);
        }
    }
 
    protected void AddWithPlus(string name)
    {
        Add($"{name}+");
    }
 
    protected void AddWithMinus(string name)
    {
        Add($"{name}-");
    }
 
    protected void AddWithPlusOrMinus(string name, bool condition)
    {
        if (condition)
        {
            AddWithPlus(name);
        }
        else
        {
            AddWithMinus(name);
        }
    }
 
    protected string GetDocumentFilePath(MSB.Framework.ITaskItem documentItem)
    {
        return GetAbsolutePath(documentItem.ItemSpec);
    }
 
    protected string GetAbsolutePath(string path)
    {
        var baseDirectory = PathUtilities.GetDirectoryName(Project.FullPath);
        var absolutePath = FileUtilities.ResolveRelativePath(path, baseDirectory) ?? path;
        return FileUtilities.TryNormalizeAbsolutePath(absolutePath) ?? absolutePath;
    }
 
    protected void ReadAdditionalFiles()
    {
        var additionalFiles = Project.GetAdditionalFiles();
        if (additionalFiles != null)
        {
            foreach (var additionalFile in additionalFiles)
            {
                Add("additionalfile", GetDocumentFilePath(additionalFile));
            }
        }
    }
 
    protected void ReadAnalyzers()
    {
        var analyzers = Project.GetAnalyzers();
        if (analyzers != null)
        {
            foreach (var analyzer in analyzers)
            {
                Add("analyzer", GetDocumentFilePath(analyzer));
            }
        }
    }
 
    protected void ReadCodePage()
    {
        var codePage = Project.ReadPropertyInt(PropertyNames.CodePage);
        AddIfTrue("codepage", codePage.ToString(), codePage != 0);
    }
 
    private static readonly ImmutableDictionary<string, string> s_debugTypeValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
    {
        { "none", "none" },
        { "pdbonly", "pdbonly" },
        { "full", "full" },
        { "portable", "portable" },
        { "embedded", "embedded" }
    }.ToImmutableDictionary();
 
    protected void ReadDebugInfo()
    {
        var emitDebugInfo = Project.ReadPropertyBool(PropertyNames.DebugSymbols);
        if (emitDebugInfo)
        {
            var debugType = Project.ReadPropertyString(PropertyNames.DebugType);
            if (debugType != null && s_debugTypeValues.TryGetValue(debugType, out var value))
            {
                Add("debug", value);
            }
        }
    }
 
    protected void ReadDelaySign()
    {
        var delaySign = Project.ReadPropertyString(PropertyNames.DelaySign);
        if (!RoslynString.IsNullOrWhiteSpace(delaySign))
        {
            AddWithPlusOrMinus("delaysign", Conversions.ToBool(delaySign));
        }
    }
 
    protected void ReadErrorReport()
    {
        var errorReport = Project.ReadPropertyString(PropertyNames.ErrorReport);
        if (!RoslynString.IsNullOrWhiteSpace(errorReport))
        {
            Add("errorreport", errorReport.ToLower());
        }
    }
 
    protected void ReadFeatures()
    {
        var features = Project.ReadPropertyString(PropertyNames.Features);
        if (!RoslynString.IsNullOrWhiteSpace(features))
        {
            foreach (var feature in CompilerOptionParseUtilities.ParseFeatureFromMSBuild(features))
            {
                Add("features", feature);
            }
        }
    }
 
    protected void ReadImports()
    {
        var imports = Project.GetTaskItems(ItemNames.Import);
        if (imports == null)
            return;
 
        // In case of import alias clause in the form of `aliasname = namespace`,
        // we want to add quotes to that single clause only instead of the entire imports.
        AddIfNotNullOrWhiteSpace("imports", string.Join(",", imports.Select(ReadImportItem)), addQuoteIfValueContainsWhitespace: false);
 
        static string ReadImportItem(MSB.Framework.ITaskItem item)
        {
            var trimmed = item.ItemSpec.Trim();
            return trimmed.Contains(' ') ? $"\"{trimmed}\"" : trimmed;
        }
    }
 
    protected void ReadPlatform()
    {
        var platform = Project.ReadPropertyString(PropertyNames.PlatformTarget);
        var prefer32bit = Project.ReadPropertyBool(PropertyNames.Prefer32Bit);
 
        if (prefer32bit && (RoslynString.IsNullOrWhiteSpace(platform) || string.Equals("anycpu", platform, StringComparison.OrdinalIgnoreCase)))
        {
            platform = "anycpu32bitpreferred";
        }
 
        AddIfNotNullOrWhiteSpace("platform", platform);
    }
 
    protected void ReadReferences()
    {
        var references = Project.GetMetadataReferences();
        if (references != null)
        {
            foreach (var reference in references)
            {
                if (reference.ReferenceOutputAssemblyIsTrue())
                {
                    var filePath = GetDocumentFilePath(reference);
 
                    var aliases = reference.GetAliases();
                    if (aliases.IsDefaultOrEmpty)
                    {
                        Add("reference", filePath);
                    }
                    else
                    {
                        foreach (var alias in aliases)
                        {
                            if (string.Equals(alias, "global", StringComparison.OrdinalIgnoreCase))
                            {
                                Add("reference", filePath);
                            }
                            else
                            {
                                Add("reference", $"{alias}=\"{filePath}\"");
                            }
                        }
                    }
                }
            }
        }
    }
 
    protected void ReadSigning()
    {
        var signAssembly = Project.ReadPropertyBool(PropertyNames.SignAssembly);
        if (signAssembly)
        {
            var keyFile = Project.ReadPropertyString(PropertyNames.KeyOriginatorFile);
            if (!RoslynString.IsNullOrWhiteSpace(keyFile))
            {
                Add("keyFile", keyFile);
            }
 
            var keyContainer = Project.ReadPropertyString(PropertyNames.KeyContainerName);
            if (!RoslynString.IsNullOrWhiteSpace(keyContainer))
            {
                Add("keycontainer", keyContainer);
            }
        }
    }
 
    protected ImmutableArray<string> Read()
    {
        ReadCore();
        return _builder.ToImmutable();
    }
}