import { A_Caller, A_Feature, A_Inject } from "@adaas/a-concept";
import { A_Logger } from "@adaas/a-utils/a-logger";
import { AreNodeFeatures, AreNode, AreTokenizer, AreAttribute_Init, AreContext } from "@adaas/are";
import { AreComponentNode } from "@adaas/are-html/nodes/AreComponent";
import { AreRootNode } from "@adaas/are-html/nodes/AreRoot";
import { AreDirectiveAttribute } from "@adaas/are-html/attributes/AreDirective.attribute";
import { AreEventAttribute } from "@adaas/are-html/attributes/AreEvent.attribute";
import { AreBindingAttribute } from "@adaas/are-html/attributes/AreBinding.attribute";
import { AreStaticAttribute } from "@adaas/are-html/attributes/AreStatic.attribute";
import { AreHTMLAttribute } from "../lib/AreHTMLAttribute/AreHTML.attribute";
import { AreHTMLNode } from "../lib/AreHTMLNode/AreHTMLNode";
import { isStaticMarkup } from "./AreHTML.constants";
import { A_Frame } from "@adaas/a-frame/core";


@A_Frame.Define({
    namespace: 'a-are-html',
    description: 'HTML-specific tokenizer extending AreTokenizer. Parses raw HTML template strings into AreHTMLNode trees by scanning element tags and resolving directive ($), event (@), binding (:), and static attributes to their typed attribute classes, constructing AreComponentNode and AreRootNode instances where required.'
})
export class AreHTMLTokenizer extends AreTokenizer {

    ATTR_PATTERN = /([$:@]?[\w.-]+(?::[\w.-]+)?)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>/"'=]+)))?/g


    @A_Feature.Extend({
        name: AreNodeFeatures.onTokenize,
        scope: [AreComponentNode, AreRootNode]
    })
    tokenize(
        @A_Inject(A_Caller) node: AreNode,
        @A_Inject(AreContext) context: AreContext,
        @A_Inject(A_Logger) logger?: A_Logger
    ): void {

        /**
         * Static-island fast path.
         *
         * When a node's entire inner subtree is fully static — no `{{ }}`
         * interpolations, no dynamic (`$`/`:`/`@`) attributes and only standard
         * HTML tags — we skip exploding it into one child AreNode per element /
         * text run and instead capture the inner markup verbatim. The interpreter
         * later materialises it in a single pass (browser-parsed innerHTML /
         * cached `<template>` clone), which:
         *   - eliminates N node + scope + scene + instruction allocations,
         *   - collapses N isolated DOM mutations into one, and
         *   - decodes HTML entities (e.g. `&nbsp;`) for free.
         *
         * Routing outlets (AreRootNode) are intentionally excluded — they own
         * their content dynamically. The node's OWN attributes are still
         * extracted below, so a dynamic attribute on the island root itself
         * (e.g. `<div :class="x"> …static… </div>`) keeps working.
         */
        const isStaticIsland =
            node instanceof AreComponentNode &&
            !!node.content &&
            isStaticMarkup(node.content);

        if (isStaticIsland) {
            (node as AreHTMLNode).markStatic(node.content);
        } else {
            super.tokenize(node, context, logger);
        }

        context.startPerformance('attributeExtraction');

        const attributes = this.extractAttributes(node.markup);

        for (const attr of attributes) {
            node.scope.register(attr);
        }

        context.endPerformance('attributeExtraction');
    }



    extractAttributes(markup: string): AreHTMLAttribute[] {
        // Strip the tag name, then remove the closing > that is NOT inside quotes
        const withoutTag = markup.replace(/^<[a-zA-Z][a-zA-Z0-9-]*\s*/, '')

        // Walk the string to find the closing > that isn't inside a quoted value
        let inSingle = false
        let inDouble = false
        let endIdx = withoutTag.length

        for (let i = 0; i < withoutTag.length; i++) {
            const ch = withoutTag[i]
            if (ch === '"' && !inSingle) inDouble = !inDouble
            else if (ch === "'" && !inDouble) inSingle = !inSingle
            else if (ch === '>' && !inSingle && !inDouble) {
                endIdx = i
                break
            }
        }

        const attrString = withoutTag.slice(0, endIdx).replace(/\s*\/?\s*$/, '').trim()

        const results: AreHTMLAttribute[] = []

        for (const match of attrString.matchAll(this.ATTR_PATTERN)) {
            const raw = match[0]
            const full = match[1]                           // e.g. ':class', '@click', '$for', 'id'

            // skip zero-length or name-less regex matches
            if (!full) continue

            const value = match[2] ?? match[3] ?? match[4] ?? 'true'

            const prefix = full[0]
            const isSpecial = prefix === ':' || prefix === '@' || prefix === '$'
            const name = isSpecial ? full.slice(1) : full

            const meta: AreAttribute_Init = { name, content: value, raw, prefix: isSpecial ? prefix : '' }

            if (prefix === ':') results.push(new AreBindingAttribute(meta))
            else if (prefix === '@') results.push(new AreEventAttribute(meta))
            else if (prefix === '$') results.push(new AreDirectiveAttribute(meta))
            else results.push(new AreStaticAttribute(meta))
        }

        return results
    }

}