/**
 * Common JavaScript functions
 *
 */
var LB = "\n";
var TAB = "\t";
var EDC = '<!-- -->';

var POS_TOP_LEFT = 1;
var POS_TOP = 2;
var POS_TOP_RIGHT = 3;
var POS_LEFT = 4;
var POS_CENTER = 5;
var POS_RIGHT = 6;
var POS_BOTTOM_LEFT = 7;
var POS_BOTTOM = 8;
var POS_BOTTOM_RIGHT = 9;

var MSG_TYPE_OK = 1;
var MSG_TYPE_ERROR = 2;

var LOCALE = 'hu_HU';

/**
 * PHP.JS global object
 * 
 */
//var _P = new PHP_JS;

/**
 * Document ready function
 * 
 */
$(document).ready(function() {
	runOnLoadListeners();
});

/**
 * onLoad listener arrays
 *
 */
window.onLoadListeners = [];
window.onLoadListenerArgs = [];

/**
 * Application onLoad listener arrays
 * 
 */
window.onAppLoadListeners = [];
window.onAppLoadListenersArgs = [];

/**
 * Add onLoad listener
 *
 * @param listener function
 * @param args object
 * @return void
 */
window.addOnLoadListener = function (listener, args) {
	var listenerLength = window.onLoadListeners.length;
	
	if (isFunction(listener)) {
		window.onLoadListeners[listenerLength] = listener;

		if (isDefined(args)) {
			window.onLoadListenerArgs[listenerLength] = args;
		} else {
			window.onLoadListenerArgs[listenerLength] = null;
		}
	}
}

/**
 * Add application onLoad listener
 *
 * @param listener function
 * @param args object
 * @return void
 */
window.addOnAppLoadListener = function (listener, args) {
	var listenerLength = window.onAppLoadListeners.length;

	if (isFunction(listener) || isString(listener)) {
		window.onAppLoadListeners[listenerLength] = listener;

		if (isDefined(args)) {
			window.onAppLoadListenersArgs[listenerLength] = args;
		} else {
			window.onAppLoadListenersArgs[listenerLength] = null;
		}
	}
}

/**
 * Run onLoad listeners
 * 
 * @return void
 */
function runOnLoadListeners() {
	for (var i=0; i<window.onLoadListeners.length; i++) {
		var listener = window.onLoadListeners[i];
		var args = window.onLoadListenerArgs[i];

		if (isFunction(listener)) {
			listener.call(this, args);
		}
	}
}

/**
 * Run application onLoad listeners
 * 
 * @return void
 */
function runOnAppLoadListeners() {
	for (var i=0; i<window.onAppLoadListeners.length; i++) {
		var listener = window.onAppLoadListeners[i];
		var args = window.onAppLoadListenersArgs[i];

		if (isFunction(listener)) {
			listener.call(this, args);
		}
                if (isString(listener)) {
			call('app.'+listener, args);
		}
	}
}

/**
 * Translate
 *
 * @param str string
 * @return string
 */
function __(str) {
	if (isObject(app) && app.checkModule('dictionary')) {
		return app.dictionary.translate(str);
	}
	return str;
}

/**
 * Call object function
 *
 * @param fn string
 * @param args array
 * @return void
 */
function call(fn, args) {
	var fnStr = fn;
	
	try {
		if (isString(fn) && fn.length) {
			var fnObj = fn.split('.');
			
			if (isArray(fnObj) && fnObj.length > 1) {
				if (arguments.length > 2) {
					args = Array.prototype.slice.call(arguments);
					args.shift();
				}
		
				fn = eval(fn);
				
				fnObj.pop();
				var context = eval(fnObj.join('.'));
				
				if (isFunction(fn) && isObject(context)) {
					fn.call(context, args);
				} else {
					throw 'Invalid or missing function: '+fnStr;
				}
			} else {
				throw 'Invalid function string: '+fnStr;
			}
		} else {
			throw 'Missing or invalid function string: '+fnStr;
		}
	} catch (e) {
		if (isObject(app) && app.checkModule('debug')) {
			app.debug.error(e);
		}
	}
}

/**
 * Get function name
 *
 * @params fn string
 * @params context object
 * @return string
 */
function getFunctionName(fn, context) {
	if (isFunction(fn) && isObject(context)) {
		for (var prop in context) {
			if (context[prop] == fn) {
				return prop;
			}
		}
	}
	return null;
}

/**
 * Check null
 *
 * @param input mixed
 * @return boolean
 */
function isNull(input) {
	return (input == null);
}

/**
 * Check object
 *
 * @param input mixed
 * @return boolean
 */
function isObject(input) {
	return (typeof(input) == 'object' && !isNull(input));
}

/**
 * Check array
 *
 * @param input mixed
 * @return boolean
 */
function isArray(input) {
	return (isObject(input) && (input instanceof Array));
}

/**
 * Check string
 *
 * @param input mixed
 * @return boolean
 */
function isString(input) {
	return (typeof(input) == 'string' && !isNull(input));
}

/**
 * Check undefined
 *
 * @param input mixed
 * @return boolean
 */
function isUndefined(input) {
	return (typeof(input) == 'undefined');
}

/**
 * Check defined
 *
 * @param input mixed
 * @return boolean
 */
function isDefined(input) {
	return (typeof(input) != 'undefined');
}

/**
 * Check function
 *
 * @param input mixed
 * @return boolean
 */
function isFunction(input) {
	return $.isFunction(input);
}

/**
 * Check number
 * 
 * @param input mixed
 * @return boolean
 */
function isNumber(input) {
	return (typeof(input) == 'number');
}

/**
 * Check value in array
 *
 * @param value mixed
 * @param array array
 * @return boolean
 */
function inArray(value, array) {
	if ($.inArray(value, array) > -1) {
		return true;
	}
	return false;
}

/**
 * Check form
 *
 * @param input mixed
 * @return boolean
 */
function isForm(input) {
	return (isObject(input) && isDefined(input.nodeName) && input.nodeName.toLowerCase() == 'form');
}

/**
 * Merge objects
 *
 * @param src object
 * @param ext object
 * @return object
 */
function mergeObjects(src, ext) {
	if (isObject(src) && isObject(ext)) {
		for (prop in ext) {
			if (isObject(ext[prop]) && isObject(src[prop])) {
				mergeObjects(src[prop], ext[prop]);
			} else {
				src[prop] = ext[prop];
			}
		}
	}
	return src;
}

/**
 * Get viewport dimensions
 *
 * @return object
 */
function getViewportDimensions() {
	var dDim = getObjectDimensions(document);
	var wDim = getObjectDimensions(window);
	var width, height = 0;
	
	if (isObject(app) && app.checkModule('browser') && app.browser.isIE) {
		width = ((wDim.width < dDim.width) ? wDim.width : dDim.width);
		height = ((dDim.height - wDim.height) < 20) ? wDim.height : dDim.height;

		if (wDim.scrollLeft) {
			width += wDim.scrollLeft;
		}
	} else {
		width = dDim.width;
		height = dDim.height;
	}
	return {width: width, height: height};
}

/**
 * Get object dimension properties
 *
 * @param obj object
 * @return object
 */
function getObjectDimensions(obj) {
	var width, height, offset, scrollLeft, scrollTop = null;

	if (isObject(obj)) {
		width = $(obj).width();
		height = $(obj).height();
		offset = $(obj).offset();
		scrollLeft = $(obj).scrollLeft();
		scrollTop = $(obj).scrollTop();
	}

	var dim = {
		width: (isNull(width) ? 0 : width),
		height: (isNull(height) ? 0 : height),
		left: ((isObject(offset) && offset.hasOwnProperty('left')) ? offset.left : 0),
		top: ((isObject(offset) && offset.hasOwnProperty('top')) ? offset.top : 0),
		scrollLeft: (isNull(scrollLeft) ? 0 : scrollLeft),
		scrollTop: (isNull(scrollTop) ? 0 : scrollTop)
	};
	return dim;
}

/**
 * Set object position
 *
 * @return void
 */
function setObjectPosition(obj, position) {
	if (isObject(obj)) {
		var dim = getObjectDimensions(obj);
		var wDim = getObjectDimensions(window);
		var left, top = 0;

		if (isObject(position)) {
			if (isArray(position)) {
				left = position[0];
				top = position[1];
			} else {
				if (position.hasOwnProperty('left')) {
					left = position.left;
				}
				if (position.hasOwnProperty('top')) {
					top = position.top;
				}
			}
		}
		
		if (isNumber(position)) {
			/**
			 * IE width fix by Huszy
			 * 
			 */
			if (isObject(app) && app.checkModule('browser') && app.browser.isIE) {
				var max = 0;
				
				$(obj).children("div").each(function(o, i) {
					if ($(i).width() > max) {
						max = $(i).width();
					}
				});
				dim.width = max;
				$(obj).css({width: max+'px'});
			}
			
			switch(position) {
				case POS_TOP_LEFT:
					left = wDim.scrollLeft;
					top = wDim.scrollTop;
					break;
				case POS_TOP:
					left = Math.ceil((wDim.width - dim.width) / 2) + wDim.scrollLeft;
					top = wDim.scrollTop;
					break;
				case POS_TOP_RIGHT:
					left = (wDim.width + wDim.scrollLeft) - dim.width;
					top = wDim.scrollTop;
					break;
				case POS_LEFT:
					left = wDim.scrollLeft;
					top = Math.ceil((wDim.height - dim.height) / 2) + wDim.scrollTop;
					break;
				case POS_CENTER:
					left = Math.ceil((wDim.width - dim.width) / 2) + wDim.scrollLeft;
					top = Math.ceil((wDim.height - dim.height) / 2) + wDim.scrollTop;
					break;
				case POS_RIGHT:
					left = (wDim.width + wDim.scrollLeft) - dim.width;
					top = Math.ceil((wDim.height - dim.height) / 2) + wDim.scrollTop;
					break;
				case POS_BOTTOM_LEFT:
					left = wDim.scrollLeft;
					top =  (wDim.height + wDim.scrollTop) - dim.height;
					break;
				case POS_BOTTOM:
					left = Math.ceil((wDim.width - dim.width) / 2) + wDim.scrollLeft;
					top =  (wDim.height + wDim.scrollTop) - dim.height;
					break;
				case POS_BOTTOM_RIGHT:
					left = (wDim.width + wDim.scrollLeft) - dim.width;
					top =  (wDim.height + wDim.scrollTop) - dim.height;
					break;
				default:
					left = Math.ceil((wDim.width - dim.width) / 2) + wDim.scrollLeft;
					top = Math.ceil((wDim.height - dim.height) / 2) + wDim.scrollTop;
					break;
			}
		}

		obj.css({
			top: top+'px',
			left: left+'px'
		});
	}
}

/**
 * Reload page
 * 
 * @return void
 */
function reloadPage() {
	window.location.reload(true);
}

/**
 * Redirect page
 * 
 * @param url string
 * @return void
 */
function redirectPage(url) {
	if (url) {
		window.location.replace(url);
	}
}

/**
 * Jump to hash
 * 
 * @param hash string
 * @return void
 */
function jumpToHash(hash) {
	if (hash) {
		window.location.hash = hash;
	}
}

/**
 * String to boolean function
 * 
 * @return boolean
 */
String.prototype.toBoolean = function() {
    return (/^(true|yes|1)$/i).test(this);
};

/**
 * String trim function
 * 
 * @return string
 */
String.prototype.trim = function() {
	return this.replace(/^\s+|\s+$/g, '');
}

/**
 * String left trim function
 * 
 * @return string
 */
String.prototype.ltrim = function() {
	return this.replace(/^\s+/, '');
}

/**
 * String right trim function
 * 
 * @return string
 */
String.prototype.rtrim = function() {
	return this.replace(/\s+$/, '');
}

/**
 * String to integer function
 * 
 * @return string
 */
String.prototype.toInt = function(radix) {
	radix = (radix) ? radix : 10;
	return parseInt(this, radix);
}


/**
 * CurvyCorners init
 */

/*
    Usage:

    curvyCorners(settingsObj, selectorStr);
    curvyCorners(settingsObj, Obj1[, Obj2[, Obj3[, . . . [, ObjN]]]]);

    selectorStr ::= complexSelector [, complexSelector]...
    complexSelector ::= singleSelector[ singleSelector]
    singleSelector ::= idType | classType
    idType ::= #id
    classType ::= [tagName].className
    tagName ::= div|p|form|blockquote|frameset // others may work
    className : .name
    selector examples:
    #mydiv p.rounded
    #mypara
    .rounded
*/
   
function initCorners() {
    var topSet = {
        tl: { radius: 12 }, tr: { radius: 12 },
        bl: { radius: 0 }, br: { radius: 0 },
        antiAlias: true
    }
    var bottomSet = {
        tl: { radius: 0 }, tr: { radius: 0 },
        bl: { radius: 12 }, br: { radius: 12 },
        antiAlias: true
    }
    var allSet = {
        tl: { radius: 12 }, tr: { radius: 12 },
        bl: { radius: 12 }, br: { radius: 12 },
        antiAlias: true
    }

    curvyCorners(topSet, ".rounded-top");
    curvyCorners(bottomSet, ".rounded-bottom");
    curvyCorners(allSet, ".rounded-all");
}