/**
 * SimonUp Core Compiler (Core.js) - Version 1.2b.003
 * Eine moderne, fluss- und blockorientierte Auszeichnungssprache.
 */
class SimonUp {
    constructor() {
        this.plugins = [];
        this.headings = [];
        this.counters = [0, 0, 0, 0, 0, 0];
    }

    /**
     * Registriert eine Erweiterung (Plugin)
     */
    use(plugin) {
        this.plugins.push(plugin);
        return this;
    }

    /**
     * Hauptfunktion: Wandelt SimonUp-Text (.up) in valides HTML um
     */
    parse(text) {
        this.headings = [];
        this.counters = [0, 0, 0, 0, 0, 0];

        let html = text;

        if (this.plugins && this.plugins.length > 0) {
            for (let i = 0; i < this.plugins.length; i++) {
                if (this.plugins[i].before) {
                    html = this.plugins[i].before(html);
                }
            }
        }

        // Phase 1: Blöcke und Inline-Strukturen parsen
        html = this._parseBlocks(html);
        
        // Phase 2: Das Inhaltsverzeichnis nachträglich in die vorbereitete Box einsetzen
        html = this._injectTOC(html);

        if (this.plugins && this.plugins.length > 0) {
            for (let i = 0; i < this.plugins.length; i++) {
                if (this.plugins[i].after) {
                    html = this.plugins[i].after(html);
                }
            }
        }

        return html;
    }

    /**
     * INTERN: Verarbeitet strukturelle Blöcke und freie Strukturen zeilenweise
     */
    _parseBlocks(text) {
        const lines = text.replace(/\r\n/g, '\n').split('\n');
        let result = [];
        let inBlock = false;
        let blockType = null;
        let blockMeta = ""; 
        let blockBuffer = [];

        for (let i = 0; i < lines.length; i++) {
            let line = lines[i];

            // Block-Start erkennen (&typ meta)
            if (!inBlock && line.startsWith('&') && line.trim().length > 1) {
                inBlock = true;
                const fullHeader = line.substring(1).trim();
                const spaceIndex = fullHeader.indexOf(' ');

                if (spaceIndex !== -1) {
                    blockType = fullHeader.substring(0, spaceIndex).toLowerCase();
                    blockMeta = fullHeader.substring(spaceIndex).trim();
                } else {
                    blockType = fullHeader.toLowerCase();
                    blockMeta = "";
                }
                blockBuffer = [];
                continue;
            }

            // Block-Ende erkennen mit /&
            if (inBlock && line.trim().replace(/\u00A0/g, ' ') === '/&') {
                result.push(this._renderBlock(blockType, blockMeta, blockBuffer));
                inBlock = false;
                blockType = null;
                blockMeta = "";
                continue;
            }

            if (inBlock) {
                blockBuffer.push(line);
            } else {
                let trimmed = line.trim();
                
                if (trimmed === '___') {
                    result.push('<hr>');
                } else if (trimmed.startsWith('- ')) {
                    let insideUl = this._parseInline(line.replace(/^\s*-\s+/, ''));
                    result.push(`<ul-item>${insideUl}</ul-item>`);
                } else if (/^\d+\.\s+/.test(trimmed)) {
                    let cleanLine = line.replace(/^\s*\d+\.\s+/, '');
                    let insideOl = this._parseInline(cleanLine);
                    result.push(`<ol-item>${insideOl}</ol-item>`);
                } else {
                    result.push(this._parseInline(line));
                }
            }
        }

        // Automatischer Schutz: Falls am Dateiende ein Block nicht geschlossen wurde
        if (inBlock && blockBuffer.length > 0) {
            result.push(this._renderBlock(blockType, blockMeta, blockBuffer));
        }

        return this._processParagraphsAndLists(result);
    }

    /**
     * INTERN: Erzeugt das HTML für einen geschlossenen Block
     */
    _renderBlock(type, meta, lines) {
        const content = lines.join('\n');
        let self = this;

        switch (type) {
            case 'toc':
                let tocWrapper = '<div class="simonup-toc-wrapper">\n';
                if (meta) {
                    tocWrapper += `<h2>${meta}</h2>\n`;
                }
                if (content.trim()) {
                    const intro = lines.map(function(l) { return self._parseInline(l); }).join('<br>');
                    tocWrapper += `<p class="toc-intro">${intro}</p>\n`;
                }
                tocWrapper += 'STRENG_GEHEIMER_TOC_PLATZHALTER\n';
                tocWrapper += '</div>';
                return tocWrapper;

            case 'c': 
                const langClass = meta ? ` class="language-${meta}"` : '';
                const escapedCode = content.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
                return `<pre><code${langClass}>${escapedCode}</code></pre>`;

            case 'q': 
                const qContent = lines.map(function(l) { return self._parseInline(l); }).join('<br>');
                return `<blockquote>${qContent}</blockquote>`;

            case 'b': 
                const bContent = lines.map(function(l) { return self._parseInline(l); }).join('<br>');
                return `<div class="bible-block">${bContent}</div>`;

            case 'f': 
                const fSummary = meta || 'Details';
                const fContent = lines.map(function(l) { return self._parseInline(l); }).join('<br>');
                return `<details>\n<summary>${fSummary}</summary>\n<p>${fContent}</p>\n</details>`;

            case 'i': 
                const iColor = meta || '#ff6347';
                const iContent = lines.map(function(l) { return self._parseInline(l); }).join('<br>');
                return `<div class="infobox" style="border-left: 4px solid ${iColor}; padding: 10px; margin: 10px 0; background: #f8f9fa;">\n${iContent}\n</div>`;

            case 't': 
                return this._renderTable(meta, lines);

            default:
                const defContent = lines.map(function(l) { return self._parseInline(l); }).join('<br>');
                return `<div class="block-${type}">${defContent}</div>`;
        }
    }

    /**
     * INTERN: Robustes Rendern von Multi-line-Tabellen und Galerien
     */
    _renderTable(meta, lines) {
        let tableHtml = '<table>\n';
        
        let colCount = 0;
        if (meta) {
            let metaParts = meta.trim().split(/\s+/);
            if (metaParts.length === 1 && metaParts[0].endsWith('x')) {
                colCount = parseInt(metaParts[0]);
            } else {
                colCount = metaParts.length;
            }
        }

        let fullContent = lines.join('\n');
        let rawCells = fullContent.split('|');
        
        if (rawCells.length > 1 && rawCells[rawCells.length - 1].trim() === '') {
            rawCells.pop();
        }

        let currentConfiguredCols = colCount || 1; 
        let cellIndex = 0;

        tableHtml += '<tr>\n';
        
        for (let i = 0; i < rawCells.length; i++) {
            let cellText = rawCells[i].trim();
            let parsedCell = this._parseInline(cellText).replace(/\n/g, '<br>');
            tableHtml += `  <td>${parsedCell}</td>\n`;
            
            cellIndex++;
            
            if (cellIndex === currentConfiguredCols && i < rawCells.length - 1) {
                tableHtml += '</tr>\n<tr>\n';
                cellIndex = 0;
            }
        }
        
        tableHtml += '</tr>\n</table>';
        return tableHtml;
    }

    /**
     * INTERN: Verarbeitet Fluss-Formatierungen (Inline) ohne HTML-Zerstörung
     */
    _parseInline(text) {
        if (!text) return '';
        let html = text;

        const escapes = [];
        html = html.replace(/\\(.)/g, function(match, char) {
            escapes.push(char);
            return `__ESCAPED_CHAR_${escapes.length - 1}__`;
        });

        // 1. Überschriften ERST parsen (bevor HTML-Tags im Fluss entstehen)
        html = html.replace(/^([1-6])x#\s*(.*)/gm, (match, level, titleAndRest) => {
            let { title, rest } = this._extractHeadingRest(titleAndRest);
            const numStr = this._getAutoNumber(parseInt(level));
            const fullTitle = `${numStr} ${title}`;
            const id = this._slugify(fullTitle);
            this.headings.push({ level: parseInt(level), text: title, id: id }); 
            return `<h${level} id="${id}">${fullTitle}</h${level}>${rest}`;
        });

        html = html.replace(/^([1-6])-#\s*(.*)/gm, (match, level, titleAndRest) => {
            let { title, rest } = this._extractHeadingRest(titleAndRest);
            return `<h${level}>${title}</h${level}>${rest}`;
        });

        html = html.replace(/^([1-6])#\s*(.*)/gm, (match, level, titleAndRest) => {
            let { title, rest } = this._extractHeadingRest(titleAndRest);
            const id = this._slugify(title);
            this.headings.push({ level: parseInt(level), text: title, id: id });
            return `<h${level} id="${id}">${title}</h${level}>${rest}`;
        });

        // Medien & Links verarbeiten
        html = html.replace(/!\[([^\]]+)\s+w:(\d+)\]\(([^)]+)\)/g, '<img src="$3" alt="$1" style="width: $2px; height: auto;">');
        html = html.replace(/!\[([^\]]+)\]\(([^)]+)\)/g, '<img src="$2" alt="$1">');
        html = html.replace(/\[([^\]]+)\]\{([^}]+)\}/g, '<a href="$2" target="_blank" rel="noopener noreferrer">$1</a>');
        html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');

        // Hilfsfunktion: Führt Ersetzungen nur AUSSERHALB von HTML-Tags <...> aus
        const replaceOutsideTags = (regex, replacement) => {
            const masterRegex = new RegExp(/(<[^>]+>)/g.source + '|' + regex.source, 'g');
            html = html.replace(masterRegex, (match, p1) => {
                if (p1) return p1; // HTML-Tags überspringen
                
                const innerMatch = regex.exec(match);
                if (innerMatch) {
                    if (typeof replacement === 'function') {
                        return replacement(...innerMatch);
                    }
                    let res = replacement;
                    for (let idx = 1; idx < innerMatch.length; idx++) {
                        res = res.replace(new RegExp('\\$' + idx, 'g'), innerMatch[idx]);
                    }
                    return res;
                }
                return match;
            });
        };

        // 2. Formatierung für FETT (**text/** oder **text/)
        replaceOutsideTags(/\*\*(.+?)(?:\/\*\*|\/|\*\*|$)/, '<strong>$1</strong>');

        // 3. Formatierung für MEDIUM (*text/* oder *text/)
        replaceOutsideTags(/\*(.+?)(?:\/\*|\/|\*|$)/, '<span style="font-weight: 500;">$1</span>');

        // 4. Standard Text-Inline-Rules via Symbol-Paar/Slash-Abschluss
        const inlineRules = [
            { tag: 'em', symbol: '%' },
            { tag: 'u', symbol: '_' },
            { tag: 'del', symbol: '~' },
            { tag: 'mark', symbol: '=' },
            { tag: 'sup', symbol: '\\^' },
            { tag: 'sub', symbol: '°' },
            { tag: 'code', symbol: '`' }
        ];

        for (let k = 0; k < inlineRules.length; k++) {
            let rule = inlineRules[k];
            let tagSimple = rule.tag.split(' ')[0];
            
            // Unterstützt %text/% sowie das Fallback %text am Zeilenende
            replaceOutsideTags(new RegExp(rule.symbol + '(.+?)(?:\\/' + rule.symbol + '|\\/|' + rule.symbol + '|$)'), `<${rule.tag}>$1</${tagSimple}>`);
        }

        // Ausrichtungen & Fußnoten
        const alignMap = { 'l': 'left', 'r': 'right', 'c': 'center', 'j': 'justify' };
        html = html.replace(/>([lrcj])\s+(.+?)\s*\/>/g, function(m, dir, content) {
            return `<div style="text-align: ${alignMap[dir]};">${content}</div>`;
        });

        html = html.replace(/\^x\[([^\]]+)\]\^x/g, '<span class="footnote-auto" title="$1">[*]</span>'); 
        html = html.replace(/\^(\d+)\[([^\]]+)\]\^x/g, '<sup class="footnote-manual" title="$2">[$1]</sup>');

        html = html.replace(/__ESCAPED_CHAR_(\d+)__/g, function(match, idx) {
            return escapes[idx];
        });

        return html;
    }

    /**
     * INTERN: Hilfsmethode zur Extraktion des optionalen /# Abschlusses bei Überschriften
     */
    _extractHeadingRest(text) {
        let title = text;
        let rest = "";
        const closeIdx = text.indexOf('/#');
        if (closeIdx !== -1) {
            title = text.substring(0, closeIdx);
            rest = text.substring(closeIdx + 2);
        }
        return { title: title.trim(), rest: rest };
    }

    /**
     * INTERN: Errechnet die nächste fortlaufende Kapitelnummer
     */
    _getAutoNumber(level) {
        let idx = level - 1;
        this.counters[idx]++;
        for (let i = idx + 1; i < 6; i++) {
            this.counters[i] = 0;
        }
        let activeParts = this.counters.slice(0, level);
        return activeParts.join('.') + '.';
    }

    /**
     * INTERN: Macht aus Text eine URL-konforme ID
     */
    _slugify(text) {
        return text.toLowerCase()
            .replace(/[^a-z0-9\s-]/g, '') 
            .replace(/\s+/g, '-');        
    }

    /**
     * INTERN: Erzeugt die fertige HTML-Liste des TOC und injiziert sie in den Block
     */
    _injectTOC(html) {
        const placeholder = 'STRENG_GEHEIMER_TOC_PLATZHALTER';
         
        if (!html.includes(placeholder)) {
            return html;
        }
         
        if (this.headings.length === 0) {
            return html.replace(placeholder, '');
        }
     
        let tocListHtml = '<div class="simonup-toc">\n<ul>\n';
        let currentLevel = 1;
     
        for (let i = 0; i < this.headings.length; i++) {
            let heading = this.headings[i];
            if (heading.level > currentLevel) {
                let diffUp = heading.level - currentLevel;
                tocListHtml += '<ul>\n'.repeat(diffUp);
            } else if (heading.level < currentLevel) {
                let diffDown = currentLevel - heading.level;
                tocListHtml += '</ul>\n'.repeat(diffDown);
            }
            currentLevel = heading.level;
            tocListHtml += `<li><a href="#${heading.id}">${heading.text}</a></li>\n`;
        }
         
        if (currentLevel > 1) {
            let diffFinal = currentLevel - 1;
            tocListHtml += '</ul>\n'.repeat(diffFinal);
        }
        tocListHtml += '</ul>\n</div>';
     
        return html.replace(placeholder, tocListHtml);
    }

    /**
     * INTERN: Fasst freie Listen-Elemente zusammen und generiert Absätze (p)
     */
    _processParagraphsAndLists(elements) {
        let processed = [];
        let paragraphBuffer = [];
        let listBuffer = [];
        let currentListType = null; 

        function flushList() {
            if (listBuffer.length > 0) {
                let items = listBuffer.map(function(item) { return "  <li>" + item + "</li>"; }).join("\n");
                processed.push("<" + currentListType + ">\n" + items + "\n</" + currentListType + ">");
                listBuffer = [];
                currentListType = null;
            }
        }

        function flushParagraph() {
            if (paragraphBuffer.length > 0) {
                let pContent = paragraphBuffer.join("<br>");
                processed.push("<p>" + pContent + "</p>");
                paragraphBuffer = [];
            }
        }

        for (let i = 0; i < elements.length; i++) {
            let element = elements[i];
            if (!element) continue;
             
            let isUlItem = element.startsWith("<ul-item>");
            let isOlItem = element.startsWith("<ol-item>");

            if (isUlItem || isOlItem) {
                flushParagraph();
                let type = isUlItem ? "ul" : "ol";
                let content = isUlItem ? element.replace(/<\/?ul-item>/g, "") : element.replace(/<\/?ol-item>/g, "");
                 
                if (currentListType && currentListType !== type) {
                    flushList();
                }
                currentListType = type;
                listBuffer.push(content);
            } else if (element.startsWith("<") && !/^(<a>|<strong>|<em>|<u>|<del>|<mark>|<sup>|<sub>|<span>|<code>|<img>|<h[1-6])/i.test(element)) {
                flushList();
                flushParagraph();
                processed.push(element);
            } else {
                flushList();
                if (element.trim() === "") {
                    flushParagraph();
                } else {
                    paragraphBuffer.push(element);
                }
            }
        }

        flushList();
        flushParagraph();

        return processed.join("\n");
    }
}