// utils.js — 多种命名导出方式

// 方式 1：声明时导出
export function formatDate(date) {
    return date.toISOString().split('T')[0];
}

export const MAX_SIZE = 1024 * 1024;

export class EventEmitter {
    #listeners = {};

    on(event, fn) {
        (this.#listeners[event] ??= []).push(fn);
    }

    emit(event, ...args) {
        (this.#listeners[event] ?? []).forEach(fn => fn(...args));
    }
}

// 方式 2：末尾统一导出
function helperA() { return 'a'; }
function helperB() { return 'b'; }
const SECRET = 'abc123';

export { helperA, helperB, SECRET };

// 方式 3：重命名导出
export { helperA as a, helperB as b };

// logger.js — 默认导出
export default class Logger {
    #prefix;

    constructor(prefix = 'LOG') {
        this.#prefix = prefix;
    }

    info(msg) { console.log(`[${this.#prefix}] INFO: ${msg}`); }
    warn(msg) { console.warn(`[${this.#prefix}] WARN: ${msg}`); }
    error(msg) { console.error(`[${this.#prefix}] ERROR: ${msg}`); }
}

// app.js — 各种导入方式
import Logger from "./logger.js";                              // 默认导入
import { formatDate, MAX_SIZE } from "./utils.js";            // 命名导入
import { helperA as a } from "./utils.js";                    // 别名导入
import * as utils from "./utils.js";                          // 命名空间导入
import Logger2, { EventEmitter } from "./utils.js";           // 混合导入

// 动态导入（第 5.6 节详述）
const mod = await import("./dynamic.js");

// index.js — 模块聚合
export { default as Logger } from "./logger.js";
export { formatDate, MAX_SIZE } from "./utils.js";
export * from "./utils.js";                    // 重导出所有（不含 default）
export * as utils from "./utils.js";           // 作为命名空间重导出

// a.js
import { bFunc } from "./b.js";

export function aFunc() {
    return "a:" + bFunc();
}

console.log("Module a loaded");

// b.js
import { aFunc } from "./a.js";

export function bFunc() {
    return "b";
}

console.log("Module b loaded, aFunc():", aFunc()); // 可能报错或得到未完成的绑定

# 编译单个模块为字节码
./qjsc -o mymodule.qjsc -m mymodule.js

# 编译整个应用（包含所有依赖模块）
./qjsc -o app.qjsc -m app.js

# 生成 C 嵌入文件
./qjsc -c -o bytecode.h \
    -m module_a.js \
    -m module_b.js \
    -m app.js

# 指定模块名
./qjsc -c -o bytecode.h -M mylib -m ./lib/mylib.js

// bytecode_loader.c
#include "quickjs-libc.h"
#include <stdio.h>

// 假设 qjsc 已生成如下字节数组（在 bytecode.h 中）
// extern const uint8_t mymodule_bytecode[];
// extern const uint32_t mymodule_bytecode_size;

static JSValue js_load_bytecode_module(JSContext *ctx,
                                        const char *module_name) {
    // 根据模块名查找对应的字节码
    const uint8_t *buf;
    uint32_t buf_len;

    if (strcmp(module_name, "mymodule") == 0) {
        buf = mymodule_bytecode;
        buf_len = mymodule_bytecode_size;
    } else {
        return JS_ThrowTypeError(ctx, "Unknown module: %s", module_name);
    }

    // 加载字节码
    JSValue obj = JS_ReadObject(ctx, buf, buf_len, JS_READ_OBJ_BYTECODE);
    if (JS_IsException(obj)) return obj;

    // 编译为模块
    JSValue result = JS_EvalFunction(ctx, obj);
    return result;
}

// custom_loader.c — 自定义模块加载器
#include "quickjs-libc.h"
#include <stdio.h>
#include <string.h>

// 模块源码存储结构
typedef struct {
    const char *name;
    const char *source;
} ModuleEntry;

// 预定义的模块表（编译时嵌入）
static ModuleEntry builtin_modules[] = {
    { "math", "export function add(a,b){return a+b} export const PI=3.14;" },
    { "greet", "export default function(name){return `Hello, ${name}!`}" },
    { NULL, NULL }
};

// 查找模块源码
static const char* find_module_source(const char *name) {
    for (ModuleEntry *e = builtin_modules; e->name; e++) {
        if (strcmp(e->name, name) == 0) return e->source;
    }
    return NULL;
}

// 模块查找回调
static JSModuleDef* custom_module_loader(JSContext *ctx,
                                          const char *module_name,
                                          void *opaque) {
    // 先尝试从内存表查找
    const char *source = find_module_source(module_name);
    if (source) {
        JSValue func_val = JS_Eval(ctx, source, strlen(source),
                                    module_name, JS_EVAL_TYPE_MODULE);
        if (JS_IsException(func_val)) {
            // 返回 NULL 表示加载失败
            return NULL;
        }
        JSModuleDef *m = JS_VALUE_GET_PTR(func_val);
        JS_FreeValue(ctx, func_val);
        return m;
    }

    // 回退到默认文件加载
    return NULL; // 让 QuickJS 尝试默认加载
}

// 注册自定义加载器
void setup_custom_loader(JSContext *ctx) {
    JS_SetModuleLoaderFunc(JS_GetRuntime(ctx),
                           NULL,               // normalize 回调
                           custom_module_loader,
                           NULL);              // opaque 数据
}

int main() {
    JSRuntime *rt = JS_NewRuntime();
    JSContext *ctx = JS_NewContext(rt);

    setup_custom_loader(ctx);

    const char *code = R"(
        import { add, PI } from "math";
        import greet from "greet";

        console.log("2 + 3 =", add(2, 3));
        console.log("PI =", PI);
        console.log(greet("QuickJS"));
    )";

    JSValue result = JS_Eval(ctx, code, strlen(code), "<main>",
                              JS_EVAL_TYPE_MODULE);
    if (JS_IsException(result)) {
        JSValue ex = JS_GetException(ctx);
        const char *msg = JS_ToCString(ctx, ex);
        fprintf(stderr, "Error: %s\n", msg);
        JS_FreeCString(ctx, msg);
        JS_FreeValue(ctx, ex);
    }
    JS_FreeValue(ctx, result);

    JS_FreeContext(ctx);
    JS_FreeRuntime(rt);
    return 0;
}

// module_normalize.c — 模块路径规范化
#include "quickjs-libc.h"
#include <string.h>
#include <stdlib.h>
#include <libgen.h>

static char* normalize_path(const char *base, const char *name) {
    // 简化实现：相对于基础模块的路径解析
    if (name[0] == '.') {
        char *base_copy = strdup(base);
        char *dir = dirname(base_copy);
        char *result = malloc(strlen(dir) + strlen(name) + 2);
        sprintf(result, "%s/%s", dir, name);
        free(base_copy);
        return result;
    }
    return strdup(name);
}

static JSValue module_normalize(JSContext *ctx,
                                 const char *module_name,
                                 const char *base_name,
                                 void *opaque) {
    char *normalized = normalize_path(base_name, module_name);
    JSValue result = JS_NewString(ctx, normalized);
    free(normalized);
    return result;
}

// 注册时传入 normalize 回调
JS_SetModuleLoaderFunc(JS_GetRuntime(ctx),
                       module_normalize,  // normalize
                       custom_loader,     // load
                       NULL);

// dynamic_import.js
async function loadModule(name) {
    try {
        const module = await import(name);
        console.log("Module loaded:", Object.keys(module));
        return module;
    } catch (e) {
        console.error("Failed to load:", name, e.message);
        return null;
    }
}

// 条件加载
const module = await loadModule("./optional_feature.js");
if (module) {
    module.doSomething();
} else {
    console.log("Feature not available");
}

# Makefile — 编译为字节码
QJS=qjs
QJSC=qjsc

all: app.qjsc

# 编译所有模块为字节码
app.qjsc: src/app.js src/utils.js src/config.js
	$(QJSC) -o $@ -m $^

# 生成 C 嵌入头文件
bytecode.h: src/app.js src/utils.js src/config.js
	$(QJSC) -c -o $@ -m $^

clean:
	rm -f app.qjsc bytecode.h