using System.Text;
using System.Text.Encodings.Web;

namespace Nuuru.Server.Services.BBCode
{
    public record QuoteSourceInfo(string? AuthorName, string? OriginalContent);

    public class BbRenderer
    {
        private readonly IQuoteChecksumService? _quoteService;
        private readonly Func<string, string, QuoteSourceInfo>? _lookupSource;
        private readonly Func<string, string?>? _lookupAvatar;

        public BbRenderer(
            IQuoteChecksumService? quoteService = null,
            Func<string, string, QuoteSourceInfo>? lookupSource = null,
            Func<string, string?>? lookupAvatar = null)
        {
            _quoteService = quoteService;
            _lookupSource = lookupSource;
            _lookupAvatar = lookupAvatar;
        }

        public string Render(List<BbNode> nodes)
        {
            var sb = new StringBuilder();
            foreach (var node in nodes)
            {
                sb.Append(RenderNode(node));
            }
            return sb.ToString();
        }

        private string RenderNode(BbNode node)
        {
            return node switch
            {
                TextNode t => HtmlEncode(t.Content),
                NewlineNode => "<br>",
                ElementNode e => RenderElement(e),
                ThumbNode t => RenderThumb(t),
                UrlNode u => RenderUrl(u),
                QuoteNode q => RenderQuote(q),
                MentionNode m => RenderMention(m),
                AttachmentNode a => RenderAttachment(a),
                EmoteNode em => RenderEmote(em),
                _ => ""
            };
        }

        private string RenderElement(ElementNode node)
        {
            var (openTag, closeTag) = GetHtmlTags(node.Tag, node.Attribute);

            if (openTag == null)
            {
                // Unknown tag - render as text with children
                var tagText = node.Attribute != null
                    ? $"[{node.Tag}={node.Attribute}]"
                    : $"[{node.Tag}]";
                return HtmlEncode(tagText) + RenderChildren(node.Children) + HtmlEncode($"[/{node.Tag}]");
            }

            // Greentext/orangetext lines need the > / < prefix before children
            var prefix = node is { Attribute: "line", Tag: "greentext" } ? "&gt;"
                       : node is { Attribute: "line", Tag: "orangetext" } ? "&lt;"
                       : "";

            return openTag + prefix + RenderChildren(node.Children) + closeTag;
        }

        private string RenderChildren(List<BbNode> children)
        {
            var sb = new StringBuilder();
            foreach (var child in children)
            {
                sb.Append(RenderNode(child));
            }
            return sb.ToString();
        }

        private (string? open, string? close) GetHtmlTags(string tag, string? attribute)
        {
            return tag.ToLowerInvariant() switch
            {
                // Basic formatting
                "b" => ("<strong>", "</strong>"),
                "i" => ("<em>", "</em>"),
                "s" => ("<del>", "</del>"),
                "u" => ("<span class=\"bbcode-underline\">", "</span>"),

                // Code
                "code" => ("<pre class=\"bbcode-code\"><code>", "</code></pre>"),
                "inline" => ("<code class=\"bbcode-inline\">", "</code>"),

                // Headings
                "h1" => ("<h1 class=\"bbcode-heading\">", "</h1>"),
                "h2" => ("<h2 class=\"bbcode-heading\">", "</h2>"),
                "h3" => ("<h3 class=\"bbcode-heading\">", "</h3>"),
                "h4" => ("<h4 class=\"bbcode-heading\">", "</h4>"),

                // Sub/Superscript
                "sub" => ("<sub>", "</sub>"),
                "sup" => ("<sup>", "</sup>"),

                // Special effects
                "spoiler" => ("<span class=\"bbcode-spoiler\">", "</span>"),
                "blur" => ("<span class=\"bbcode-blur\">", "</span>"),

                // Font properties
                "color" => IsValidColor(attribute) ? ($"<span style=\"color:{attribute}\">", "</span>") : ("<span>", "</span>"),
                "size" => IsValidSize(attribute, out var size) ? ($"<span style=\"font-size:{size}\">", "</span>") : ("<span>", "</span>"),
                "font" => attribute != null && ValidFonts.Contains(attribute.Trim()) ? ($"<span style=\"font-family:'{attribute}'\">", "</span>") : ("<span>", "</span>"),
                "align" => (attribute is "left" or "right" or "center" or "justify" ? ($"<div style=\"text-align:{attribute}\">", "</div>") : ("<div style=\"text-align:left\">", "</div>")),
                "list" => (attribute == "1" ? ("<ol>", "</ol>") : ("<ul>", "</ul>")),
                "*" => ("<li>", "</li>"),

                // Colored text (tag versions)
                "greentext" => ("<span class=\"bbcode-greentext\">", "</span>"),
                "redtext" => ("<span class=\"bbcode-redtext\">", "</span>"),
                "orangetext" => ("<span class=\"bbcode-orangetext\">", "</span>"),
                "bluetext" => ("<span class=\"bbcode-bluetext\">", "</span>"),
                "glowtext" => ("<span class=\"bbcode-glow\">", "</span>"),
                "redglow" => ("<span class=\"bbcode-glow-red\">", "</span>"),
                "yellowglow" => ("<span class=\"bbcode-glow-yellow\">", "</span>"),
                "rainbow" => ("<span class=\"bbcode-rainbow\">", "</span>"),

                // URL with invalid/missing href renders as span
                "url" => ("<span class=\"bbcode-invalid-url\">", "</span>"),

                _ => (null, null)
            };
        }

        private string RenderThumb(ThumbNode node)
        {
            return $"<a href=\"/post/view/{node.PostId}\" class=\"bbcode-thumb\">" +
                   $"<img src=\"/api/booru/posts/{node.PostId}/thumbnail\" alt=\"Post #{node.PostId}\" loading=\"lazy\" />" +
                   "</a>";
        }

        private string RenderUrl(UrlNode node)
        {
            var href = HtmlEncode(node.Href);
            var content = RenderChildren(node.Children);
            return $"<a href=\"{href}\" class=\"bbcode-link\" rel=\"nofollow noopener\" target=\"_blank\">{content}</a>";
        }

        private string RenderMention(MentionNode node)
        {
            var userName = HtmlEncode(node.UserName);
            var href = (node.PostId, node.CommentId) switch
            {
                (int pid, int cid) => $"/post/view/{pid}#c{cid}",
                (int pid, null) => $"/post/view/{pid}",
                _ => $"/user/{userName}",
            };
            return $"<a href=\"{href}\" class=\"bbcode-mention\">@{userName}</a>";
        }

        private string RenderQuote(QuoteNode node)
        {
            var content = RenderChildren(node.Children);
            var hasValidSourceUrl = TryBuildQuoteSourceUrl(node, out var sourceUrl);

            // Simple quote without source reference (e.g. [quote=author] or [quote])
            if (string.IsNullOrEmpty(node.SourceType) || string.IsNullOrEmpty(node.SourceId) || !hasValidSourceUrl)
            {
                var simpleHeader = !string.IsNullOrEmpty(node.AuthorName)
                    ? $"<div class=\"bbcode-quote-header\"><span class=\"bbcode-quote-author\">{HtmlEncode(node.AuthorName)}</span></div>"
                    : "";
                return $"<blockquote class=\"bbcode-quote\">{simpleHeader}<div class=\"bbcode-quote-content\">{content}</div></blockquote>";
            }

            // Quote with source reference - attempt verification
            bool isVerified = false;
            string? authorName = node.AuthorName; // Use the author from the attribute first
            if (_quoteService != null && !string.IsNullOrEmpty(node.ProvidedHash))
            {
                // HMAC verification - the hash proves authenticity at quote-creation time
                var quotedText = ExtractTextContent(node.Children);
                isVerified = _quoteService.VerifyHash(
                    node.SourceType, node.SourceId, quotedText, node.ProvidedHash);
            }

            // Optionally look up author name if not provided in attribute
            if (_lookupSource != null && string.IsNullOrEmpty(authorName))
            {
                var sourceInfo = _lookupSource(node.SourceType, node.SourceId);
                authorName = sourceInfo.AuthorName;
            }

            var verificationClass = isVerified ? "bbcode-quote-verified" : "bbcode-quote-unverified";
            var badge = isVerified ? "" : "<span class=\"bbcode-quote-warning\">unverified</span>";

            // Build header with avatar, author name, and go-to-post button
            var headerContent = "";
            if (!string.IsNullOrEmpty(authorName))
            {
                var avatarImg = RenderAvatarImg(authorName);
                headerContent = $"{avatarImg}<span class=\"bbcode-quote-author\">{HtmlEncode(authorName)}</span>";
            }

            // Add the go-to-post button
            var goToButton = $"<a href=\"{sourceUrl}\" class=\"bbcode-quote-link\" title=\"Go to original post\">↗</a>";

            var header = $"<div class=\"bbcode-quote-header\">{headerContent}{goToButton}{badge}</div>";

            return $"<blockquote class=\"bbcode-quote {verificationClass}\">{header}" +
                   $"<div class=\"bbcode-quote-content\">{content}</div></blockquote>";
        }

        private string RenderAvatarImg(string authorName)
        {
            var avatarUrl = _lookupAvatar?.Invoke(authorName);
            if (avatarUrl == null) return "";
            return $"<img src=\"{HtmlEncode(avatarUrl)}\" class=\"bbcode-quote-avatar\" alt=\"\" />";
        }

        private static bool TryBuildQuoteSourceUrl(QuoteNode node, out string sourceUrl)
        {
            sourceUrl = "";

            if (node.SourceType == "forum" && int.TryParse(node.SourceId, out var postId) && postId > 0)
            {
                sourceUrl = $"#p{postId}";
                return true;
            }

            if (node.SourceType == "comment" && int.TryParse(node.SourceId, out var commentId) && commentId > 0)
            {
                sourceUrl = $"#c{commentId}";
                return true;
            }

            return false;
        }

        private static string ExtractTextContent(List<BbNode> nodes)
        {
            var sb = new StringBuilder();
            foreach (var node in nodes)
            {
                switch (node)
                {
                    case TextNode t:
                        sb.Append(t.Content);
                        break;
                    case NewlineNode:
                        sb.Append('\n');
                        break;
                    case ElementNode e:
                        sb.Append(ExtractTextContent(e.Children));
                        break;
                    case QuoteNode q:
                        sb.Append(ExtractTextContent(q.Children));
                        break;
                    case UrlNode u:
                        sb.Append(ExtractTextContent(u.Children));
                        break;
                    case MentionNode m:
                        sb.Append('@');
                        sb.Append(m.UserName);
                        break;
                    case EmoteNode em:
                        sb.Append(':');
                        sb.Append(em.Name);
                        sb.Append(':');
                        break;
                    case AttachmentNode:
                        // Attachments don't contribute to plain text
                        break;
                }
            }
            return sb.ToString();
        }

        private static string RenderAttachment(AttachmentNode node)
        {
            var src = node.IsThumbnail
                ? $"/api/forum/attachments/{node.AttachmentId}/thumb"
                : $"/api/forum/attachments/{node.AttachmentId}/file";

            var styleParts = new List<string>();
            if (node.Width.HasValue) styleParts.Add($"width:{node.Width}px");
            if (node.Height.HasValue) styleParts.Add($"height:{node.Height}px");
            if (!node.Width.HasValue && !node.Height.HasValue && !node.IsThumbnail)
            {
                styleParts.Add("max-width:100%");
                styleParts.Add("height:auto");
            }

            var style = styleParts.Count > 0 ? $" style=\"{string.Join(";", styleParts)}\"" : "";

            return $"<a href=\"/api/forum/attachments/{node.AttachmentId}/file\" class=\"bbcode-attachment\" target=\"_blank\">" +
                   $"<img src=\"{src}\"{style} loading=\"lazy\" data-attachment-id=\"{node.AttachmentId}\" />" +
                   "</a>";
        }

        private static string RenderEmote(EmoteNode node)
        {
            var name = HtmlEncode(node.Name);
            return $"<span class=\"bbcode-emote\" data-emote=\"{name}\">:{name}:</span>";
        }

        private static readonly HashSet<string> ValidFonts = new(StringComparer.OrdinalIgnoreCase)
        {
            // Serif
            "serif", "Georgia", "Palatino Linotype", "Book Antiqua", "Palatino", "Times New Roman", "Times",
            "Garamond", "Bookman", "Constantia", "Lucida Bright", "Baskerville", "Big Caslon", "Bodoni MT",
            "Cambria", "Cochin", "Didot", "Footlight MT Light", "High Tower Text", "Hoefler Text", "Libre Baskerville",
            "Lora", "Merriweather", "Playfair Display", "PT Serif", "Rockwell", "Sitka",

            // Generic / System
            "monospace", "cursive", "fantasy", "system-ui", "TransLibri",

            // Sans-Serif
            "sans-serif", "Arial", "Helvetica", "Arial Black", "Gadget", "Trebuchet MS", "Verdana", "Geneva",
            "Tahoma", "MS Sans Serif", "Segoe UI", "Calibri", "Candara", "Impact", "Charcoal",
            "Gill Sans", "Optima", "Lucida Sans Unicode", "Lucida Grande", "Open Sans", "Roboto", "Lato",
            "Montserrat", "Oswald", "Source Sans Pro", "Raleway", "PT Sans", "Nunito", "Muli", "Ubuntu",
            "Fira Sans", "Droid Sans", "Noto Sans", "Quicksand", "Karla", "Work Sans", "Avenir", "Century Gothic",
            "Dejavu Sans", "Franklin Gothic Medium", "Futura", "Inter", "Josefin Sans", "Maven Pro", "Poppins",

            // Monospace
            "monospace", "Courier New", "Courier", "Lucida Console", "Monaco", "Consolas", "Andale Mono",
            "DejaVu Sans Mono", "Liberation Mono", "Fira Code", "Source Code Pro", "Inconsolata", "Ubuntu Mono",
            "Courier Prime", "Menlo", "Terminal",

            // Cursive & Decorative
            "cursive", "Comic Sans MS", "Comic Sans", "Brush Script MT", "Apple Chancery", "fantasy", "Copperplate",
            "Papyrus", "Lobster", "Pacifico", "Dancing Script", "Caveat", "Satisfy", "Courgette", "Amatic SC",
            "Bangers", "Fredoka One", "Great Vibes", "Kaushan Script", "Permanent Marker", "Sacramento", "Yellowtail"
        };

        private static bool IsValidColor(string? color)
        {
            if (string.IsNullOrEmpty(color) || color.Length > 20) return false;
            if (color[0] == '#')
            {
                return (color.Length is 4 or 7) && color[1..].All(char.IsAsciiHexDigit);
            }
            return color.All(char.IsLetter);
        }

        private static bool IsValidSize(string? size, out string normalized)
        {
            normalized = "";
            if (string.IsNullOrEmpty(size) || size.Length > 10) return false;

            int i = 0;
            while (i < size.Length && char.IsDigit(size[i])) i++;
            if (i == 0) return false;

            if (!int.TryParse(size.AsSpan(0, i), out int val)) return false;

            string unit = size[i..].Trim().ToLowerInvariant();
            if (string.IsNullOrEmpty(unit)) unit = "%";

            bool valid = unit switch
            {
                "%" => val is >= 50 and <= 300,
                "px" => val is >= 8 and <= 100,
                "pt" => val is >= 8 and <= 72,
                "em" => val is >= 1 and <= 5,
                _ => false
            };

            if (valid)
            {
                normalized = $"{val}{unit}";
                return true;
            }
            return false;
        }

        private static string HtmlEncode(string text) => HtmlEncoder.Default.Encode(text);
    }
}