/*
 * @static
 * JavaScript Site API
 */

window.SP = ((typeof window.SP !== "undefined") ? window.SP : {});

// Als eigene Funktion ausgelagert um den scope sauber zu halten
(function () {
	var initializing = false,
	fnTest;

	if (/xyz/.test(function() {})) {
		fnTest = /\b_super\b/;
	} else {
		fnTest = /.*/;
	}

	// The base Class implementation (does nothing)
	SP.BaseClass = function() {};

	// Create a new Class that inherits from this class
	SP.BaseClass.extend = function(prop, clsName) {

		var _super = this.prototype;
		var Me = this;

		initializing = true;
		var prototype = new Me();
		initializing = false;

		var f = function(name, fn) {
			return function() {
				var tmp = this._super;

				// Add a new ._super() method that is the same method
				// but on the super-class
				this._super = _super[name];

				// The method only need to be bound temporarily, so we
				// remove it when we're done executing
				var ret = fn.apply(this, arguments);
				this._super = tmp;

				return ret;
			};
		};

		for (var name in prop) {
			if (typeof prop[name] === "function" && typeof _super[name] === "function" && fnTest.test(prop[name])) {
				prototype[name] = f.apply(this, [name, prop[name]]);
			} else {
				prototype[name] = prop[name];
			}
		}

		function Class() {
			var me = this;
			if (!initializing && me.init) {
				me.init.apply(me, arguments);
			}
		}

		Class.displayName = clsName;
		Class.prototype = prototype;
		Class.prototype.self = Class;
		Class.superClass = Me;
		Class.prototype.constructor = Class;
		Class.extend = SP.BaseClass.extend;

		return Class;
	};
})();


(function () {

	/**
	 * Namespace erzeugen. SP.ns('SP.package.subpackage');
	 * @memberOf SP
	 * @param {String} ns Namespace
	 * @param {Object} val Value
	 * @return {Object} Namespace
	 */
	SP.ns = function(ns, val) {
		var spaces = ns.split("."),
			cur = window,
			l = spaces.length,
			i;
		for (i = 0; i < l; i++) {
			if ((i + 1) === l && typeof val !== "undefined") {
				cur[spaces[i]] = val;
			} else if (typeof cur[spaces[i]] === "undefined") {
				cur[spaces[i]] = {};
			}
			cur = cur[spaces[i]];
		}
		return cur;
	};

	SP.emptyFn = function() {};

	/**
	 * Erzeugt eine ID
	 * @param {String} Prefix für die ID
	 * @return {String} generierte id
	 */
	SP.generateId = function(prefix) {
		if (!SP._idPool) {
			SP._idPool = {};
		}
		if (!SP._idPool[prefix]) {
			SP._idPool[prefix] = 1;
		} else {
			SP._idPool[prefix] = SP._idPool[prefix] + 1;
		}
		return prefix + "-" + SP._idPool[prefix];
	};

	/**
	 * Returns the Type of the given Object like '[object Object]'
	 * @param Object
	 * @return srting the Type-String like '[object Object]'
	 */
	SP.toString = function (param) {
		return Object.prototype.toString.call(param);
	};

	/**
	 * Returns true if the passed value is empty, false otherwise. The
	 * value is deemed to be empty if it is either:
	 *  - `null` - `undefined` - a zero-length array - a zero-length
	 * string (Unless the `allowEmptyString` parameter is set to `true`)
	 *
	 * @param {Object} value The value to test
	 * @param {Boolean} allowEmptyString (optional) true to allow empty
	 * strings (defaults to false)
	 * @return {Boolean}
	 * @markdown
	 */
	SP.isEmpty = function(value, allowEmptyString) {
			return (value === null) ||
				(value === undefined) ||
				(!allowEmptyString ? value === "" : false) ||
				(SP.isArray(value) && value.length === 0);
	};

	/**
	 * Returns true if the passed value is a JavaScript Array, false
	 * otherwise.
	 * @param {Object} target The target to test
	 * @return {Boolean}
	 */
	SP.isArray = (("isArray" in Array) ? Array.isArray : function(value) {
		return SP.toString(value) === "[object Array]";
	});

	/**
	 * Returns true if the passed value is a JavaScript Date object, false
	 * otherwise.
	 *
	 * @param {Object} object The object to test
	 * @return {Boolean}
	 */
	SP.isDate = function(value) {
		return SP.toString(value) === "[object Date]";
	};

	/**
	 * Returns true if the passed value is a JavaScript Object, false
	 * otherwise.
	 * @param {Object} value The value to test
	 * @return {Boolean}
	 *
	 */
	SP.isObject = (SP.toString(null) === "[object Object]") ? function(value) {
		// ERROR im MSIE: SP.isObject = (SP.toString(null) === '[object Object]') ?
		// check ownerDocument here as well to exclude DOM nodes
		return value !== null && value !== undefined && SP.toString(value) === "[object Object]" && value.ownerDocument === undefined;
	} : function(value) {
		return SP.toString(value) === "[object Object]";
	};

	/**
	 * @private
	 */
	SP.isSimpleObject = function(value) {
		return value instanceof Object && value.constructor === Object;
	};

	/**
	 * Returns true if the passed value is a JavaScript 'primitive', a
	 * string, number or boolean.
	 *
	 * @param {Object} value The value to test
	 * @return {Boolean}
	 */
	SP.isPrimitive =  function(value) {
		var type = typeof value;
		return type === "string" || type === "number" || type === "boolean";
	};

	/**
	 * Returns true if the passed value is a JavaScript Function, false
	 * otherwise.
	 *
	 * @param {Object} value The value to test
	 * @return {Boolean}
	 * @method
	 */
	SP.isFunction =  function(value) {
		return "function" === typeof value;
	};

	/**
	 * Returns true if the passed value is a number. Returns false for
	 * non-finite numbers.
	 *
	 * @param {Object} value The value to test
	 * @return {Boolean}
	 */
	SP.isNumber = function(value) {
		return typeof value === "number" && isFinite(value);
	};

	/**
	 * Validates that a value is numeric.
	 *
	 * @param {Object} value Examples: 1, '1', '2.34'
	 * @return {Boolean} True if numeric, false otherwise
	 */
	SP.isNumeric = function(value) {
		return !isNaN(parseFloat(value)) && isFinite(value);
	};

	/**
	 * Validates that a value is integer
	 * @param {Object} value
	 * @returns {Boolean}
	 */
	SP.isInt = function(value){
		return Number(value) === value && value % 1 === 0;
	};

	/**
	 * Validates that a value is float
	 * @param {Object} value
	 * @returns {Boolean}
	 */
	SP.isFloat = function(value){
		return Number(value) === value && value % 1 !== 0;
	};

	/**
	 * Returns true if the passed value is a string.
	 *
	 * @param {Object} value The value to test
	 * @return {Boolean}
	 */
	SP.isString = function(value) {
		return typeof value === "string";
	};

	/**
	 * Returns true if the passed value is a boolean.
	 *
	 * @param {Object} value The value to test
	 * @return {Boolean}
	 */
	SP.isBoolean = function(value) {
		return typeof value === "boolean";
	};

	/**
	 * Returns true if the passed value is defined.
	 * @param {Object} value The value to test
	 * @return {Boolean}
	 */
	SP.isDefined = function(value) {
		return typeof value !== "undefined";
	};

	/**
	 * Prüft ob das übergebene Objekt ein Dom-Element ist
	 * @param {Object} value The value to test
	 * @returns {Boolean}
	 */
	SP.isElement = function (value) {
		var isElement = false;
		if (typeof HTMLElement === "object") {
			isElement = value instanceof HTMLElement;
		} else {
			isElement = (value &&
					typeof value === "object" &&
					value !== null &&
					value.nodeType === 1 &&
					typeof value.nodeName==="string");
		}
		return isElement;
	};

	/**
	 * Returns true if the passed value is a NodeList
	 * @param value
	 * @returns {Boolean}
	 */
	SP.isNodeList = function (value) {
		var stringRepr = SP.toString(value);

		return typeof value === "object" &&
				/^\[object (HTMLCollection|NodeList|Object)\]$/.test(stringRepr) &&
				SP.isInt(value.length) &&
				(value.length === 0 || (typeof value[0] === "object" && value[0].nodeType > 0));
	};

	// for MSIE
	if (typeof console === "undefined") {
		console = {}; // jshint ignore:line
	}

	console.log = console.log ? console.log : SP.emptyFn;
	console.debug = console.debug ? console.debug : SP.emptyFn;
	console.info = console.info ? console.info : SP.emptyFn;
	console.warn = console.warn ? console.warn : SP.emptyFn;
	console.error = console.error ? console.error  : SP.emptyFn;
	console.groupCollapsed = console.groupCollapsed ? console.groupCollapsed  : SP.emptyFn;
	console.groupEnd = console.groupEnd ? console.groupEnd  : SP.emptyFn;
})();





/**
 * Sammlung von statischen Funktionen für den Umgang mit Emails
 * @static
 * @class SP.util.Email
 */
SP.ns("SP.util.Email", (function() {

	return {

		/**
		 * Encodiert, den für den Spam-Schutz decodierten Email-String für ein HTML-Attribut
		 *
		 * @param {HTMLElement} el HTMLElement, dessen Attribut decodiert werden soll
		 * @param {String} name Name des Attributes
		 */
		decryptAttribute : function(el, name) {
			var email = el.getAttribute(name);
			email = email.replace(/%E2%9A%B9/g, "@");
			email = email.replace(/%E2%97%A6/g, ".");
			el.setAttribute(name, email);
		}

	};
}()));