programs.js

const fs = require('fs')

function addModuleToProgram(program, path) {
    // source -> heap
    if (fs.existsSync(path)) {
        var src = require(path)
        var mod = new src()

        // wants unique module id's 
        if(program.description.counter == null){
            program.description.counter = 0
        } else {
            program.description.counter ++ 
        }

        // make unique name 
        mod.description.id = mod.description.id = mod.description.name + '-' + program.description.counter
        mod.description.path = path
        
        // add to program object 
        program.modules[mod.description.id] = mod

        // input need references for later hookup
        for (key in mod.inputs) {
            mod.inputs[key].parentId = mod.description.id
            mod.inputs[key].key = key
        }

        // state updating, begs for update 
        for (key in mod.state) {
            if (key == 'onChange' | key == 'emitChange' | key == 'emitters') {
                //console.log('rolling past change fn')
            } else {
                mod.state['_' + key] = mod.state[key]
                mod.state[key] = {}
                writeStateObject(mod, key)
            }
        }

        if (program.description.id == null) {
            if (program.description.name == null) {
                if (program.description == null) {
                    program.description = {}
                }
                program.description.name = 'unnamed program'
            }
            program.description.id = program.description.name + '-' + 0
        }

        console.log('ADDING', mod.description.id, 'to', program.description.id)
        // also return it so that we can write programs without the UI 
        return mod
    } else {
        console.log('ERR no module found at ', path)
    }
}

function writeStateObject(mod, key) {
    Object.defineProperty(mod.state, key, {
        set: function(x) {
            // update internal value 
            this['_' + key] = x
            //console.log('SET', key, this['_' + key])
            // push to internal state change handler
            this.emitChange(key)
            // update server (or in some cases, a confirmation)
            putState(mod)
        }
    })
    Object.defineProperty(mod.state, key, {
        get: function() {
            //console.log('GET', key, this['_' + key])
            return this['_' + key]
        }
    })
}

function saveProgram(prgmem, path) {
    // ok, and we're interested in just copying the relevant things ... 
    var svprgmem = {
        description: {
            name: prgmem.description.name,
            counter: prgmem.description.counter
        },
        modules: {}
    }

    var mdls = prgmem.modules

    for(key in mdls){
        var mdl = mdls[key]
        var og = makeRepFromModule(mdl)
        svprgmem.modules[mdl.description.id] = og 
    }

    fs.writeFileSync(path, JSON.stringify(svprgmem, null, 2), 'utf8')
}


function openProgram(path){
    var program = {}

    // get the .json file as an object 
    var prgRep = JSON.parse(fs.readFileSync(path, 'utf8'))
    console.log('OPENING THIS PRGRAM REP', prgRep)

    // copy-pasta the program descro, 
    program.description = {
        name: prgRep.description.name,
        counter: 0,
        id: prgRep.description.name + 1, // in another world, we count
        path: path
    }

    // gonna get those modules from source
    program.modules = {}

    for(key in prgRep.modules){
        var mdlRep = prgRep.modules[key]
        addModuleToProgram(program, mdlRep.description.path)
    }

    // gonna hook 'em up
    for(modName in prgRep.modules){
        // keys should be identical for rep and heap
        var mdlRep = prgRep.modules[modName]
        var mdl = program.modules[modName]

        for(outName in mdlRep.outputs){
            var outRep = mdlRep.outputs[outName]
            // each has some caller ids 
            for(nestedInputRep in outRep.calls){
                // conn from tl program -> this hookup 
                var nIRParent = outRep.calls[nestedInputRep].parentId
                var nIRKey = outRep.calls[nestedInputRep].key 
                var nI = program.modules[nIRParent].inputs[nIRKey]
                console.log("ATTACHING", nIRKey, 'to', outName)
                mdl.outputs[outName].attach(nI)
            }
        }
    }

    // once modules exist, link inputs / outputs / copy state ? 


    return program
}

module.exports = {
    open: openProgram,
    save: saveProgram,
    addModule: addModuleToProgram
}