var requireCounter = 0;

function Module(id) {
    this.id = id;

    this.depIds = [];     // Module dependencies
    this.depExports = []; // Dependencies values (1)
    this.depCount = 0;    // Counter representing the number of dependencies
                          // still pending (2)

    // No id => it's a call to the function require => we generate a new id
    if (!this.id) { (3)
        this.id = '_@r' + (requireCounter += 1);
    }

    this.events = {}; // event => [listeners] (4)

    this.url = baseUrl + this.id + '.js';
};

Module.prototype = {

    /*
     * Register a new listener.
     */
    on: function (name, callback) {
        var callbacks = this.events[name];
        if (!callbacks) {
            callbacks = this.events[name] = [];
        }
        callbacks.push(callback);
    },

    /*
     * Notify all listeners.
     */
    emit: function (name, evt) {
        (this.events[name] || []).forEach(function (callback) {
            callback(evt);
        });
    }
};

Module.prototype = {

    /*
     * Init a new module.
     *
     * @param depIds Dependencies of the module
     * @param factory Instantiation callback
     * @param enabled Immediate activation enabled
     *                (used by require),
     */
    init: function (depIds, factory, enabled) {
        if (this.inited) {
            return;
        }

        this.enabled = this.enabled || enabled;
        this.factory = factory;
        this.depIds = depIds || [];

        // Flag indicating that the module is currently initializing
        this.inited = true;

        if (this.enabled) {
            this.enable();
        }
    },

    enable: function () {
        this.enabled = true; (1)

        // Enable every dependency successively
        var module = this;
        this.depIds.forEach(function (id, i) { (2)
            var mod;

            if (!registry[id]) {
                mod = new Module(id);
                registry[id] = mod;

                module.depCount += 1; (3)

                mod.on('defined', function (depExports) { (4)
                    module.depCount -= 1;
                    module.depExports[i] = depExports;
                    module.check();
                });
            }

            mod = registry[id];

            if (!mod.enabled) {
                mod.enable();
            }
        });

        this.check(); (5)
    }

}

Module.prototype = {

    /*
     * Checks if the module is ready to define itself, and if so,
     * define it.
     */
    check: function () {
        if (!this.enabled) {
            return;
        }

        if (!this.inited) {
            this.load();
        } else {
            this.define();
        }
    },

    define: function() {
        var id = this.id,
        depExports = this.depExports,
        exports = this.exports,
        factory = this.factory;

        if (this.depCount < 1 && !this.defined) {
            if (typeof factory === "function") {
                factory.apply(exports, depExports);
            } else {
                // Just a literal value
                exports = factory;
            }

            this.exports = exports;

            this.defined = true;
            this.emit('defined', this.exports);
        }
    }

};

require = function (deps, factory) {
    var module = new Module();
    module.init(deps, factory, true);
}

require(["helper/util"], function(util) {
   // ...
});

define({
    // ...
});

var defQueue = [];

define = function (id, deps, factory) {
    // Allow for anonymous modules
    if (typeof id !== 'string') { (1)
        // Adjust args appropriately
        factory = deps;
        deps = id;
        id = null;
    }

    // This module may not have dependencies
    if (!Array.isArray(deps)) { (2)
        factory = deps;
        deps = null;
    }

    defQueue.push([id, deps, factory]); (3)
};

/**
 * Do the request to load a module for the browser case.
 * Make this a separate function to allow other environments
 * to override it.
 *
 * @param {String} id the name of the module.
 * @param {Object} url the URL to the module.
 */
function load(id, url) {
    var head = document.getElementsByTagName('head')[0];

    var node = document.createElement('script');
    node.type = 'text/javascript';
    node.charset = 'utf-8';
    node.async = true;
    node.addEventListener('load', function() { (1)
        completeLoad(id);
    }, false);
    node.src = url;

    head.appendChild(node);

    return node;
};

/**
 * Complete a load event.
 * @param {String} id the id of the module to potentially complete.
 */
function completeLoad(id) {
    /*
     * We iterate over all saved modules (define).
     * If we find a module without id or with the given id,
     * we proceed to the module initialization.
     */

    var found, args, module;

    while (!found && defQueue.length) { (2)
        args = defQueue.shift();
        if (args[0] === null) {
            args[0] = id;
            found = true;
        } else if (args[0] === id) {
            // Found matching define call for this script!
            found = true;
        }

        if (found) {
            module = registry[args[0]]; (3)
            module.init(args[1], args[2]);
        }
    }
};