LittleWhiteBox/modules/variables/state2/parser.js

import jsyaml from '../../../libs/js-yaml.mjs';

/**
 * Robust <state> block matcher (no regex)
 * - Pairs each </state> with the nearest preceding <state ...>
 * - Ignores unclosed <state>
 */

function isValidOpenTagAt(s, i) {
    if (s[i] !== '<') return false;

    const head = s.slice(i, i + 6).toLowerCase();
    if (head !== '<state') return false;

    const next = s[i + 6] ?? '';
    if (next && !(next === '>' || next === '/' || /\s/.test(next))) return false;

    return true;
}

function isValidCloseTagAt(s, i) {
    if (s[i] !== '<') return false;
    if (s[i + 1] !== '/') return false;

    const head = s.slice(i, i + 7).toLowerCase();
    if (head !== '</state') return false;

    let j = i + 7;
    while (j < s.length && /\s/.test(s[j])) j++;
    return s[j] === '>';
}

function findTagEnd(s, openIndex) {
    const end = s.indexOf('>', openIndex);
    return end === -1 ? -1 : end;
}

function findStateBlockSpans(text) {
    const s = String(text ?? '');
    const closes = [];

    for (let i = 0; i < s.length; i++) {
        if (s[i] !== '<') continue;
        if (isValidCloseTagAt(s, i)) closes.push(i);
    }
    if (!closes.length) return [];

    const spans = [];
    let searchEnd = s.length;

    for (let cIdx = closes.length - 1; cIdx >= 0; cIdx--) {
        const closeStart = closes[cIdx];
        if (closeStart >= searchEnd) continue;

        let closeEnd = closeStart + 7;
        while (closeEnd < s.length && s[closeEnd] !== '>') closeEnd++;
        if (s[closeEnd] !== '>') continue;
        closeEnd += 1;

        let openStart = -1;
        for (let i = closeStart - 1; i >= 0; i--) {
            if (s[i] !== '<') continue;
            if (!isValidOpenTagAt(s, i)) continue;

            const tagEnd = findTagEnd(s, i);
            if (tagEnd === -1) continue;
            if (tagEnd >= closeStart) continue;

            openStart = i;
            break;
        }

        if (openStart === -1) continue;

        const openTagEnd = findTagEnd(s, openStart);
        if (openTagEnd === -1) continue;

        spans.push({
            openStart,
            openTagEnd: openTagEnd + 1,
            closeStart,
            closeEnd,
        });

        searchEnd = openStart;
    }

    spans.reverse();
    return spans;
}

export function extractStateBlocks(text) {
    const s = String(text ?? '');
    const spans = findStateBlockSpans(s);
    const out = [];
    for (const sp of spans) {
        const inner = s.slice(sp.openTagEnd, sp.closeStart);
        if (inner.trim()) out.push(inner);
    }
    return out;
}

export function computeStateSignature(text) {
    const s = String(text ?? '');
    const spans = findStateBlockSpans(s);
    if (!spans.length) return '';
    const chunks = spans.map(sp => s.slice(sp.openStart, sp.closeEnd).trim());
    return chunks.join('\n---\n');
}


/**
 * Parse $schema block
 */
function parseSchemaBlock(basePath, schemaLines) {
    const rules = [];

    const nonEmpty = schemaLines.filter(l => l.trim());
    if (!nonEmpty.length) return rules;

    const minIndent = Math.min(...nonEmpty.map(l => l.search(/\S/)));
    const yamlText = schemaLines
        .map(l => (l.trim() ? l.slice(minIndent) : ''))
        .join('\n');

    let schemaObj;
    try {
        schemaObj = jsyaml.load(yamlText);
    } catch (e) {
        console.warn('[parser] $schema YAML parse failed:', e.message);
        return rules;
    }

    if (!schemaObj || typeof schemaObj !== 'object') return rules;

    function walk(obj, curPath) {
        if (obj === null || obj === undefined) return;

        if (Array.isArray(obj)) {
            if (obj.length === 0) {
                rules.push({
                    path: curPath,
                    rule: { typeLock: 'array', arrayGrow: true },
                });
            } else {
                rules.push({
                    path: curPath,
                    rule: { typeLock: 'array', arrayGrow: true },
                });
                walk(obj[0], curPath ? `${curPath}.[*]` : '[*]');
            }
            return;
        }

        if (typeof obj !== 'object') {
            const t = typeof obj;
            if (t === 'string' || t === 'number' || t === 'boolean') {
                rules.push({
                    path: curPath,
                    rule: { typeLock: t },
                });
            }
            return;
        }

        const keys = Object.keys(obj);

        if (keys.length === 0) {
            rules.push({
                path: curPath,
                rule: { typeLock: 'object', objectExt: true },
            });
            return;
        }

        const hasWildcard = keys.includes('*');

        if (hasWildcard) {
            rules.push({
                path: curPath,
                rule: { typeLock: 'object', objectExt: true, hasWildcard: true },
            });

            const wildcardTemplate = obj['*'];
            if (wildcardTemplate !== undefined) {
                walk(wildcardTemplate, curPath ? `${curPath}.*` : '*');
            }

            for (const k of keys) {
                if (k === '*') continue;
                const childPath = curPath ? `${curPath}.${k}` : k;
                walk(obj[k], childPath);
            }
            return;
        }

        rules.push({
            path: curPath,
            rule: { typeLock: 'object', allowedKeys: keys },
        });

        for (const k of keys) {
            const childPath = curPath ? `${curPath}.${k}` : k;
            walk(obj[k], childPath);
        }
    }

    walk(schemaObj, basePath);
    return rules;
}

/**
 * Parse rule line ($ro, $range, $step, $enum)
 */
function parseRuleLine(line) {
    const tokens = line.trim().split(/\s+/);
    const directives = [];
    let pathStart = 0;

    for (let i = 0; i < tokens.length; i++) {
        if (tokens[i].startsWith('$')) {
            directives.push(tokens[i]);
            pathStart = i + 1;
        } else {
            break;
        }
    }

    const path = tokens.slice(pathStart).join(' ').trim();
    if (!path || !directives.length) return null;

    const rule = {};

    for (const tok of directives) {
        if (tok === '$ro') { rule.ro = true; continue; }

        const rangeMatch = tok.match(/^\$range=\[\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\]$/);
        if (rangeMatch) {
            rule.min = Math.min(Number(rangeMatch[1]), Number(rangeMatch[2]));
            rule.max = Math.max(Number(rangeMatch[1]), Number(rangeMatch[2]));
            continue;
        }

        const stepMatch = tok.match(/^\$step=(\d+(?:\.\d+)?)$/);
        if (stepMatch) { rule.step = Math.abs(Number(stepMatch[1])); continue; }

        const enumMatch = tok.match(/^\$enum=\{([^}]+)\}$/);
        if (enumMatch) {
            rule.enum = enumMatch[1].split(/[,、;]/).map(s => s.trim()).filter(Boolean);
            continue;
        }
    }

    return { path, rule };
}

export function parseStateBlock(content) {
    const lines = String(content ?? '').split(/\r?\n/);

    const rules = [];
    const dataLines = [];

    let inSchema = false;
    let schemaPath = '';
    let schemaLines = [];
    let schemaBaseIndent = -1;

    const flushSchema = () => {
        if (schemaLines.length) {
            const parsed = parseSchemaBlock(schemaPath, schemaLines);
            rules.push(...parsed);
        }
        inSchema = false;
        schemaPath = '';
        schemaLines = [];
        schemaBaseIndent = -1;
    };

    for (let i = 0; i < lines.length; i++) {
        const raw = lines[i];
        const trimmed = raw.trim();
        const indent = raw.search(/\S/);

        if (!trimmed || trimmed.startsWith('#')) {
            if (inSchema && schemaBaseIndent >= 0) schemaLines.push(raw);
            continue;
        }

        // $schema 开始
        if (trimmed.startsWith('$schema')) {
            flushSchema();
            const rest = trimmed.slice(7).trim();
            schemaPath = rest || '';
            inSchema = true;
            schemaBaseIndent = -1;
            continue;
        }

        if (inSchema) {
            if (schemaBaseIndent < 0) {
                schemaBaseIndent = indent;
            }

            // 缩进回退 => schema 结束
            if (indent < schemaBaseIndent && indent >= 0 && trimmed) {
                flushSchema();
                i--;
                continue;
            }

            schemaLines.push(raw);
            continue;
        }

        // 普通 $rule（$ro, $range, $step, $enum）
        if (trimmed.startsWith('$')) {
            const parsed = parseRuleLine(trimmed);
            if (parsed) rules.push(parsed);
            continue;
        }

        dataLines.push(raw);
    }

    flushSchema();

    const ops = parseDataLines(dataLines);
    return { rules, ops };
}

/**
 * 解析数据行
 */
function stripYamlInlineComment(s) {
    const text = String(s ?? '');
    if (!text) return '';
    let inSingle = false;
    let inDouble = false;
    let escaped = false;
    for (let i = 0; i < text.length; i++) {
        const ch = text[i];
        if (inSingle) {
            if (ch === "'") {
                if (text[i + 1] === "'") { i++; continue; }
                inSingle = false;
            }
            continue;
        }
        if (inDouble) {
            if (escaped) { escaped = false; continue; }
            if (ch === '\\') { escaped = true; continue; }
            if (ch === '"') inDouble = false;
            continue;
        }
        if (ch === "'") { inSingle = true; continue; }
        if (ch === '"') { inDouble = true; continue; }
        if (ch === '#') {
            const prev = i > 0 ? text[i - 1] : '';
            if (i === 0 || /\s/.test(prev)) {
                return text.slice(0, i).trimEnd();
            }
        }
    }
    return text.trimEnd();
}

function parseDataLines(lines) {
    const results = [];

    let pendingPath = null;
    let pendingLines = [];

    const flushPending = () => {
        if (!pendingPath) return;

        if (!pendingLines.length) {
            results.push({ path: pendingPath, op: 'set', value: '' });
            pendingPath = null;
            pendingLines = [];
            return;
        }

        try {
            const nonEmpty = pendingLines.filter(l => l.trim());
            const minIndent = nonEmpty.length
                ? Math.min(...nonEmpty.map(l => l.search(/\S/)))
                : 0;

            const yamlText = pendingLines
                .map(l => (l.trim() ? l.slice(minIndent) : ''))
                .join('\n');

            const obj = jsyaml.load(yamlText);
            results.push({ path: pendingPath, op: 'set', value: obj });
        } catch (e) {
            results.push({ path: pendingPath, op: 'set', value: null, warning: `YAML 解析失败: ${e.message}` });
        } finally {
            pendingPath = null;
            pendingLines = [];
        }
    };

    for (const raw of lines) {
        const trimmed = raw.trim();
        if (!trimmed || trimmed.startsWith('#')) continue;

        const indent = raw.search(/\S/);

        if (indent === 0) {
            flushPending();
            const colonIdx = findTopLevelColon(trimmed);
            if (colonIdx === -1) continue;

            const path = trimmed.slice(0, colonIdx).trim();
            let rhs = trimmed.slice(colonIdx + 1).trim();
            rhs = stripYamlInlineComment(rhs);
            if (!path) continue;

            if (!rhs) {
                pendingPath = path;
                pendingLines = [];
            } else {
                results.push({ path, ...parseInlineValue(rhs) });
            }
        } else if (pendingPath) {
            pendingLines.push(raw);
        }
    }

    flushPending();
    return results;
}

function findTopLevelColon(line) {
    let inQuote = false;
    let q = '';
    let esc = false;
    for (let i = 0; i < line.length; i++) {
        const ch = line[i];
        if (esc) { esc = false; continue; }
        if (ch === '\\') { esc = true; continue; }
        if (!inQuote && (ch === '"' || ch === "'")) { inQuote = true; q = ch; continue; }
        if (inQuote && ch === q) { inQuote = false; q = ''; continue; }
        if (!inQuote && ch === ':') return i;
    }
    return -1;
}

function unescapeString(s) {
    return String(s ?? '')
        .replace(/\\n/g, '\n')
        .replace(/\\t/g, '\t')
        .replace(/\\r/g, '\r')
        .replace(/\\"/g, '"')
        .replace(/\\'/g, "'")
        .replace(/\\\\/g, '\\');
}

export function parseInlineValue(raw) {
    const t = String(raw ?? '').trim();

    if (t === 'null') return { op: 'del' };

    const parenNum = t.match(/^\((-?\d+(?:\.\d+)?)\)$/);
    if (parenNum) return { op: 'set', value: Number(parenNum[1]) };

    if (/^\+\d/.test(t) || /^-\d/.test(t)) {
        const n = Number(t);
        if (Number.isFinite(n)) return { op: 'inc', delta: n };
    }

    const pushD = t.match(/^\+"((?:[^"\\]|\\.)*)"\s*$/);
    if (pushD) return { op: 'push', value: unescapeString(pushD[1]) };
    const pushS = t.match(/^\+'((?:[^'\\]|\\.)*)'\s*$/);
    if (pushS) return { op: 'push', value: unescapeString(pushS[1]) };

    if (t.startsWith('+[')) {
        try {
            const arr = JSON.parse(t.slice(1));
            if (Array.isArray(arr)) return { op: 'push', value: arr };
        } catch {}
        return { op: 'set', value: t, warning: '+[] 解析失败' };
    }

    const popD = t.match(/^-"((?:[^"\\]|\\.)*)"\s*$/);
    if (popD) return { op: 'pop', value: unescapeString(popD[1]) };
    const popS = t.match(/^-'((?:[^'\\]|\\.)*)'\s*$/);
    if (popS) return { op: 'pop', value: unescapeString(popS[1]) };

    if (t.startsWith('-[')) {
        try {
            const arr = JSON.parse(t.slice(1));
            if (Array.isArray(arr)) return { op: 'pop', value: arr };
        } catch {}
        return { op: 'set', value: t, warning: '-[] 解析失败' };
    }

    if (/^-?\d+(?:\.\d+)?$/.test(t)) return { op: 'set', value: Number(t) };

    const strD = t.match(/^"((?:[^"\\]|\\.)*)"\s*$/);
    if (strD) return { op: 'set', value: unescapeString(strD[1]) };
    const strS = t.match(/^'((?:[^'\\]|\\.)*)'\s*$/);
    if (strS) return { op: 'set', value: unescapeString(strS[1]) };

    if (t === 'true') return { op: 'set', value: true };
    if (t === 'false') return { op: 'set', value: false };

    if (t.startsWith('{') || t.startsWith('[')) {
        try { return { op: 'set', value: JSON.parse(t) }; }
        catch { return { op: 'set', value: t, warning: 'JSON 解析失败' }; }
    }

    return { op: 'set', value: t };
}