ATLYSS TechPendium

function resolveArgs(args) {
    if (args == null) return {};

    if (Array.isArray(args)) {
        if (args.length === 1 && typeof args[0] === "object" && args[0] !== null) {
            return args[0];
        }

        const out = {};
        for (let i = 0; i < args.length; i++) {
            out[i] = args[i];
        }
        return out;
    }

    if (typeof args === "object") {
        return args;
    }

    return { 0: args };
}
function isModuleEmpty(mod) {
    return !mod || Object.keys(mod).length === 0;
}

async function resolveData(moduleName, test = false, version) {
    const versionsModuleName = test ? `TEST/Versions` : `Versions`;
    const Versions = await requireData(versionsModuleName);
    const LatestGameVersion = Versions.latest;
    const VersionEntries = Versions.versions || [];

    if (version) {
        const forcedName = test ? `TEST/${moduleName}/data/${version}` : `${moduleName}/data/${version}`;

        if (!availablePages.has(`Module:${forcedName}`)) return { data: {}, version };

        return { data: await requireData(forcedName), version }
    }

    const requireName = test ? `TEST/${moduleName}/data/${LatestGameVersion}` : `${moduleName}/data/${LatestGameVersion}`;
    if (availablePages.has(`Module:${requireName}`)) return { data: await requireData(requireName), version: LatestGameVersion };

    // Fallback: iterate versions list in order
    for (const entry of VersionEntries) {
        const v = entry.id;
        const candidateName = test ? `TEST/${moduleName}/data/${v}` : `${moduleName}/data/${v}`
        if (availablePages.has(`Module:${candidateName}`)) return { data: await requireData(candidateName), version: v };
    }

    return { data: {}, version: null };
}

function sortObjectByKey(obj) {
    return Object.keys(obj).sort().reduce((result, key) => {
        result[key] = obj[key];
        return result;
    }, {});
}

function filterObjectByProperty(obj, key, value) {
    return Object.fromEntries(
        Object.entries(obj).filter(([_, v]) => v[key] === value)
    );
}

function sortObject(obj, compareFunction) {
    // Turn the object into an array of objects
    const entries = Object.entries(obj);

    // Sort the array using the provided compare function
    entries.sort((a, b) => compareFunction(a[1], b[1]));

    // Convert the sorted array back into an object
    return Object.fromEntries(entries);
}

function findByProperty(obj, key, value) {
    return Object.values(obj).find(item => item[key] === value);
}

async function resolveItemByGuid(guid, options = {}) {
    if (!guid) return null;

    const { test = false, version } = options;

    const [
        { data: TradeItems },
        { data: Equipment },
        { data: Consumables }
    ] = await Promise.all([
        resolveData("Trade_Items", test, version),
        resolveData("Equipment", test, version),
        resolveData("Consumables", test, version)
    ]);

    const search = (obj, category) => {
        const found = Object.values(obj || {}).find(i => i.guid === guid);
        if (!found) return null;
        return { ...found, category };
    };

    return (
        search(TradeItems, "Trade") ||
        search(Equipment, "Equipment") ||
        search(Consumables, "Consumable") ||
        null
    );
}

async function resolveConditionSource(sourceGuid, options = {}) {
    if (!sourceGuid) return null;

    const { test = false, version } = options;

    const [
        { data: Consumables}
    ] = await Promise.all([
        resolveData("Consumables", test, version)
    ]);

    const search = (obj, category) => {
        const found = Object.values(obj || {}).find(i => i.guid === sourceGuid);
        if (!found) return null;
        return { ...found, category };
    };

    return (
        search(Consumables, "Consumable") ||
        null
    );
}

exports = {
    resolveArgs,
    isModuleEmpty,
    resolveData,
    sortObjectByKey,
    filterObjectByProperty,
    sortObject,
    findByProperty,
    resolveItemByGuid,
    resolveConditionSource
}