/* Copyright 2009 the Melange authors.

 *

 * Licensed 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.

 */

/**

 * @author <a href="mailto:fadinlight@gmail.com">Mario Ferraro</a>

 */

(function () {

  /** @lends melange */

  /** General melange package.

    * @name melange

    * @namespace melange

    */

  var melange = window.melange = function () {

    return new melange();

  };

  if (window.jQuery === undefined) {

    throw new Error("jQuery package must be loaded exposing jQuery namespace");

  }

  if (window.JSON === undefined) {

    throw new Error("json2 package must be loaded exposing JSON namespace");

  }

  /** Shortcut to current package.

    * @private

    */

  var $m = melange;

  /** Contains general configuration for melange package.

    * @variable

    * @public

    * @name melange.config

    */

  $m.config = {};

  (function () {

    var configuration =

      jQuery("script[melangeConfig][src$='melange.js']").attr("melangeConfig");

    if (configuration) {

      var configuration_object = JSON.parse("{ " + configuration + " }");

      jQuery.extend($m.config, configuration_object);

    }

  }());

  /** Shortcut to clone objects using jQuery.

    * @function

    * @public

    * @name melange.clone

    * @param {Object} object the object to clone

    * @returns {Object} a new, cloned object

    */

  $m.clone = function (object) {

    // clone object, see

    // http://stackoverflow.com/questions/122102/

    // what-is-the-most-efficent-way-to-clone-a-javascript-object

    return jQuery.extend(true, {}, object);

  };

  /** Set melange general options.

    * @function

    * @public

    * @name melange.setOptions

    * @param {Object} options Options to set/unset

    */

  $m.setOptions = function (options) {

    switch (options.debug) {

    case true:

      $m.logging.setDebug();

      break;

    case false:

      $m.logging.unsetDebug();

      break;

    default:

      $m.logging.setDebug();

    }

    if (options.debugLevel) {

      $m.logging.setDebugLevel(options.debugLevel);

    }

  };

  /** Facility to load google API.

    * @function

    * @public

    * @name melange.loadGoogleApi

    * @param {String} modulename Google Ajax module to load

    * @param {String|Number} moduleversion Google Ajax module version to load

    * @param {Object} settings Google Ajax settings for the module

    * @param {Function} callback to be called as soon as module is loaded

    */

  $m.loadGoogleApi = function (modulename, moduleversion, settings, callback) {

    if (!modulename || !moduleversion) {

      throw new TypeError("modulename must be defined");

    }

    /** Options to be sent to google.load constructor

      * @private

      * @name melange.loadGoogleApi.options

      */

    var options = {

      name : modulename,

      version : moduleversion,

      settings : settings

    };

    jQuery.extend(options.settings, {callback: callback});

    google.load(options.name, options.version, options.settings);

  };

  (function () {

    /** @lends melange.error */

    /** Package that handles melange errors

      * @namespace melange.error

      */

    melange.error = window.melange.error = function () {

      return new melange.error();

    };

    /** Shortcut to current package.

      * @property

      * @private

      */

    var $m = melange.error;

    /** List of default custom error types to be created.

      * @property

      * @private

      */

    var error_types = [

      "DependencyNotSatisfied",

      "notImplementedByChildClass"

    ];

    /** Create errors

      * @function

      * @public

      * @name melange.error.createErrors

      * @param {String[]} error_types Array of strings with errors names

      */

    $m.createErrors = function (error_types) {

      jQuery.each(error_types, function () {

        melange.error[this] = Error;

      });

    };

    $m.createErrors(error_types);

  }());

  (function () {

    /** @lends melange.logging */

    /** Package that contains all log related functions.

      * @name melange.logging

      * @namespace melange.logging

      */

    melange.logging = window.melange.logging = function () {

      return new melange.logging();

    };

    /** Shortcut to current package.

      * @property

      * @private

      */

    var $m = melange.logging;

    /** @private */

    var debug = false;

    /** @private */

    var current_debug_level = 5;

    /** Set debug logging on.

      * @function

      * @public

      * @name melange.logging.setDebug

      */

    $m.setDebug = function () {

      debug = true;

    };

    /** Set debug logging off.

      * @function

      * @public

      * @name melange.logging.unsetDebug

      */

    $m.unsetDebug = function () {

      debug = false;

    };

    /** Check if debug is active.

      * @function

      * @public

      * @name melange.logging.isDebug

      * @returns {boolean} true if debug is on, false otherwise

      */

    $m.isDebug = function () {

      return debug ? true : false;

    };

    /** Set the current debug level.

      * @function

      * @public

      * @name melange.logging.setDebugLevel

      * @param level The log level to set

      * @throws {TypeError} if the parameter given is not a number

      */

    $m.setDebugLevel = function (level) {

      if (isNaN(level)) {

        throw new melange.error.TypeError(

          "melange.logging.setDebugLevel: parameter must be a number"

        );

      }

      if (level <= 0) {

        level = 1;

      }

      if (level >= 6) {

        level = 5;

      }

      current_debug_level = level;

    };

    /** Get the current debug level.

      * @function

      * @public

      * @name melange.logging.getDebugLevel

      * @returns {Number} The current debug level

      */

    $m.getDebugLevel = function () {

      return current_debug_level;

    };

    /** A decorator for logging.

      * @function

      * @public

      * @name melange.logging.debugDecorator

      * @param {Object} object_to_decorate The Function/Object to decorate

      * @returns {Object} Same object,decorated with log(level,message) func

    */

    $m.debugDecorator = function (object_to_decorate) {

      /** Function to handle output of logs.

        * @function

        * @name melange.logging.debugDecorator.log

        * @param level The log level

        * @param message The string

        */

      object_to_decorate.log = function (level, message) {

          if (melange.logging.isDebug() && current_debug_level >= level) {

            console.debug(message);

          }

        };

      return object_to_decorate;

    };

  }());

  (function () {

    /** @lends melange.templates */

    /** Package that provides basic templates functions

      * @name melange.templates

      * @namespace melange.templates

      */

    melange.templates = window.melange.templates = function () {

      return new melange.templates();

    };

    /** Shortcut to current package

      * @private

      */

    var $m = melange.logging.debugDecorator(melange.templates);

    melange.error.createErrors([

    ]);

    /** Parent prototype for all templates

      * @class

      * @constructor

      * @name melange.templates._baseTemplate

      * @public

      */

    $m._baseTemplate = function () {

      this.context = {};

      var configuration = jQuery("script[melangeContext]")[0];

      if (configuration !== undefined) {

        configuration = jQuery(configuration).attr("melangeContext");

        if (configuration) {

          /* FIXME: json2 doesn't parse the object if they have k:"v" instead

             of "k":"v", but this is not what gviz outputs, we need to change

             gviz source or hack json2 source or use another method. eval()

             must be not used anyway

          */

          /*jslint evil: true,undef: false */

          eval("var configuration_object = " + configuration);

          jQuery.extend(this.context, configuration_object);

          /*jslint evil: false,undef: true */

        }

      }

    };

  }());

}());

window.melange = window.melange.logging.debugDecorator(window.melange);