// Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Linq;
using Mono.Cecil;
 
namespace Mono.Linker
{
    public class WarningSuppressionWriter
    {
        private readonly Dictionary<AssemblyNameDefinition, HashSet<(int Code, IMemberDefinition Member)>> _warnings;
        private readonly FileOutputKind _fileOutputKind;
        readonly LinkContext _context;
 
        public WarningSuppressionWriter(LinkContext context, FileOutputKind fileOutputKind = FileOutputKind.CSharp)
        {
            _warnings = new Dictionary<AssemblyNameDefinition, HashSet<(int, IMemberDefinition)>>();
            _fileOutputKind = fileOutputKind;
            _context = context;
        }
 
        public bool IsEmpty => _warnings.Count == 0;
 
        public void AddWarning(int code, ICustomAttributeProvider provider)
        {
            // We don't have a targeted suppression mechanism for
            // warnings from assembly-level attributes.
            if (provider is not IMemberDefinition memberDefinition)
                return;
 
            if (UnconditionalSuppressMessageAttributeState.GetModuleFromProvider(provider) is not ModuleDefinition module)
                return;
 
            var assemblyName = module.Assembly.Name;
            if (!_warnings.TryGetValue(assemblyName, out var warnings))
            {
                warnings = new HashSet<(int, IMemberDefinition)>();
                _warnings.Add(assemblyName, warnings);
            }
 
            warnings.Add((code, memberDefinition));
        }
 
        public void OutputSuppressions(string directory)
        {
            foreach (var assemblyName in _warnings.Keys)
            {
                if (_fileOutputKind == FileOutputKind.Xml)
                {
                    OutputSuppressionsXmlFormat(assemblyName, directory);
                }
                else
                {
                    OutputSuppressionsCSharpFormat(assemblyName, directory);
                }
            }
        }
 
        void OutputSuppressionsXmlFormat(AssemblyNameDefinition assemblyName, string directory)
        {
            var xmlTree = new XElement("linker");
            var xmlAssembly = new XElement("assembly", new XAttribute("fullname", assemblyName.FullName));
            xmlTree.Add(xmlAssembly);
 
            foreach (var warning in GetListOfWarnings(assemblyName))
            {
                xmlAssembly.Add(
                    new XElement("attribute",
                        new XAttribute("fullname", "System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute"),
                        new XElement("argument", Constants.ILLink),
                        new XElement("argument", $"IL{warning.Code}"),
                        new XElement("property", new XAttribute("name", UnconditionalSuppressMessageAttributeState.ScopeProperty),
                            GetWarningSuppressionScopeString(warning.MemberDocumentationSignature)),
                        new XElement("property", new XAttribute("name", UnconditionalSuppressMessageAttributeState.TargetProperty),
                            warning.MemberDocumentationSignature)));
            }
 
            XDocument xdoc = new XDocument(xmlTree);
            using (var xw = XmlWriter.Create(Path.Combine(directory, $"{assemblyName.Name}.WarningSuppressions.xml"),
                new XmlWriterSettings { Indent = true }))
            {
                xdoc.Save(xw);
            }
        }
 
        void OutputSuppressionsCSharpFormat(AssemblyNameDefinition assemblyName, string directory)
        {
            using (var sw = new StreamWriter(Path.Combine(directory, $"{assemblyName.Name}.WarningSuppressions.cs")))
            {
                StringBuilder sb = new StringBuilder("using System.Diagnostics.CodeAnalysis;").AppendLine().AppendLine();
                foreach (var warning in GetListOfWarnings(assemblyName))
                {
                    sb.Append("[assembly: UnconditionalSuppressMessage(\"")
                        .Append(Constants.ILLink)
                        .Append("\", \"IL").Append(warning.Code)
                        .Append("\", Scope = \"").Append(GetWarningSuppressionScopeString(warning.MemberDocumentationSignature))
                        .Append("\", Target = \"").Append(warning.MemberDocumentationSignature)
                        .AppendLine("\")]");
                }
 
                sw.Write(sb.ToString());
            }
        }
 
        List<(int Code, string MemberDocumentationSignature)> GetListOfWarnings(AssemblyNameDefinition assemblyName)
        {
            List<(int Code, string MemberDocumentationSignature)> listOfWarnings = new List<(int Code, string MemberDocumentationSignature)>();
            StringBuilder sb = new StringBuilder();
            foreach (var warning in _warnings[assemblyName].ToList())
            {
                DocumentationSignatureGenerator.VisitMember(warning.Member, sb, _context);
                listOfWarnings.Add((warning.Code, sb.ToString()));
                sb.Clear();
            }
 
            listOfWarnings.Sort();
            return listOfWarnings;
        }
 
        static string GetWarningSuppressionScopeString(string memberDocumentationSignature)
        {
            if (memberDocumentationSignature.StartsWith(DocumentationSignatureGenerator.TypePrefix))
                return "type";
 
            return "member";
        }
 
        public enum FileOutputKind
        {
            CSharp,
            Xml
        };
    }
}