// Debug logging through LogManager (controlled by Settings)

#include "interpreter.h"
#include <cstring>
#include "compression.h"
#include "utils.h"
#include "logmanager.h"

#include <stdexcept>
// Custom exception for break statement
struct BreakException : std::exception {};
#include <QFileInfo>

Interpreter::Interpreter(Module mod) : m_mod(std::move(mod)) {}

void Interpreter::setProgressCallback(ProgressCallback cb) {
    m_progressCallback = std::move(cb);
}

void Interpreter::setFileSize(qint64 size) {
    m_fileSize = size;
}

void Interpreter::setStatusCallback(StatusCallback cb) {
    m_statusCallback = std::move(cb);
}

void Interpreter::reportProgress(Runtime& rt) const {
    if (m_progressCallback && rt.in && rt.in->device()) {
        m_progressCallback(rt.in->device()->pos(), m_fileSize);
    }
}

void Interpreter::reportStatus(const QString& status) const {
    if (m_statusCallback) {
        m_statusCallback(status);
    }
}

static QDataStream::ByteOrder toQtOrder(ByteOrder b) {
    return (b == ByteOrder::LE) ? QDataStream::LittleEndian : QDataStream::BigEndian;
}

QVariantMap Interpreter::runType(const QString& typeName, QIODevice* dev, const QString &filePath) const {
    QDataStream ds(dev);
    return runType(typeName, ds, filePath);
}

QVariantMap Interpreter::runType(const QString& typeName, QDataStream& stream, const QString& filePath) const {
    if (!m_mod.types.contains(typeName)) {
        throw std::runtime_error(("Unknown type: " + typeName).toStdString());
    }

    const qint64 startPos = stream.device() ? stream.device()->pos() : -1;
    LogManager::instance().debug(QString("[PARSE] Starting type '%1' at pos 0x%2")
        .arg(typeName)
        .arg(startPos, 0, 16));

    Runtime rt;
    rt.in = &stream;
    rt.module = &m_mod;
    rt.pushType(typeName);  // Track root type

    const TypeDef& td = m_mod.types[typeName];
    rt.order = td.order;
    applyByteOrder(rt);

    if (!filePath.isEmpty())
    {
        seedFileVars(rt, filePath);
    }

    execBlock(rt, td.body);

    rt.vars["_type"] = typeName;

    const qint64 endPos = stream.device() ? stream.device()->pos() : -1;
    LogManager::instance().debug(QString("[PARSE] Finished type '%1' at pos 0x%2 (consumed %3 bytes)")
        .arg(typeName)
        .arg(endPos, 0, 16)
        .arg(endPos - startPos));

    return rt.vars;
}

void Interpreter::seedFileVars(Runtime& rt, const QString& filePath) {
    rt.filePath = filePath;

    QFileInfo fi(filePath);
    rt.vars["_path"] = filePath;
    rt.vars["_name"] = fi.fileName();              // "mp_test_load.ff"
    rt.vars["_basename"] = fi.completeBaseName();  // "mp_test_load" (without extension)
    rt.vars["_ext"]  = fi.suffix().toLower();      // "ff", "xpak", etc.
}

bool Interpreter::checkCriteria(const QString &typeName, QIODevice *dev, const QString filePath) const
{
    if (!m_mod.types.contains(typeName))
    {
        LogManager::instance().debug(QString("[CRITERIA] Type '%1' not found").arg(typeName));
        return false;
    }

    const TypeDef& td = m_mod.types[typeName];
    if (td.criteria.isEmpty())
    {
        LogManager::instance().debug(QString("[CRITERIA] Type '%1' has no criteria, returning true").arg(typeName));
        return true;
    }

    LogManager::instance().debug(QString("[CRITERIA] Checking type '%1' for file '%2'").arg(typeName).arg(filePath));

    // Save/restore device position
    const qint64 savedPos = dev->pos();
    auto restore = [&]() { dev->seek(savedPos); };

    try {
        QDataStream ds(dev);

        Runtime rt;
        rt.in = &ds;
        rt.module = &m_mod;
        rt.order = td.order;
        applyByteOrder(rt);

        if (!filePath.isEmpty())
        {
            seedFileVars(rt, filePath);
        }

        execBlock(rt, td.criteria);

        restore();

        LogManager::instance().debug(QString("[CRITERIA] Type '%1' PASSED criteria").arg(typeName));
        return true;
    } catch (const std::exception& e) {
        restore();

        LogManager::instance().debug(QString("[CRITERIA] Type '%1' FAILED: %2").arg(typeName).arg(e.what()));
        return false;
    } catch (...) {
        restore();

        LogManager::instance().debug(QString("[CRITERIA] Type '%1' FAILED (unknown exception)").arg(typeName));
        return false;
    }
}

QVariantMap Interpreter::runTypeInternal(const QString &typeName, QDataStream &stream, const QString &filePath, std::optional<ByteOrder> inheritedOrder) const
{
    if (!m_mod.types.contains(typeName)) {
        throw std::runtime_error(("Unknown type: " + typeName).toStdString());
    }

    Runtime rt;
    rt.in = &stream;
    rt.module = &m_mod;
    rt.pushType(typeName);  // Track type for error context

    const TypeDef& td = m_mod.types[typeName];

    // IMPORTANT: inherit if the typedef doesn't specify byteorder
    if (td.hasExplicitByteOrder) rt.order = td.order;
    else if (inheritedOrder.has_value()) rt.order = *inheritedOrder;
    else rt.order = td.order; // root fallback (keeps old behavior)

    applyByteOrder(rt);

    if (!filePath.isEmpty()) seedFileVars(rt, filePath);

    execBlock(rt, td.body);

    rt.vars["_type"] = typeName;
    return rt.vars;
}

void Interpreter::applyByteOrder(Runtime& rt) const {
    if (!rt.in) return;
    rt.in->setByteOrder(toQtOrder(rt.order));
}

qint64 Interpreter::toInt(const QVariant& v) const {
    if (v.canConvert<qint64>()) return v.toLongLong();
    throw std::runtime_error("Expected integer value");
}

bool Interpreter::toBool(const QVariant& v) const {
    if (v.typeId() == QMetaType::Bool) return v.toBool();
    if (v.canConvert<qint64>()) return v.toLongLong() != 0;
    if (v.typeId() == QMetaType::QString) return !v.toString().isEmpty();
    if (v.canConvert<QByteArray>()) return !v.toByteArray().isEmpty();
    return v.isValid();
}

QVariant Interpreter::readScalar(Runtime& rt, ScalarType t) const {
    QDataStream& in = *rt.in;
    QIODevice* dev = in.device();
    const qint64 pos = dev ? dev->pos() : -1;

    auto checkStatus = [&](const char* typeName, int expectedSize) {
        if (in.status() != QDataStream::Ok) {
            throw std::runtime_error(
                QString("Failed to read %1 at pos 0x%2. Parsing: %3")
                    .arg(typeName)
                    .arg(pos, 0, 16)
                    .arg(rt.typeStackString().isEmpty() ? "root" : rt.typeStackString())
                    .toStdString());
        }
    };

    switch (t) {
    case ScalarType::U8:  { quint8  v; in >> v; checkStatus("u8", 1); return v; }
    case ScalarType::I8:  { qint8   v; in >> v; checkStatus("i8", 1); return v; }
    case ScalarType::U16: { quint16 v; in >> v; checkStatus("u16", 2); return v; }
    case ScalarType::I16: { qint16  v; in >> v; checkStatus("i16", 2); return v; }
    case ScalarType::U32: { quint32 v; in >> v; checkStatus("u32", 4); return v; }
    case ScalarType::I32: { qint32  v; in >> v; checkStatus("i32", 4); return v; }
    case ScalarType::U64: { quint64 v; in >> v; checkStatus("u64", 8); return v; }
    case ScalarType::I64: { qint64  v; in >> v; checkStatus("i64", 8); return v; }
    case ScalarType::F32: { quint32 bits; in >> bits; checkStatus("f32", 4); float v; memcpy(&v, &bits, 4); return v; }
    case ScalarType::F64: { quint64 bits; in >> bits; checkStatus("f64", 8); double v; memcpy(&v, &bits, 8); return v; }
    case ScalarType::Bool: { quint8 v; in >> v; checkStatus("bool", 1); return (v != 0); }
    }
    return {};
}

QByteArray Interpreter::readBytes(Runtime& rt, qint64 n) const {
    if (n < 0) throw std::runtime_error("read(n): n must be >= 0");
    QIODevice* dev = rt.in->device();
    if (!dev) throw std::runtime_error("No device in stream");

    const qint64 pos = dev->pos();
    QByteArray buf;
    buf.resize(int(n));
    const int got = rt.in->readRawData(buf.data(), int(n));
    if (got != int(n)) {
        buf.resize(qMax(0, got));
        throw std::runtime_error(
            QString("Unexpected EOF while reading %1 bytes at pos 0x%2 (got %3). Parsing: %4")
                .arg(n)
                .arg(pos, 0, 16)
                .arg(got)
                .arg(rt.typeStackString().isEmpty() ? "root" : rt.typeStackString())
                .toStdString());
    }
    return buf;
}

QByteArray Interpreter::readEOF(Runtime& rt) const {
    QIODevice* dev = rt.in->device();
    if (!dev) throw std::runtime_error("No device in stream");
    const qint64 remaining = dev->size() - dev->pos();
    if (remaining < 0) return {};
    return readBytes(rt, remaining);
}

QVariant Interpreter::evalCall(Runtime& rt, const Expr::Call& c) const {
    // Builtins:
    // pos() -> int
    // size() -> int
    // read(n) where n is int or EOF -> bytes
    // zlib(bytes) -> bytes
    // parse("typeName", bytes) -> map

    if (c.fn == "pos") {
        if (!c.args.isEmpty()) throw std::runtime_error("pos() takes no args");
        return rt.in->device()->pos();
    }
    if (c.fn == "size") {
        if (!c.args.isEmpty()) throw std::runtime_error("size() takes no args");
        return rt.in->device()->size();
    }
    if (c.fn == "read") {
        if (c.args.size() != 1) throw std::runtime_error("read(x) takes 1 arg");
        QVariant arg = evalExpr(rt, *c.args[0]);
        // special: EOF token was represented as Var("EOF")
        if (arg.typeId() == QMetaType::QString && arg.toString() == "EOF") {
            return readEOF(rt);
        }
        return readBytes(rt, toInt(arg));
    }
    if (c.fn == "zlib") {
        if (c.args.size() != 1) throw std::runtime_error("zlib(bytes) takes 1 arg");
        QByteArray in = evalExpr(rt, *c.args[0]).toByteArray();
        const QByteArray decompressed = Compression::DecompressZLIB(in);

        Utils::ExportData(rt.filePath.split('/').last() + ".zone", decompressed);

        if (!rt.filePath.isEmpty()) {
            QFileInfo fi(rt.filePath);
            const QString stem = fi.completeBaseName();         // "mp_test_load"
            rt.vars["_zone_name"] = stem + ".zone";             // "mp_test_load.zone"
        }

        return decompressed;
    }
    if (c.fn == "xmem") {
        if (c.args.size() != 1) throw std::runtime_error("xmem(bytes) takes 1 arg");
        QByteArray in = evalExpr(rt, *c.args[0]).toByteArray();
        reportStatus(QString("Decompressing %1 bytes...").arg(in.size()));
        const QByteArray decompressed = Compression::DecompressXMem(in);

        if (!rt.filePath.isEmpty()) {
            QFileInfo fi(rt.filePath);
            const QString stem = fi.completeBaseName();
            rt.vars["_decompressed_name"] = stem + ".decompressed";
        }

        reportStatus(QString("Decompressed to %1 bytes").arg(decompressed.size()));
        return decompressed;
    }
    if (c.fn == "parse") {
        if (c.args.size() != 2) throw std::runtime_error("parse(typeName, bytes) takes 2 args");
        const QString typeName = evalExpr(rt, *c.args[0]).toString();
        const QByteArray bytes = evalExpr(rt, *c.args[1]).toByteArray();

        reportStatus(QString("Parsing %1...").arg(typeName));
        QDataStream nested(bytes);

        QVariantMap obj = runTypeInternal(typeName, nested, rt.filePath, rt.order);

        if (rt.vars.contains("_zone_name") && !obj.contains("_zone_name")) {
            obj["_zone_name"] = rt.vars["_zone_name"];
        }

        obj["_type"] = typeName;
        return obj;
    }
    if (c.fn == "parse_here") {
        if (c.args.size() != 1) throw std::runtime_error("parse_here(typeName) takes 1 arg");
        const QString typeName = evalExpr(rt, *c.args[0]).toString();

        if (!rt.module->types.contains(typeName)) {
            throw std::runtime_error(("Unknown type (parse_here): " + typeName).toStdString());
        }

        const qint64 startPos = rt.in->device() ? rt.in->device()->pos() : -1;
        LogManager::instance().debug(QString("[PARSE_HERE] Parsing '%1' at pos 0x%2")
            .arg(typeName)
            .arg(startPos, 0, 16));

        // Push type onto stack for error context
        rt.pushType(typeName);

        // IMPORTANT: parse using the SAME stream (advance)
        // We must temporarily apply that type's byteorder.
        const TypeDef& td = rt.module->types[typeName];

        // Save current byteorder
        const auto oldOrder = rt.order;

        // Decide child order
        ByteOrder childOrder = oldOrder;
        if (td.hasExplicitByteOrder) childOrder = td.order;

        // Create child runtime sharing stream but inheriting type stack
        Runtime childRt;
        childRt.in = rt.in;
        childRt.module = rt.module;
        childRt.order = childOrder;
        childRt.typeStack = rt.typeStack;  // Inherit type stack for error context
        childRt.filePath = rt.filePath;    // Inherit file path for naming

        // Copy file variables to child context
        if (rt.vars.contains("_path")) childRt.vars["_path"] = rt.vars["_path"];
        if (rt.vars.contains("_name")) childRt.vars["_name"] = rt.vars["_name"];
        if (rt.vars.contains("_basename")) childRt.vars["_basename"] = rt.vars["_basename"];
        if (rt.vars.contains("_ext")) childRt.vars["_ext"] = rt.vars["_ext"];

        applyByteOrder(childRt);

        execBlock(childRt, td.body);
        QVariantMap child = childRt.vars;

        // Pop type from stack
        rt.popType();

        // Restore parent order
        rt.order = oldOrder;
        applyByteOrder(rt);

        child["_type"] = typeName;

        const qint64 endPos = rt.in->device() ? rt.in->device()->pos() : -1;
        LogManager::instance().debug(QString("[PARSE_HERE] Finished '%1' at pos 0x%2 (consumed %3 bytes)")
            .arg(typeName)
            .arg(endPos, 0, 16)
            .arg(endPos - startPos));

        return child;
    }
    if (c.fn == "push") {
        if (c.args.size() != 2) throw std::runtime_error("push(name, value) takes 2 args");
        const QString listName = evalExpr(rt, *c.args[0]).toString();

        QVariant v = evalExpr(rt, *c.args[1]);
        if (v.typeId() != QMetaType::QVariantMap)
            throw std::runtime_error("push expects a map as 2nd arg");

        QVariantList lst = rt.vars.value(listName).toList(); // empty if missing/not a list
        const int newIndex = lst.size();
        lst.push_back(v);
        rt.vars[listName] = lst;

        const QVariantMap itemMap = v.toMap();
        const QString itemType = itemMap.value("_type").toString();
        const QString itemName = itemMap.value("_name").toString();
        LogManager::instance().debug(QString("[PUSH] Added item #%1 to '%2': type='%3', name='%4'")
            .arg(newIndex)
            .arg(listName)
            .arg(itemType)
            .arg(itemName));

        return rt.vars[listName];
    }
    if (c.fn == "get") {
        if (c.args.size() != 2) throw std::runtime_error("get(container, key) takes 2 args");
        QVariant container = evalExpr(rt, *c.args[0]);
        QVariant key = evalExpr(rt, *c.args[1]);

        // Array indexing: get(array, index)
        if (container.typeId() == QMetaType::QVariantList) {
            const QVariantList list = container.toList();
            const qint64 index = toInt(key);
            if (index < 0 || index >= list.size()) {
                throw std::runtime_error(QString("get: array index %1 out of bounds (size=%2). Parsing: %3")
                    .arg(index).arg(list.size())
                    .arg(rt.typeStackString().isEmpty() ? "root" : rt.typeStackString())
                    .toStdString());
            }
            return list[int(index)];
        }

        // Object field access: get(object, "fieldName")
        if (container.typeId() == QMetaType::QVariantMap) {
            const QVariantMap map = container.toMap();
            const QString fieldName = key.toString();
            if (!map.contains(fieldName)) {
                throw std::runtime_error(QString("get: field '%1' not found in object. Parsing: %2")
                    .arg(fieldName)
                    .arg(rt.typeStackString().isEmpty() ? "root" : rt.typeStackString())
                    .toStdString());
            }
            return map.value(fieldName);
        }

        throw std::runtime_error("get: first argument must be an array or object");
    }
    if (c.fn == "set") {
        if (c.args.size() != 3) throw std::runtime_error("set(varName, key, value) takes 3 args");
        const QString varName = evalExpr(rt, *c.args[0]).toString();
        QVariant key = evalExpr(rt, *c.args[1]);
        QVariant value = evalExpr(rt, *c.args[2]);

        if (!rt.vars.contains(varName)) {
            throw std::runtime_error(QString("set: variable '%1' not found").arg(varName).toStdString());
        }

        QVariant container = rt.vars[varName];

        // Array indexing: set("arrayVar", index, value)
        if (container.typeId() == QMetaType::QVariantList) {
            QVariantList list = container.toList();
            const qint64 index = toInt(key);
            if (index < 0 || index >= list.size()) {
                throw std::runtime_error(QString("set: array index %1 out of bounds (size=%2)")
                    .arg(index).arg(list.size()).toStdString());
            }
            list[int(index)] = value;
            rt.vars[varName] = list;
            return value;
        }

        // Object field access: set("objectVar", "fieldName", value)
        if (container.typeId() == QMetaType::QVariantMap) {
            QVariantMap map = container.toMap();
            const QString fieldName = key.toString();
            map[fieldName] = value;
            rt.vars[varName] = map;
            return value;
        }

        throw std::runtime_error("set: variable must be an array or object");
    }

    auto readAt = [&](qint64 offset, int nbytes)->QByteArray {
        QIODevice* dev = rt.in->device();
        if (!dev) throw std::runtime_error("No device");
        if (offset < 0) throw std::runtime_error("readAt: offset must be >= 0");
        if (nbytes < 0) throw std::runtime_error("readAt: nbytes must be >= 0");
        const qint64 saved = dev->pos();
        if (!dev->seek(offset)) throw std::runtime_error("seek failed");
        QByteArray buf(nbytes, Qt::Uninitialized);
        const int got = rt.in->readRawData(buf.data(), nbytes);
        dev->seek(saved);
        if (got != nbytes) throw std::runtime_error("readAt short read");
        return buf;
    };

    // u8at(offset)
    if (c.fn == "u8at") {
        if (c.args.size() != 1) throw std::runtime_error("u8at(off) takes 1 arg");
        qint64 off = toInt(evalExpr(rt, *c.args[0]));
        QByteArray b = readAt(off, 1);
        return quint8(b[0]);
    }

    if (c.fn == "u16at") {
        if (c.args.size() != 1) throw std::runtime_error("u16at(off) takes 1 arg");
        qint64 off = toInt(evalExpr(rt, *c.args[0]));
        QByteArray b = readAt(off, 2);
        const quint8 b0 = quint8(b[0]), b1 = quint8(b[1]);
        if (rt.order == ByteOrder::LE) return quint16(b0 | (b1 << 8));
        return quint16((b0 << 8) | b1);
    }

    if (c.fn == "u32at") {
        if (c.args.size() != 1) throw std::runtime_error("u32at(off) takes 1 arg");
        qint64 off = toInt(evalExpr(rt, *c.args[0]));
        QByteArray b = readAt(off, 4);
        quint32 v = 0;
        if (rt.order == ByteOrder::LE) {
            v = quint32(quint8(b[0])) |
                (quint32(quint8(b[1])) << 8) |
                (quint32(quint8(b[2])) << 16) |
                (quint32(quint8(b[3])) << 24);
        } else {
            v = (quint32(quint8(b[0])) << 24) |
                (quint32(quint8(b[1])) << 16) |
                (quint32(quint8(b[2])) << 8) |
                quint32(quint8(b[3]));
        }
        return v;
    }

    if (c.fn == "i32at") {
        if (c.args.size() != 1) throw std::runtime_error("i32at(off) takes 1 arg");
        qint64 off = toInt(evalExpr(rt, *c.args[0]));
        QByteArray b = readAt(off, 4);
        qint32 v = 0;
        if (rt.order == ByteOrder::LE) {
            v = qint32(quint8(b[0])) |
                (qint32(quint8(b[1])) << 8) |
                (qint32(quint8(b[2])) << 16) |
                (qint32(quint8(b[3])) << 24);
        } else {
            v = (qint32(quint8(b[0])) << 24) |
                (qint32(quint8(b[1])) << 16) |
                (qint32(quint8(b[2])) << 8) |
                qint32(quint8(b[3]));
        }
        return v;
    }

    if (c.fn == "u64at") {
        if (c.args.size() != 1) throw std::runtime_error("u64at(off) takes 1 arg");
        qint64 off = toInt(evalExpr(rt, *c.args[0]));
        QByteArray b = readAt(off, 8);
        quint64 v = 0;
        if (rt.order == ByteOrder::LE) {
            for (int i = 0; i < 8; ++i) v |= (quint64(quint8(b[i])) << (8 * i));
        } else {
            for (int i = 0; i < 8; ++i) v = (v << 8) | quint8(b[i]);
        }
        return v;
    }

    // optional helper for magic checks
    if (c.fn == "bytesat") {
        if (c.args.size() != 2) throw std::runtime_error("bytesat(off,len) takes 2 args");
        qint64 off = toInt(evalExpr(rt, *c.args[0]));
        int len = int(toInt(evalExpr(rt, *c.args[1])));
        return readAt(off, len);
    }

    // Extract bytes from a byte array: bytesof(data, off, len)
    if (c.fn == "bytesof") {
        if (c.args.size() != 3) throw std::runtime_error("bytesof(data, off, len) takes 3 args");
        QByteArray data = evalExpr(rt, *c.args[0]).toByteArray();
        qint64 off = toInt(evalExpr(rt, *c.args[1]));
        int len = int(toInt(evalExpr(rt, *c.args[2])));
        if (off < 0 || off >= data.size()) return QByteArray();
        if (off + len > data.size()) len = data.size() - off;
        return data.mid(off, len);
    }

    if (c.fn == "ascii") {
        if (c.args.size() != 1) throw std::runtime_error("ascii(bytes) takes 1 arg");
        const QByteArray b = evalExpr(rt, *c.args[0]).toByteArray();
        return QString::fromLatin1(b); // strict 1:1 byte->char (good for magic tags)
    }

    if (c.fn == "cstring") {
        if (c.args.size() != 0) throw std::runtime_error("cstring() takes 0 args");
        // Read null-terminated string (C-style string)
        const qint64 startPos = rt.in->device() ? rt.in->device()->pos() : -1;
        QByteArray result;
        char ch;
        while (true) {
            if (rt.in->readRawData(&ch, 1) != 1) {
                throw std::runtime_error(
                    QString("cstring(): unexpected EOF at pos 0x%1. Parsing: %2")
                        .arg(rt.in->device() ? rt.in->device()->pos() : -1, 0, 16)
                        .arg(rt.typeStackString().isEmpty() ? "root" : rt.typeStackString())
                        .toStdString());
            }
            if (ch == '\0') break;
            result.append(ch);
        }
        return QString::fromUtf8(result);
    }

    if (c.fn == "set_global") {
        if (c.args.size() != 2) throw std::runtime_error("set_global(name, value) takes 2 args");
        const QString name = evalExpr(rt, *c.args[0]).toString();
        const QVariant value = evalExpr(rt, *c.args[1]);
        rt.module->globals[name] = value;
        return value;
    }

    if (c.fn == "get_global") {
        if (c.args.size() != 1) throw std::runtime_error("get_global(name) takes 1 arg");
        const QString name = evalExpr(rt, *c.args[0]).toString();
        if (rt.module->globals.contains(name)) {
            return rt.module->globals[name];
        }
        return QVariant(0);  // Default to 0 if not found
    }

    if (c.fn == "write_file") {
        if (c.args.size() != 2) throw std::runtime_error("write_file(filename, data) takes 2 args");
        const QString filename = evalExpr(rt, *c.args[0]).toString();
        const QByteArray data = evalExpr(rt, *c.args[1]).toByteArray();

        reportStatus(QString("Exporting %1...").arg(filename));

        // Use Utils::ExportData which writes to exports/ directory
        if (!Utils::ExportData(filename, data)) {
            throw std::runtime_error(("Failed to export file: " + filename).toStdString());
        }

        LogManager::instance().debug(QString("[EXPORT] Exported %1 bytes to exports/%2")
            .arg(data.size())
            .arg(filename));
        return data.size(); // Return number of bytes written
    }

    if (c.fn == "strip") {
        if (c.args.size() != 2) throw std::runtime_error("strip(string, chars) takes 2 args");
        QString str = evalExpr(rt, *c.args[0]).toString();
        QString chars = evalExpr(rt, *c.args[1]).toString();
        for (const QChar& ch : chars) {
            str.remove(ch);
        }
        return str;
    }

    if (c.fn == "basename") {
        if (c.args.size() != 1) throw std::runtime_error("basename(path) takes 1 arg");
        QString path = evalExpr(rt, *c.args[0]).toString();
        // Handle both forward and back slashes
        int lastSlash = path.lastIndexOf('/');
        int lastBackslash = path.lastIndexOf('\\');
        int pos = qMax(lastSlash, lastBackslash);
        if (pos >= 0) {
            return path.mid(pos + 1);
        }
        return path;
    }

    if (c.fn == "ends_with") {
        if (c.args.size() != 2) throw std::runtime_error("ends_with(string, suffix) takes 2 args");
        QString str = evalExpr(rt, *c.args[0]).toString();
        QString suffix = evalExpr(rt, *c.args[1]).toString();
        return str.endsWith(suffix, Qt::CaseInsensitive);
    }

    if (c.fn == "starts_with") {
        if (c.args.size() != 2) throw std::runtime_error("starts_with(string, prefix) takes 2 args");
        QString str = evalExpr(rt, *c.args[0]).toString();
        QString prefix = evalExpr(rt, *c.args[1]).toString();
        return str.startsWith(prefix, Qt::CaseInsensitive);
    }

    if (c.fn == "to_lower") {
        if (c.args.size() != 1) throw std::runtime_error("to_lower(string) takes 1 arg");
        return evalExpr(rt, *c.args[0]).toString().toLower();
    }

    if (c.fn == "trim") {
        if (c.args.size() != 1) throw std::runtime_error("trim(string) takes 1 arg");
        return evalExpr(rt, *c.args[0]).toString().trimmed();
    }

    if (c.fn == "clean") {
        // Find the last contiguous sequence of printable ASCII characters
        if (c.args.size() != 1) throw std::runtime_error("clean(string) takes 1 arg");
        QString input = evalExpr(rt, *c.args[0]).toString();

        QString lastValid;
        QString current;

        for (const QChar& ch : input) {
            ushort code = ch.unicode();
            // Printable ASCII (32-126)
            if (code >= 32 && code <= 126) {
                current.append(ch);
            } else {
                // Hit invalid char - if we had a valid sequence, save it
                if (!current.trimmed().isEmpty()) {
                    lastValid = current;
                }
                current.clear();
            }
        }

        // Check final segment
        if (!current.trimmed().isEmpty()) {
            lastValid = current;
        }

        return lastValid.trimmed();
    }

    if (c.fn == "preview") {
        // preview(data) - stores image data for UI preview
        // preview(filename, data) - stores with filename hint
        if (c.args.size() < 1 || c.args.size() > 2) throw std::runtime_error("preview(data) or preview(filename, data)");

        QString filename;
        QByteArray data;

        if (c.args.size() == 1) {
            data = evalExpr(rt, *c.args[0]).toByteArray();
            filename = "preview";
        } else {
            filename = evalExpr(rt, *c.args[0]).toString();
            data = evalExpr(rt, *c.args[1]).toByteArray();
        }

        // Store preview data in runtime vars for UI to pick up
        QVariantMap preview;
        preview["filename"] = filename;
        preview["data"] = data;
        preview["size"] = data.size();
        rt.vars["_preview"] = preview;

        LogManager::instance().debug(QString("[PREVIEW] Set preview: %1 (%2 bytes)")
            .arg(filename)
            .arg(data.size()));

        return true;
    }

    if (c.fn == "len") {
        if (c.args.size() != 1) throw std::runtime_error("len(value) takes 1 arg");
        QVariant v = evalExpr(rt, *c.args[0]);
        if (v.typeId() == QMetaType::QString) return v.toString().length();
        if (v.typeId() == QMetaType::QByteArray) return v.toByteArray().size();
        if (v.typeId() == QMetaType::QVariantList) return v.toList().size();
        throw std::runtime_error("len() requires string, bytes, or array");
    }

    throw std::runtime_error(("Unknown function: " + c.fn).toStdString());
}

QVariant Interpreter::evalPipe(Runtime& rt, const Expr::Pipe& p) const {
    QVariant v = evalExpr(rt, *p.base);

    for (const auto& stage : p.stages) {
        if (stage.fn == "zlib") {
            if (!v.canConvert<QByteArray>()) throw std::runtime_error("zlib stage expects bytes");

            const QByteArray in = v.toByteArray();
            const QByteArray decompressed = Compression::DecompressZLIB(in);

            // Match evalCall("zlib") behavior
            if (!rt.filePath.isEmpty()) {
                QFileInfo fi(rt.filePath);
                const QString stem = fi.completeBaseName();     // "mp_test_load"
                rt.vars["_zone_name"] = stem + ".zone";         // "mp_test_load.zone"
            }

            v = decompressed;
            continue;
        }

        if (stage.fn == "xmem") {
            if (!v.canConvert<QByteArray>()) throw std::runtime_error("xmem stage expects bytes");

            const QByteArray in = v.toByteArray();
            const QByteArray decompressed = Compression::DecompressXMem(in);

            if (!rt.filePath.isEmpty()) {
                QFileInfo fi(rt.filePath);
                const QString stem = fi.completeBaseName();
                rt.vars["_decompressed_name"] = stem + ".decompressed";
            }

            v = decompressed;
            continue;
        }

        if (stage.fn == "parse") {
            // stage args[0] is a String expr holding type name (we created it that way in parser)
            if (stage.args.size() != 1) throw std::runtime_error("parse stage requires type name");
            const QString typeName = stage.args[0]->node.index() == 1
                                         ? std::get<Expr::String>(stage.args[0]->node).v
                                         : evalExpr(rt, *stage.args[0]).toString();

            if (!v.canConvert<QByteArray>()) throw std::runtime_error("parse stage expects bytes");
            const QByteArray bytes = v.toByteArray();
            QDataStream nested(bytes);

            QVariantMap obj = runTypeInternal(typeName, nested, rt.filePath, rt.order);

            // propagate zone label just like evalCall("parse")
            if (rt.vars.contains("_zone_name") && !obj.contains("_zone_name")) {
                obj["_zone_name"] = rt.vars["_zone_name"];
            }

            obj["_type"] = typeName;
            v = obj;
            continue;
        }

        // Allow calling a stage as fn(current) for future extensions
        // e.g. stage "zlib" already handled above
        throw std::runtime_error(("Unknown pipeline stage: " + stage.fn).toStdString());
    }

    return v;
}

QVariant Interpreter::evalExpr(Runtime& rt, const Expr& e) const {
    if (std::holds_alternative<Expr::Int>(e.node)) {
        return std::get<Expr::Int>(e.node).v;
    }
    if (std::holds_alternative<Expr::String>(e.node)) {
        return std::get<Expr::String>(e.node).v;
    }
    if (std::holds_alternative<Expr::Var>(e.node)) {
        const QString name = std::get<Expr::Var>(e.node).name;
        // EOF is a sentinel used only inside read(...)
        if (name == "EOF") return QString("EOF");

        // Check local vars first, then globals
        if (rt.vars.contains(name)) {
            return rt.vars.value(name);
        }
        if (rt.module && rt.module->globals.contains(name)) {
            return rt.module->globals.value(name);
        }
        throw std::runtime_error(("Unknown variable: " + name).toStdString());
    }
    if (std::holds_alternative<Expr::Unary>(e.node)) {
        const auto& u = std::get<Expr::Unary>(e.node);
        QVariant rhs = evalExpr(rt, *u.rhs);
        if (u.op == "!") return !toBool(rhs);
        if (u.op == "-") return -toInt(rhs);
        if (u.op == "+") return +toInt(rhs);
        throw std::runtime_error(("Unknown unary op: " + u.op).toStdString());
    }
    if (std::holds_alternative<Expr::Binary>(e.node)) {
        const auto& b = std::get<Expr::Binary>(e.node);
        QVariant lv = evalExpr(rt, *b.lhs);
        QVariant rv = evalExpr(rt, *b.rhs);

        const QString& op = b.op;

        // comparisons/logical
        // For == and !=: use numeric comparison if both are convertible to numbers,
        // otherwise fall back to QVariant comparison (for strings, maps, etc.)
        if (op == "==" || op == "!=") {
            bool lnumeric = lv.canConvert<qint64>() &&
                           (lv.typeId() != QMetaType::QString && lv.typeId() != QMetaType::QVariantMap);
            bool rnumeric = rv.canConvert<qint64>() &&
                           (rv.typeId() != QMetaType::QString && rv.typeId() != QMetaType::QVariantMap);
            if (lnumeric && rnumeric) {
                qint64 lval = toInt(lv);
                qint64 rval = toInt(rv);
                return (op == "==") ? (lval == rval) : (lval != rval);
            }
            // Non-numeric: use QVariant comparison
            return (op == "==") ? (lv == rv) : (lv != rv);
        }
        if (op == "<")  return toInt(lv) <  toInt(rv);
        if (op == "<=") return toInt(lv) <= toInt(rv);
        if (op == ">")  return toInt(lv) >  toInt(rv);
        if (op == ">=") return toInt(lv) >= toInt(rv);
        if (op == "&&") return toBool(lv) && toBool(rv);
        if (op == "||") return toBool(lv) || toBool(rv);

        // Handle string concatenation for +
        if (op == "+") {
            // If either operand is a string, do string concatenation
            if (lv.typeId() == QMetaType::QString || rv.typeId() == QMetaType::QString) {
                return lv.toString() + rv.toString();
            }
            // Otherwise do integer addition
            return toInt(lv) + toInt(rv);
        }

        // arithmetic/bitwise
        const qint64 a = toInt(lv);
        const qint64 c = toInt(rv);
        if (op == "-")  return a - c;
        if (op == "*")  return a * c;
        if (op == "/")  return c == 0 ? 0 : (a / c);
        if (op == "%")  return c == 0 ? 0 : (a % c);
        if (op == "<<") return a << c;
        if (op == ">>") return a >> c;
        if (op == "&")  return a & c;
        if (op == "^")  return a ^ c;
        if (op == "|")  return a | c;

        throw std::runtime_error(("Unknown binary op: " + op).toStdString());
    }
    if (std::holds_alternative<Expr::Call>(e.node)) {
        return evalCall(rt, std::get<Expr::Call>(e.node));
    }
    if (std::holds_alternative<Expr::Pipe>(e.node)) {
        return evalPipe(rt, std::get<Expr::Pipe>(e.node));
    }

    throw std::runtime_error("Unknown expression node");
}

void Interpreter::execBlock(Runtime& rt, const QVector<StmtPtr>& body) const {
    for (const auto& s : body) {
        execStmt(rt, *s);
        reportProgress(rt);
    }
}

void Interpreter::execStmt(Runtime& rt, const Stmt& s) const {
    if (std::holds_alternative<Stmt::ReadScalar>(s.node)) {
        const auto& rs = std::get<Stmt::ReadScalar>(s.node);
        QVariant v = readScalar(rt, rs.type);
        rt.vars[rs.name] = v;
        return;
    }

    if (std::holds_alternative<Stmt::Skip>(s.node)) {
        const auto& sk = std::get<Stmt::Skip>(s.node);
        const qint64 n = toInt(evalExpr(rt, *sk.count));
        if (n < 0) throw std::runtime_error("skip n must be >= 0");
        const qint64 pos = rt.in->device() ? rt.in->device()->pos() : -1;
        const int skipped = rt.in->skipRawData(int(n));
        if (skipped != int(n)) {
            throw std::runtime_error(
                QString("Unexpected EOF during skip(%1) at pos 0x%2. Parsing: %3")
                    .arg(n).arg(pos, 0, 16)
                    .arg(rt.typeStackString().isEmpty() ? "root" : rt.typeStackString())
                    .toStdString());
        }
        return;
    }

    if (std::holds_alternative<Stmt::Align>(s.node)) {
        const auto& al = std::get<Stmt::Align>(s.node);
        const qint64 n = toInt(evalExpr(rt, *al.n));
        if (n <= 0) throw std::runtime_error("align(n): n must be > 0");
        QIODevice* dev = rt.in->device();
        const qint64 pos = dev->pos();
        const qint64 mod = pos % n;
        if (mod != 0) {
            const qint64 pad = n - mod;
            const int skipped = rt.in->skipRawData(int(pad));
            if (skipped != int(pad)) {
                throw std::runtime_error(
                    QString("Unexpected EOF during align(%1) at pos 0x%2. Parsing: %3")
                        .arg(n).arg(pos, 0, 16)
                        .arg(rt.typeStackString().isEmpty() ? "root" : rt.typeStackString())
                        .toStdString());
            }
        }
        return;
    }

    if (std::holds_alternative<Stmt::Seek>(s.node)) {
        const auto& se = std::get<Stmt::Seek>(s.node);
        const qint64 p = toInt(evalExpr(rt, *se.pos));
        if (p < 0) throw std::runtime_error("seek(pos): position must be >= 0");
        QIODevice* dev = rt.in->device();
        if (!dev->seek(p)) throw std::runtime_error("seek(pos) failed");
        return;
    }

    if (std::holds_alternative<Stmt::Assign>(s.node)) {
        const auto& as = std::get<Stmt::Assign>(s.node);
        QVariant v = evalExpr(rt, *as.value);
        rt.vars[as.name] = v;

        // Log assignments of key fields for debugging
        if (as.name == "_name" || as.name == "asset_type" || as.name == "_type") {
            LogManager::instance().debug(QString("[ASSIGN] %1 = '%2'")
                .arg(as.name)
                .arg(v.toString()));
        }

        // Store hidden flag if set
        if (as.ui.hidden) {
            rt.vars["_hidden"] = true;
        }
        return;
    }

    if (std::holds_alternative<Stmt::If>(s.node)) {
        const auto& iff = std::get<Stmt::If>(s.node);
        const bool cond = toBool(evalExpr(rt, *iff.cond));
        execBlock(rt, cond ? iff.thenBody : iff.elseBody);
        return;
    }

    if (std::holds_alternative<Stmt::While>(s.node)) {
        const auto& wh = std::get<Stmt::While>(s.node);
        try {
            while (toBool(evalExpr(rt, *wh.cond))) {
                execBlock(rt, wh.body);
            }
        } catch (const BreakException&) {
            // break statement encountered, exit loop
        }
        return;
    }

    if (std::holds_alternative<Stmt::Repeat>(s.node)) {
        const auto& rp = std::get<Stmt::Repeat>(s.node);
        qint64 count = toInt(evalExpr(rt, *rp.count));
        if (count < 0) count = 0;

        const qint64 startPos = rt.in->device() ? rt.in->device()->pos() : -1;
        LogManager::instance().debug(QString("[REPEAT] Starting repeat loop: count=%1, pos=0x%2")
            .arg(count)
            .arg(startPos, 0, 16));

        // provide _i for repeat index
        const QVariant old = rt.vars.value("_i");
        const bool hadOld = rt.vars.contains("_i");

        try {
            for (qint64 i = 0; i < count; i++) {
                const qint64 iterPos = rt.in->device() ? rt.in->device()->pos() : -1;
                LogManager::instance().debug(QString("[REPEAT] Iteration %1/%2 at pos 0x%3")
                    .arg(i)
                    .arg(count)
                    .arg(iterPos, 0, 16));
                rt.vars["_i"] = i;
                execBlock(rt, rp.body);
            }
        } catch (const BreakException&) {
            // break statement encountered, exit loop
        }

        const qint64 endPos = rt.in->device() ? rt.in->device()->pos() : -1;
        LogManager::instance().debug(QString("[REPEAT] Finished repeat loop at pos 0x%1")
            .arg(endPos, 0, 16));

        if (hadOld) rt.vars["_i"] = old;
        else rt.vars.remove("_i");
        return;
    }

    if (std::holds_alternative<Stmt::ForRange>(s.node)) {
        const auto& fr = std::get<Stmt::ForRange>(s.node);
        qint64 start = toInt(evalExpr(rt, *fr.start));
        qint64 end   = toInt(evalExpr(rt, *fr.end));
        if (end < start) end = start;

        const QVariant old = rt.vars.value(fr.var);
        const bool hadOld = rt.vars.contains(fr.var);

        try {
            for (qint64 i = start; i < end; i++) {
                rt.vars[fr.var] = i;
                execBlock(rt, fr.body);
            }
        } catch (const BreakException&) {
            // break statement encountered, exit loop
        }

        if (hadOld) rt.vars[fr.var] = old;
        else rt.vars.remove(fr.var);
        return;
    }

    if (std::holds_alternative<Stmt::Require>(s.node)) {
        const auto& rq = std::get<Stmt::Require>(s.node);
        const bool ok = toBool(evalExpr(rt, *rq.cond));
        if (!ok) throw std::runtime_error("criteria require failed");
        return;
    }

    if (std::holds_alternative<Stmt::SetByteOrder>(s.node)) {
        const auto& bo = std::get<Stmt::SetByteOrder>(s.node);
        rt.order = bo.order;
        applyByteOrder(rt);
        return;
    }

    if (std::holds_alternative<Stmt::CallStmt>(s.node)) {
        const auto& cs = std::get<Stmt::CallStmt>(s.node);
        evalExpr(rt, *cs.call); // Execute function, discard result
        return;
    }

    if (std::holds_alternative<Stmt::Break>(s.node)) {
        throw BreakException{};
    }

    throw std::runtime_error("Unknown statement node");
}