namespace Microsoft.CodeAnalysis.CodeRefactorings
{
    public readonly struct CodeRefactoringContext
    {
        /// <summary>
        /// TextDocument corresponding to the <see cref="CodeRefactoringContext.Span"/> to refactor.
        /// This property should be used instead of <see cref="CodeRefactoringContext.Document"/> property by
        /// code refactorings that support non-source documents by providing a non-default value for
        /// <see cref="ExportCodeRefactoringProviderAttribute.DocumentKinds"/>
        /// </summary>
        public TextDocument TextDocument { get; }

        /// <summary>
        /// Creates a code refactoring context to be passed into <see cref="CodeRefactoringProvider.ComputeRefactoringsAsync(CodeRefactoringContext)"/> method.
        /// </summary>
        public CodeRefactoringContext(TextDocument document, TextSpan span, Action<CodeAction> registerRefactoring, CancellationToken cancellationToken);
    }

    public sealed class ExportCodeRefactoringProviderAttribute : ExportAttribute
    {
        /// <summary>
        /// The document kinds for which this provider can provide refactorings. See <see cref="TextDocumentKind"/>.
        /// By default, the provider supports refactorings only for source documents, <see cref="TextDocumentKind.Document"/>.
        /// </summary>
        public TextDocumentKind[] DocumentKinds { get; set; }

        /// <summary>
        /// The document extensions for which this provider can provide refactorings.
        /// By default, this value is null and the document extension is not considered to determine applicability of refactorings.
        /// </summary>
        public string[]? DocumentExtensions { get; set; }
    }
}

namespace Microsoft.CodeAnalysis.CodeFixes
{
    public readonly struct CodeFixContext
    {
        /// <summary>
        /// TextDocument corresponding to the <see cref="Span"/> to fix.
        /// This property should be used instead of <see cref="Document"/> property by
        /// code fixes that support non-source documents by providing a non-default value for
        /// <see cref="ExportCodeFixProviderAttribute.DocumentKinds"/>
        /// </summary>
        public TextDocument TextDocument { get; }

        /// <summary>
        /// Creates a code fix context to be passed into <see cref="CodeFixProvider.RegisterCodeFixesAsync(CodeFixContext)"/> method.
        /// </summary>
        /// <param name="document">Text document to fix.</param>
        /// <param name="diagnostic">
        /// Diagnostic to fix.
        /// The <see cref="Diagnostic.Id"/> of this diagnostic must be in the set of the <see cref="CodeFixProvider.FixableDiagnosticIds"/> of the associated <see cref="CodeFixProvider"/>.
        /// </param>
        /// <param name="registerCodeFix">Delegate to register a <see cref="CodeAction"/> fixing a subset of diagnostics.</param>
        /// <param name="cancellationToken">Cancellation token.</param>
        /// <exception cref="ArgumentNullException">Throws this exception if any of the arguments is null.</exception>
        public CodeFixContext(TextDocument document, Diagnostic diagnostic, Action<CodeAction, ImmutableArray<Diagnostic>> registerCodeFix, CancellationToken cancellationToken);
    }

    public sealed class ExportCodeFixProviderAttribute : ExportAttribute
    {
        /// <summary>
        /// The document kinds for which this provider can provide code fixes. See <see cref="TextDocumentKind"/>.
        /// By default, the provider supports code fixes only for source documents, <see cref="TextDocumentKind.Document"/>.
        /// </summary>
        public TextDocumentKind[] DocumentKinds { get; set; }

        /// <summary>
        /// The document extensions for which this provider can provide code fixes.
        /// By default, this value is null and the document extension is not considered to determine applicability of code fixes.
        /// </summary>
        public string[]? DocumentExtensions { get; set; }
    }
}

[ExportCodeRefactoringProvider(
    LanguageNames.CSharp,
    DocumentKinds = new[] { TextDocumentKind.AdditionalDocument, TextDocumentKind.AnalyzerConfigDocument },
    DocumentExtensions = new[] { ".xaml", ".txt", ".editorconfig", ".globalconfig" })]
[Shared]
internal sealed class MyRefactoring : CodeRefactoringProvider
{
    [ImportingConstructor]
    [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
    public MyRefactoring()
    {
    }

    public override Task ComputeRefactoringsAsync(CodeRefactoringContext context)
    {
        context.RegisterRefactoring(CodeAction.Create("My Refactoring",
            createChangedSolution: async ct =>
            {
                var document = context.TextDocument;
                var text = await document.GetTextAsync(ct).ConfigureAwait(false);
                var newText = SourceText.From(text.ToString() + Environment.NewLine + "# Refactored" + Environment.NewLine);
                if (document.Kind == TextDocumentKind.AdditionalDocument)
                    return document.Project.Solution.WithAdditionalDocumentText(document.Id, newText);
                return document.Project.Solution.WithAnalyzerConfigDocumentText(document.Id, newText);
            }));

        return Task.CompletedTask;
    }
}

    [ExportCodeFixProvider(
        LanguageNames.CSharp,
        DocumentKinds = new[] { TextDocumentKind.AdditionalDocument },
        DocumentExtensions = new[] { ".txt", ".xaml" })]
    [Shared]
    internal sealed class AdditionalFileCodeFixer : CodeFixProvider
    {
        [ImportingConstructor]
        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
        public AdditionalFileCodeFixer()
        {
        }

        public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create("My0001");

        public override Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            context.RegisterCodeFix(CodeAction.Create("My Code Fix",
                createChangedSolution: async ct =>
                {
                    var document = context.TextDocument;
                    var text = await document.GetTextAsync(ct).ConfigureAwait(false);
                    var newText = SourceText.From(text.ToString() + Environment.NewLine + "# Fixed" + Environment.NewLine);
                    return document.Project.Solution.WithAdditionalDocumentText(document.Id, newText);
                }),
                context.Diagnostics[0]);

            return Task.CompletedTask;
        }
    }