// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.Collections.Immutable;
using System.Diagnostics;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using Microsoft.DotNet.FileBasedPrograms;

namespace Microsoft.DotNet.Cli.Commands.Run;

/// <summary>
/// A helper to perform edits of file-based app C# source files (e.g., updating the directives).
/// </summary>
internal sealed class FileBasedAppSourceEditor
{
    public SourceFile SourceFile
    {
        get;
        private set
        {
            field = value;

            // Make sure directives are reloaded next time they are accessed.
            Directives = default;
        }
    }

    public ImmutableArray<CSharpDirective> Directives
    {
        get
        {
            if (field.IsDefault)
            {
                field = FileLevelDirectiveHelpers.FindDirectives(SourceFile, reportAllErrors: false, ErrorReporters.IgnoringReporter);
                Debug.Assert(!field.IsDefault);
            }

            return field;
        }
        private set
        {
            field = value;
        }
    }

    public required string NewLine { get; init; }

    private FileBasedAppSourceEditor() { }

    public static FileBasedAppSourceEditor Load(SourceFile sourceFile)
    {
        return new FileBasedAppSourceEditor
        {
            SourceFile = sourceFile,
            NewLine = GetNewLine(sourceFile.Text),
        };

        static string GetNewLine(SourceText text)
        {
            // Try to detect existing line endings.
            string firstLine = text.Lines is [{ } line, ..]
                ? text.ToString(line.SpanIncludingLineBreak)
                : string.Empty;
            return firstLine switch
            {
                [.., '\r', '\n'] => "\r\n",
                [.., '\n'] => "\n",
                [.., '\r'] => "\r",
                [.., '\u0085'] => "\u0085",
                [.., '\u2028'] => "\u2028",
                [.., '\u2029'] => "\u2029",
                _ => Environment.NewLine,
            };
        }
    }

    public void Add(CSharpDirective directive)
    {
        var change = DetermineAddChange(directive);
        SourceFile = SourceFile with { Text = SourceFile.Text.WithChanges([change]) };
    }

    private TextChange DetermineAddChange(CSharpDirective directive)
    {
        // Find one that has the same kind and name.
        // If found, we will replace it with the new directive.
        var named = directive as CSharpDirective.Named;
        if (named != null &&
            Directives.OfType<CSharpDirective.Named>().FirstOrDefault(d => NamedDirectiveComparer.Instance.Equals(d, named)) is { } toReplace)
        {
            return new TextChange(toReplace.Info.Span, newText: directive.ToString() + NewLine);
        }

        // Find the last directive of the first group of directives of the same kind.
        // If found, we will insert the new directive after it.
        CSharpDirective? addAfter = null;
        foreach (var existingDirective in Directives)
        {
            if (existingDirective.GetType() == directive.GetType())
            {
                // Add named directives in sorted order.
                if (named != null &&
                    existingDirective is CSharpDirective.Named existingNamed &&
                    string.CompareOrdinal(existingNamed.Name, named.Name) > 0)
                {
                    break;
                }

                addAfter = existingDirective;
            }
            else if (addAfter != null)
            {
                break;
            }
        }

        if (addAfter != null)
        {
            var span = new TextSpan(start: addAfter.Info.Span.End, length: 0);
            return new TextChange(span, newText: directive.ToString() + NewLine);
        }

        // Otherwise, we will add the directive to the top of the file.
        int start = 0;

        var tokenizer = FileLevelDirectiveHelpers.CreateTokenizer(SourceFile.Text);
        var result = tokenizer.ParseNextToken();
        var leadingTrivia = result.Token.LeadingTrivia;

        // If there is a comment or #! at the top of the file, we add the directive after it
        // (the comment might be a license which should always stay at the top).
        int insertAfterIndex = -1;
        int trailingNewLines = 0;
        for (int i = 0; i < leadingTrivia.Count; i++)
        {
            var trivia = leadingTrivia[i];

            switch (trivia.Kind())
            {
                case SyntaxKind.SingleLineCommentTrivia:
                case SyntaxKind.MultiLineCommentTrivia:
                case SyntaxKind.MultiLineDocumentationCommentTrivia:
                    // Do not consider block comments that do not end with a line break (unless at the end of the file).
                    if (result.Token.IsKind(SyntaxKind.EndOfFileToken))
                    {
                        insertAfterIndex = i;
                    }
                    else if (i < leadingTrivia.Count - 1 &&
                        leadingTrivia[i + 1].IsKind(SyntaxKind.EndOfLineTrivia))
                    {
                        i++;
                        trailingNewLines = 1;
                        insertAfterIndex = i;
                    }
                    else
                    {
                        Debug.Assert(!trivia.IsKind(SyntaxKind.SingleLineCommentTrivia),
                            "Only block comments might not end with a line break.");
                    }
                    break;

                case SyntaxKind.SingleLineDocumentationCommentTrivia:
                    if (trivia.GetStructure() is DocumentationCommentTriviaSyntax s &&
                        s.ChildNodes().LastOrDefault() is XmlTextSyntax { TextTokens: [.., { RawKind: (int)SyntaxKind.XmlTextLiteralNewLineToken }] })
                    {
                        trailingNewLines = 1;
                        insertAfterIndex = i;
                    }
                    break;

                case SyntaxKind.ShebangDirectiveTrivia:
                    trailingNewLines = 1; // shebang trivia has one newline embedded in its structure
                    insertAfterIndex = i;
                    break;

                case SyntaxKind.EndOfLineTrivia:
                    if (insertAfterIndex >= 0)
                    {
                        trailingNewLines++;
                        insertAfterIndex = i;
                    }
                    break;

                case SyntaxKind.WhitespaceTrivia:
                    break;

                default:
                    i = leadingTrivia.Count; // Break the loop.
                    break;
            }
        }

        string prefix = string.Empty;
        string suffix = NewLine;

        if (insertAfterIndex >= 0)
        {
            var insertAfter = leadingTrivia[insertAfterIndex];
            start = insertAfter.FullSpan.End;

            // Add newline after the comment if there is not one already (can happen at the end of file).
            if (trailingNewLines < 1)
            {
                prefix += NewLine;
            }

            // Add a blank separating line between the comment and the directive (unless there is already one).
            if (trailingNewLines < 2)
            {
                prefix += NewLine;
            }
        }

        // Add a blank line after the directive unless there are no other tokens (i.e., the first token is EOF),
        // or there is already a blank line or another directive before the first C# token.
        var remainingLeadingTrivia = leadingTrivia.Skip(insertAfterIndex + 1);
        if (!(result.Token.IsKind(SyntaxKind.EndOfFileToken) && !remainingLeadingTrivia.Any() && !result.Token.HasTrailingTrivia) &&
            !remainingLeadingTrivia.Any(static t => t.Kind() is SyntaxKind.EndOfLineTrivia or SyntaxKind.IgnoredDirectiveTrivia))
        {
            suffix += NewLine;
        }

        return new TextChange(new TextSpan(start: start, length: 0), newText: prefix + directive.ToString() + suffix);
    }

    public void Remove(CSharpDirective directive)
    {
        var span = directive.Info.Span;
        var start = span.Start;
        var length = span.Length;

        DetermineWhiteSpaceToRemove(directive, out int leadingLength, out int trailingLength);
        start -= leadingLength;
        length += trailingLength;

        SourceFile = SourceFile with { Text = SourceFile.Text.Replace(start: start, length: length, newText: string.Empty) };
    }

    private static void DetermineWhiteSpaceToRemove(CSharpDirective directive, out int leadingLength, out int trailingLength)
    {
        // If there are blank lines both before and after the directive, remove the trailing blank lines.
        if (directive.Info.LeadingWhiteSpace.BlankLineLength > 0 && directive.Info.TrailingWhiteSpace.BlankLineLength > 0)
        {
            leadingLength = 0;
            trailingLength = directive.Info.TrailingWhiteSpace.BlankLineLength;
            return;
        }

        // If the directive (including leading white space) starts at the beginning of the file,
        // remove both the leading and trailing blank lines.
        var startBeforeWhiteSpace = directive.Info.Span.Start - directive.Info.LeadingWhiteSpace.BlankLineLength;
        if (startBeforeWhiteSpace == 0)
        {
            leadingLength = directive.Info.LeadingWhiteSpace.BlankLineLength;
            trailingLength = directive.Info.TrailingWhiteSpace.BlankLineLength;
            return;
        }

        Debug.Assert(startBeforeWhiteSpace > 0);
        leadingLength = 0;
        trailingLength = 0;
    }
}