// 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;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using ILLink.RoslynAnalyzer;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editing;
using Microsoft.CodeAnalysis.Simplification;
 
namespace ILLink.CodeFix
{
	public abstract class BaseAttributeCodeFixProvider : Microsoft.CodeAnalysis.CodeFixes.CodeFixProvider
	{
		private protected abstract LocalizableString CodeFixTitle { get; }
 
		private protected abstract string FullyQualifiedAttributeName { get; }
 
		private protected abstract AttributeableParentTargets AttributableParentTargets { get; }
 
		public sealed override FixAllProvider GetFixAllProvider ()
		{
			// See https://github.com/dotnet/roslyn/blob/master/docs/analyzers/FixAllProvider.md for more information on Fix All Providers
			return WellKnownFixAllProviders.BatchFixer;
		}
 
		protected async Task BaseRegisterCodeFixesAsync (CodeFixContext context)
		{
			var document = context.Document;
			var diagnostic = context.Diagnostics.First ();
			var codeFixTitle = CodeFixTitle.ToString ();
 
			if (await document.GetSyntaxRootAsync (context.CancellationToken).ConfigureAwait (false) is not { } root)
				return;
 
			SyntaxNode targetNode = root.FindNode (diagnostic.Location.SourceSpan, getInnermostNodeForTie: true);
			if (FindAttributableParent (targetNode, AttributableParentTargets) is not SyntaxNode attributableNode)
				return;
 
			context.RegisterCodeFix (CodeAction.Create (
				title: codeFixTitle,
				createChangedDocument: ct => AddAttributeAsync (
					document, diagnostic, targetNode, attributableNode, ct),
				equivalenceKey: codeFixTitle), diagnostic);
		}
 
		private async Task<Document> AddAttributeAsync (
			Document document,
			Diagnostic diagnostic,
			SyntaxNode targetNode,
			SyntaxNode attributableNode,
			CancellationToken cancellationToken)
		{
			if (await document.GetSemanticModelAsync (cancellationToken).ConfigureAwait (false) is not { } model)
				return document;
			if (model.GetSymbolInfo (targetNode, cancellationToken).Symbol is not { } targetSymbol)
				return document;
			if (model.Compilation.GetBestTypeByMetadataName (FullyQualifiedAttributeName) is not { } attributeSymbol)
				return document;
 
			// N.B. May be null for FieldDeclaration, since field declarations can declare multiple variables
			var attributableSymbol = model.GetDeclaredSymbol (attributableNode, cancellationToken);
 
			var attributeArguments = GetAttributeArguments (attributableSymbol, targetSymbol, SyntaxGenerator.GetGenerator (document), diagnostic);
 
			var editor = await DocumentEditor.CreateAsync (document, cancellationToken).ConfigureAwait (false);
			var generator = editor.Generator;
			var attribute = generator.Attribute (
				generator.TypeExpression (attributeSymbol), attributeArguments)
				.WithAdditionalAnnotations (Simplifier.Annotation, Simplifier.AddImportsAnnotation);
 
			editor.AddAttribute (attributableNode, attribute);
			return editor.GetChangedDocument ();
		}
 
		[Flags]
		protected enum AttributeableParentTargets
		{
			MethodOrConstructor = 0x0001,
			Property = 0x0002,
			Field = 0x0004,
			Event = 0x0008,
			Class = 0x0010,
			All = MethodOrConstructor | Property | Field | Event | Class
		}
 
		private static CSharpSyntaxNode? FindAttributableParent (SyntaxNode node, AttributeableParentTargets targets)
		{
			SyntaxNode? parentNode = node.Parent;
			while (parentNode is not null) {
				switch (parentNode) {
				case LambdaExpressionSyntax:
					return null;
 
				case PropertyDeclarationSyntax when targets.HasFlag (AttributeableParentTargets.Property):
				case EventDeclarationSyntax when targets.HasFlag (AttributeableParentTargets.Event):
					return (CSharpSyntaxNode) parentNode;
				case PropertyDeclarationSyntax:
				case EventDeclarationSyntax:
					// If the attribute can be placed on a method but not directly on a property/event, we don't want to keep walking up
					// the syntax tree to annotate the class. Instead the correct thing to do is to add accessor methods and annotate those.
					// The code fixer doesn't support doing this automatically, so return null to indicate that the attribute can't be added.
					if (targets.HasFlag (AttributeableParentTargets.MethodOrConstructor))
						return null;
 
					parentNode = parentNode.Parent;
					break;
				case LocalFunctionStatementSyntax or BaseMethodDeclarationSyntax or AccessorDeclarationSyntax when targets.HasFlag (AttributeableParentTargets.MethodOrConstructor):
				case FieldDeclarationSyntax when targets.HasFlag (AttributeableParentTargets.Field):
				case ClassDeclarationSyntax when targets.HasFlag (AttributeableParentTargets.Class):
					return (CSharpSyntaxNode) parentNode;
 
				default:
					parentNode = parentNode.Parent;
					break;
				}
			}
 
			return null;
		}
 
		protected abstract SyntaxNode[] GetAttributeArguments (
			ISymbol? attributableSymbol,
			ISymbol targetSymbol,
			SyntaxGenerator syntaxGenerator,
			Diagnostic diagnostic);
 
		protected static bool HasPublicAccessibility (ISymbol? m)
		{
			if (m is not { DeclaredAccessibility: Accessibility.Public or Accessibility.Protected }) {
				return false;
			}
			for (var t = m.ContainingType; t is not null; t = t.ContainingType) {
				if (t.DeclaredAccessibility != Accessibility.Public) {
					return false;
				}
			}
			return true;
		}
	}
}