// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Text;
 
namespace Microsoft.AspNetCore.Razor.Language.Intermediate;
 
public sealed class IntermediateNodeFormatter(
    StringBuilder builder,
    IntermediateNodeFormatter.FormatterMode mode = IntermediateNodeFormatter.FormatterMode.PreferContent,
    bool includeSource = false)
{
    // Depending on the usage of the formatter we might prefer thoroughness (properties)
    // or brevity (content). Generally if a node has a single string that provides value
    // it has content.
    //
    // Some nodes have neither: TagHelperBody
    // Some nodes have content: HtmlContent
    // Some nodes have properties: Document
    // Some nodes have both: TagHelperProperty
    public enum FormatterMode
    {
        PreferContent,
        PreferProperties,
    }
 
    private static readonly Dictionary<Type, string> s_nodeTypeToShortNameMap = [];
 
    private static readonly char[] s_charsToEscape = ['\r', '\n', '\t'];
 
    private readonly StringBuilder _builder = builder;
    private readonly FormatterMode Mode = mode;
    private readonly bool _includeSource = includeSource;
 
    private readonly Dictionary<string, string> _properties = new(StringComparer.Ordinal);
    private string? _content;
 
    private static string GetNodeShortName(IntermediateNode node)
    {
        lock (s_nodeTypeToShortNameMap)
        {
            return s_nodeTypeToShortNameMap.GetOrAdd(node.GetType(), ComputeShortName);
        }
 
        static string ComputeShortName(Type type)
        {
            const string ShortNameSuffix = nameof(IntermediateNode);
 
            var shortName = type.Name;
 
            if (shortName.EndsWith(ShortNameSuffix, StringComparison.Ordinal))
            {
                shortName = shortName[..^ShortNameSuffix.Length];
            }
 
            return shortName;
        }
    }
 
    public void WriteChildren(IntermediateNodeCollection children)
    {
        Debug.Assert(children != null);
 
        _builder.Append(" \"");
 
        foreach (var child in children)
        {
            if (child is IntermediateToken token)
            {
                WriteEscaped(token.Content);
            }
        }
 
        _builder.Append('"');
    }
 
    public void WriteContent(string? content)
    {
        if (content != null)
        {
            _content = content;
        }
    }
 
    public void WriteProperty(string key, string? value)
    {
        Debug.Assert(key != null);
 
        if (value != null)
        {
            _properties.Add(key, value);
        }
    }
 
    public void FormatNode(IntermediateNode node)
    {
        _builder.Append(GetNodeShortName(node));
 
        if (_includeSource)
        {
            _builder.Append(' ');
            _builder.Append(node.Source?.ToString() ?? "(n/a)");
        }
 
        node.FormatNode(this);
 
        if (ShouldWriteContent())
        {
            _builder.Append(" \"");
            WriteEscaped(_content);
            _builder.Append('"');
        }
 
        if (ShouldWriteProperties())
        {
            _builder.Append(" { ");
 
            var first = true;
 
            foreach (var (key, value) in _properties)
            {
                if (first)
                {
                    first = false;
                }
                else
                {
                    _builder.Append(", ");
                }
 
                _builder.Append(key);
                _builder.Append(": \"");
                WriteEscaped(value);
                _builder.Append('"');
            }
 
            _builder.Append(" }");
        }
 
        _content = null;
        _properties.Clear();
    }
 
    [MemberNotNullWhen(true, nameof(_content))]
    private bool ShouldWriteContent()
        => _content != null && (_properties.Count == 0 || Mode == FormatterMode.PreferContent);
 
    private bool ShouldWriteProperties()
        => _properties.Count > 0 && (_content == null || Mode == FormatterMode.PreferContent);
 
    public void FormatTree(IntermediateNode node)
    {
        var visitor = new FormatterVisitor(this);
        visitor.Visit(node);
    }
 
    private void Write(char value, int repeatCount)
    {
        _builder.Append(value, repeatCount);
    }
 
    private void WriteLine()
    {
        _builder.AppendLine();
    }
 
    private void WriteEscaped(string content)
    {
        var startIndex = 0;
        int charToEscapeIndex;
 
        while ((charToEscapeIndex = content.IndexOfAny(s_charsToEscape, startIndex)) >= 0)
        {
            if (startIndex < charToEscapeIndex)
            {
                _builder.Append(content, startIndex, charToEscapeIndex - startIndex);
            }
 
            switch (content[charToEscapeIndex])
            {
                case '\r':
                    _builder.Append("\\r");
                    break;
                case '\n':
                    _builder.Append("\\n");
                    break;
                case '\t':
                    _builder.Append("\\t");
                    break;
            }
 
            startIndex = charToEscapeIndex + 1;
        }
 
        if (startIndex < content.Length)
        {
            _builder.Append(content, startIndex, content.Length - startIndex);
        }
    }
 
    private sealed class FormatterVisitor(IntermediateNodeFormatter formatter) : IntermediateNodeWalker
    {
        private const int IndentSize = 2;
 
        private readonly IntermediateNodeFormatter _formatter = formatter;
        private int _indent;
 
        public override void VisitDefault(IntermediateNode node)
        {
            // Indent
            _formatter.Write(' ', repeatCount: _indent);
 
            _formatter.FormatNode(node);
            _formatter.WriteLine();
 
            // Process children
            _indent += IndentSize;
            base.VisitDefault(node);
            _indent -= IndentSize;
        }
    }
}