/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

//----------------------------------------------------------------------------
// an implementation of the require() function as specified for use with
// CommonJS Modules - see http://commonjs.org/specs/modules/1.0.html
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// inspired from David Flanagan's require() function documented here:
// http://www.davidflanagan.com/2009/11/a-module-loader.html
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// only supports "preloaded" modules ala define() (AMD)
//    http://wiki.commonjs.org/wiki/Modules/AsynchronousDefinition
// but the id parameter is required
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// function wrapper
//----------------------------------------------------------------------------
(function(){

//----------------------------------------------------------------------------
// some constants
//----------------------------------------------------------------------------
var PROGRAM = "modjewel"
var VERSION = "2.0.0"
var global  = this

//----------------------------------------------------------------------------
// if require() is already defined, leave
//----------------------------------------------------------------------------
if (global.modjewel) {
    log("modjewel global variable already defined")
    return
}

global.modjewel = null

//----------------------------------------------------------------------------
// "globals" (local to this function scope though)
//----------------------------------------------------------------------------
var ModuleStore
var ModulePreloadStore
var MainModule
var WarnOnRecursiveRequire = false

//----------------------------------------------------------------------------
// the require function
//----------------------------------------------------------------------------
function get_require(currentModule) {
    var result = function require(moduleId) {

        if (moduleId.match(/^\.{1,2}\//)) {
            moduleId = normalize(currentModule, moduleId)
        }

        if (hop(ModuleStore, moduleId)) {
            var module = ModuleStore[moduleId]
            if (module.__isLoading) {
                if (WarnOnRecursiveRequire) {
                    var fromModule = currentModule ? currentModule.id : "<root>"
                    console.log("module '" + moduleId + "' recursively require()d from '" + fromModule + "', problem?")
                }
            }

            currentModule.moduleIdsRequired.push(moduleId)

            return module.exports
        }

        if (!hop(ModulePreloadStore, moduleId)) {
            var fromModule = currentModule ? currentModule.id : "<root>"
            error("module '" + moduleId + "' not found from '" + fromModule + "', must be define()'d first")
        }

        var factory = ModulePreloadStore[moduleId][0]
        var prereqs = ModulePreloadStore[moduleId][1]

        var module = create_module(moduleId)

        var newRequire = get_require(module)

        ModuleStore[moduleId] = module

        module.__isLoading = true
        try {
            currentModule.moduleIdsRequired.push(moduleId)

            var prereqModules = []
            for (var i=0; i<prereqs.length; i++) {
                var prereqId = prereqs[i]
                var prereqModule

                if      (prereqId == "require") prereqModule = newRequire
                else if (prereqId == "exports") prereqModule = module.exports
                else if (prereqId == "module")  prereqModule = module
                else                            prereqModule = newRequire(prereqId)

                prereqModules.push(prereqModule)
            }

            if (typeof factory == "function") {
                var result = factory.apply(null, prereqModules)
                if (result) {
                    module.exports = result
                }
            }
            else {
                module.exports = factory
            }
        }
        finally {
            module.__isLoading = false
        }

        return module.exports
    }

    result.define         = require_define
    result.implementation = PROGRAM
    result.version        = VERSION

    return result
}

//----------------------------------------------------------------------------
// shorter version of hasOwnProperty
//----------------------------------------------------------------------------
function hop(object, name) {
    return Object.prototype.hasOwnProperty.call(object, name)
}

//----------------------------------------------------------------------------
// create a new module
//----------------------------------------------------------------------------
function create_module(id) {
    return {
        id:                id,
        uri:               id,
        exports:           {},
        prereqIds:         [],
        moduleIdsRequired: []
    }
}

//----------------------------------------------------------------------------
// reset the stores
//----------------------------------------------------------------------------
function require_reset() {
    ModuleStore        = {}
    ModulePreloadStore = {}
    MainModule         = create_module(null)

    var require = get_require(MainModule)
    var define  = require_define
    
    define("modjewel", modjewel_module)

    global.modjewel            = require("modjewel")
    global.modjewel.require    = require
    global.modjewel.define     = define
    global.modjewel.define.amd = {implementation: PROGRAM, version: VERSION}
}

//----------------------------------------------------------------------------
// used by pre-built modules that can be included via <script src=>
// a simplification of
//    http://wiki.commonjs.org/wiki/Modules/AsynchronousDefinition
// where id is required
//----------------------------------------------------------------------------
function require_define(moduleId, prereqs, factory) {
    var rem = ["require", "exports", "module"]

    if (typeof moduleId != "string") {
        console.log("modjewel.define(): first parameter must be a string; was: " + moduleId)
        return
    }

    if (arguments.length == 2) {
        factory = prereqs
        prereqs = null
    }

    if (!prereqs || prereqs.length == 0) {
        prereqs = rem
    }

    if (typeof factory != "function") {
        if (factory) {
            ModulePreloadStore[moduleId] = [factory, prereqs]
            return
        }

        console.log("modjewel.define(): factory was falsy: " + factory)
        return
    }

    if (moduleId.match(/^\./)) {
        console.log("modjewel.define(): moduleId must not start with '.': '" + moduleName + "'")
        return
    }

    if (hop(ModulePreloadStore, moduleId)) {
        console.log("modjewel.define(): module '" + moduleId + "' has already been defined")
        return
    }

    ModulePreloadStore[moduleId] = [factory, prereqs]
}

//----------------------------------------------------------------------------
// get the path of a module
//----------------------------------------------------------------------------
function getModulePath(module) {
    if (!module || !module.id) return ""

    var parts = module.id.split("/")

    return parts.slice(0, parts.length-1).join("/")
}

//----------------------------------------------------------------------------
// normalize a 'file name' with . and .. with a 'directory name'
//----------------------------------------------------------------------------
function normalize(module, file) {
    var modulePath = getModulePath(module)
    var dirParts   = ("" == modulePath) ? [] : modulePath.split("/")
    var fileParts  = file.split("/")

    for (var i=0; i<fileParts.length; i++) {
        var filePart = fileParts[i]

        if (filePart == ".") {
        }

        else if (filePart == "..") {
            if (dirParts.length > 0) {
                dirParts.pop()
            }
            else {
                // error("error normalizing '" + module + "' and '" + file + "'")
                // eat non-valid .. paths
            }
        }

        else {
            dirParts.push(filePart)
        }
    }

    return dirParts.join("/")
}

//----------------------------------------------------------------------------
// throw an error
//----------------------------------------------------------------------------
function error(message) {
    throw new Error(PROGRAM + ": " + message)
}

//----------------------------------------------------------------------------
// get a list of loaded modules
//----------------------------------------------------------------------------
function modjewel_getLoadedModuleIds() {
    var result = []

    for (moduleId in ModuleStore) {
        result.push(moduleId)
    }

    return result
}

//----------------------------------------------------------------------------
// get a list of the preloaded module ids
//----------------------------------------------------------------------------
function modjewel_getPreloadedModuleIds() {
    var result = []

    for (moduleId in ModulePreloadStore) {
        result.push(moduleId)
    }

    return result
}

//----------------------------------------------------------------------------
// get a module by module id
//----------------------------------------------------------------------------
function modjewel_getModule(moduleId) {
    if (null == moduleId) return MainModule

    return ModuleStore[moduleId]
}

//----------------------------------------------------------------------------
// get a list of module ids which have been required by the specified module id
//----------------------------------------------------------------------------
function modjewel_getModuleIdsRequired(moduleId) {
    var module = modjewel_getModule(moduleId)
    if (null == module) return null

    return module.moduleIdsRequired.slice()
}

//----------------------------------------------------------------------------
// set the WarnOnRecursiveRequireFlag
// - if you make use of "module.exports =" in your code, you will want this on
//----------------------------------------------------------------------------
function modjewel_warnOnRecursiveRequire(value) {
    if (arguments.length == 0) return WarnOnRecursiveRequire
    WarnOnRecursiveRequire = !!value
}

//----------------------------------------------------------------------------
// the modjewel module
//----------------------------------------------------------------------------
function modjewel_module(require, exports, module) {
    exports.VERSION                = VERSION
    exports.require                = null // filled in later
    exports.define                 = null // filled in later
    exports.getLoadedModuleIds     = modjewel_getLoadedModuleIds
    exports.getPreloadedModuleIds  = modjewel_getPreloadedModuleIds
    exports.getModule              = modjewel_getModule
    exports.getModuleIdsRequired   = modjewel_getModuleIdsRequired
    exports.warnOnRecursiveRequire = modjewel_warnOnRecursiveRequire
}

//----------------------------------------------------------------------------
// log a message
//----------------------------------------------------------------------------
function log(message) {
    console.log("modjewel: " + message)
}

//----------------------------------------------------------------------------
// make the require function a global
//----------------------------------------------------------------------------
require_reset()

//----------------------------------------------------------------------------
})();