const fs = require('fs/promises');
const path = require('path');

/**
 * purely convienience 
 */
class FileDependecy {
    name;
    folder;
    path() {
        return this.folder + '/' + this.name;
    }
}

/**
 * Ordered Access Object
 * purely convienience 
 */
class OAO {
    constructor() {
        /**
         * @type {boolean|Map<string,FileDependecy>}
         */
        this.orderedGroups
        /**
         * @type {Array<string>}
         */
        this.keys = [];
        /**
         * @type {map<string, FileDependecy>}
         */
        this.objects = {};
        /**
         * @type {boolean}
         */
        this.isOrdered = false;
    }
}

let fileOrder = Object.assign(new OAO(), require('./fileOrder.json'));

fileOrder.objects = fileOrder.keys
    .reduce((a, fileName) => Object.assign(
        a,
        { [fileName]: Object.assign(new FileDependecy(), fileOrder.objects[fileName]) }
    ), {});

/**
 * Kept for future reference, might be that we will return to the dependency resolvement approach.
 * @param {OAO} oao 
 * @returns {OAO}
 */
function resolveDependencyOrder(oao) {
    let roots = oao.keys.filter(k => oao.objects[k].dependencies.length === 0);

    let folderList = [...new Set(oao.keys.map(k => oao.objects[k].folder))];

    console.log("Folders", folderList);

    /**
     * 
     * @param {OAO} oao 
     * @param {Array<Array<string>>} dealt 
     */
    function recursiveResolvement(oao, dealtLvls, dealt) {
        const arrsEqualSize = (arr1, arr2) => arr1.length === arr2.length;
        const arrHasAll = (arr1, arr2) => arr2.every(k => arr1.includes(k))

        if (oao.keys.length === dealt.length) {
            return [...dealt, ...current];
        } else {
            console.log(`Received ${dealt.length} dealt of ${oao.keys.length}`);
        }

        let remaining = oao.keys
            .filter(k => !dealt.includes(k));

        if (remaining.length < 2) {
            return [...dealt, ...remaining];
        }

        let current = remaining
            .filter(k => oao.objects[k].dependencies.every(sk => dealt.includes(sk)));

        if (current.length === 0) {
            console.log("Couldn't resolve", remaining);
            return remaining;
        }

        dealtLvls.push(current);

        if (arrsEqualSize(remaining, current)) {
            return [...dealt, ...current];
        }

        return recursiveResolvement(oao, dealtLvls, [...dealt, ...current]);
    }

    let recursiveResolved = recursiveResolvement(oao, [roots], roots);

    recursiveResolved
        .forEach((k, i) => {
            oao.objects[k].orderNr = i;
        });

    oao.isOrdered = recursiveResolved.slice(-1).length <= 2;
    if (oao.isOrdered) {
        oao.keys = recursiveResolved;
    }
    return oao;
}


function appendContent(srcFile, targetFile) {
    return fs.readFile(srcFile, 'utf8')
        .then(content => {
            console.log(`Processing '${srcFile}'`);
            console.log(`           READ: successfully!`)
            console.log(`           Attepting to append`);
            return fs.appendFile(targetFile, content);
        })
        .then(() => {
            console.log(`           Append/Write: successfully!`);
        })
        .catch(error => {
            console.error(`Error reading/writing files: ${error.message}`);
        })
}


let orderedJoinList = Object.keys(fileOrder.orderedGroups)
    .flatMap(groupName => fileOrder.orderedGroups[groupName])
    .map(fileName => fileOrder.objects[fileName].path());

/*
// Kept for future reference, might be that we will return to the dependency resolvement approach.
fileOrder = resolveDependencyOrder(fileOrder);

let orderedJoinList = fileOrder.keys
    .map(fileName => fileOrder.objects[k].path());
*/



const targetFile = "./jpc-like-websites.js";
console.log("(Re-) Creating target file: '" + targetFile + "'");


/* EMPTY (create?) TARGET FILE */
fs.writeFile(targetFile, "", err => { })

orderedJoinList
    .reduce((prevPromise, filePath) => prevPromise
    .then(
        ()=>appendContent(filePath, targetFile)
    ), Promise.resolve())