// SPDX-License-Identifier: LGPL-2.1-or-later

const fs = require("fs");
const path = require("path");
const { pathToFileURL } = require("url");

const buildDirectory = path.resolve(process.argv[2] || "build-web/assembly-configure/bin");

async function main()
{
    globalThis.__dirname = `${buildDirectory}${path.sep}`;
    globalThis.require = require;
    const moduleUrl = pathToFileURL(path.join(buildDirectory, "FreeCADWebAssemblyProbe.js")).href;
    const module = await import(moduleUrl);
    const probe = await module.default({
        wasmBinary: fs.readFileSync(path.join(buildDirectory, "FreeCADWebAssemblyProbe.wasm")),
    });
    const call = (name, returnType = "number", argTypes = [], args = []) => probe.ccall(name, returnType, argTypes, args);
    const error = () => ({
        code: call("fc_web_assembly_error_code", "string"),
        message: call("fc_web_assembly_error_message", "string"),
    });
    const result = {};

    result.initialize = call("fc_web_assembly_initialize", "number", ["string"], ["AssemblyApp"]);
    result.initializeAgain = call("fc_web_assembly_initialize", "number", ["string"], ["AssemblyApp"]);
    result.type = call("fc_web_assembly_type_probe", "number", ["string"], ["Assembly::AssemblyObject"]);
    result.typeName = call("fc_web_assembly_last_type", "string");
    result.stateAfterValid = {
        calls: call("fc_web_assembly_initialization_calls"),
        runs: call("fc_web_assembly_initialization_runs"),
        initialized: call("fc_web_assembly_initialized"),
    };
    result.handle = call("fc_web_assembly_create_handle", "number", ["string"], ["Assembly::AssemblyObject"]);
    result.activeBeforeRelease = call("fc_web_assembly_active_handles");
    result.release = call("fc_web_assembly_release_handle", "number", ["number"], [result.handle]);
    result.activeAfterRelease = call("fc_web_assembly_active_handles");
    result.unknownType = call("fc_web_assembly_type_probe", "number", ["string"], ["Assembly::Missing"]);
    result.unknownTypeError = error();
    result.unknownModule = call("fc_web_assembly_initialize", "number", ["string"], ["Missing"]);
    result.unknownModuleError = error();
    result.guiModule = call("fc_web_assembly_initialize", "number", ["string"], ["AssemblyGui"]);
    result.guiModuleError = error();
    result.emptyModule = call("fc_web_assembly_initialize", "number", ["string"], [""]);
    result.emptyModuleError = error();
    result.stateAfterErrors = {
        calls: call("fc_web_assembly_initialization_calls"),
        runs: call("fc_web_assembly_initialization_runs"),
        initialized: call("fc_web_assembly_initialized"),
    };

    const valid = result.initialize === 1
        && result.initializeAgain === 1
        && result.type === 1
        && result.typeName === "Assembly::AssemblyObject"
        && result.stateAfterValid.calls === 3
        && result.stateAfterValid.runs === 1
        && result.stateAfterValid.initialized === 1
        && result.handle === 1
        && result.activeBeforeRelease === 1
        && result.release === 1
        && result.activeAfterRelease === 0
        && result.unknownType === 0
        && result.unknownTypeError.code === "type_not_found"
        && result.unknownModule === 0
        && result.unknownModuleError.code === "module_unavailable"
        && result.guiModule === 0
        && result.guiModuleError.code === "gui_dependency_unavailable"
        && result.emptyModule === 0
        && result.emptyModuleError.code === "invalid_argument"
        && result.stateAfterErrors.calls === 5
        && result.stateAfterErrors.runs === 1
        && result.stateAfterErrors.initialized === 1;
    if (!valid) {
        throw new Error(JSON.stringify(result));
    }
    console.log(JSON.stringify(result));
}

main().catch((error) => {
    console.error(error);
    process.exitCode = 1;
});