/**
 * definition of the main module function: 
 * it takes an anonymous function as a parameter
 * the anonymous function has one parameter: the object encompassing 
 * ARCS definitions (in order to able to use ARCS.Component.create, ...)
 * @param moduleDefinition {function} main function of the module. 
 * It should return a list of components
 * @param deps {mixed[]} dependencies
 */

// TODO arcs_module seems to be not needed anymore!!!!
// more cunning, this time, we export an arcs_module function 
// that we call later!
// still we need to do something about it in order to register
// components.
// in fact factories should be registered in load library.

// reimplementation using native promises
arcs_module = function(moduleDefinition, deps) {
    var storeComponents, i;
    
    if (typeof module !== 'undefined') {
        if (module.parent.exports) {
            ARCS = module.exports; 
        }
    }
    
    if (deps === undefined) { deps = []; }
    
    storeComponents = function (deps) {
        var mdef, p;
        // we should insert ARCS at the beginning of deps !
        deps.unshift(ARCS);
        
        mdef = (typeof moduleDefinition === 'function') ?
                moduleDefinition.apply(this, deps) : moduleDefinition;

        if (mdef === undefined) {
            throw new Error("[ARCS] Your module is undefined. Did you forget to export components?\nCode of module follows:\n" +moduleDefinition);
        }

        for (p in mdef) {
            if (mdef.hasOwnProperty(p) && ARCS.Context.currentContext != null) {
                ARCS.Context.currentContext.setFactory(p,mdef[p]); //.setFactory(ARCS.Application.currentApplication, p, mdef[p]);
            }
        }
        
        return Promise.resolve();
    };
    // until now, it is the very same code.
    
    // here we create a promise to solve dependency
    // reject has the dependency name, while resolve has the object
    var depResolve = function(dep) {
        return new Promise(function(resolve, reject) {  
            var d,shimConfig;
            if (ARCS.isInNode()) {
                d = require(dep);
                if (d === undefined) {
                    reject(dep);
                } else {
                    resolve(d);
                }
            } else {
                // this one a little bit trickier since we have to shim.
                if (dep.name !== undefined) {
                    shimConfig = { shim: {} };
                    shimConfig.shim[dep.name] = { exports: dep.exports };
                    if (dep.deps !== undefined) {
                        shimConfig.shim[dep.name].deps = dep.deps;
                    }
                    require.config(shimConfig);
                    dep = dep.name;
                }
                // shim performed
                require([dep], 
                        function(d) { resolve(d); },
                        function(err) { console.log("[ARCS] Trouble with module ", dep); reject(dep, err); }
                );
            }
        });            
    };
        
    var depResolves = [];
    for (i=0; i<deps.length; i++) {
        depResolves[i] = depResolve(deps[i]);
    }
    
 
    
        ARCS.Context.currentContext.addLibraryPromise(
            Promise.all(depResolves).then(storeComponents,
            function(reason) { console.error("[ARCS] Failed to load dependency ", reason ); })
        
        );
    
}