/*	
################################################################
	The Verifier Object includes a lot of verifier functions
	that help us writing client-side scripts without warry
	about debug.errors in the future.
################################################################
*/

var verifier = {
	/**
	* Verifies that object specified isn't null or undefined.
	*
	* @param object object to check
	* @param message debug.error message to display in case of verification failure
	* @throws debug.error if object specified is null or undefined
	*/
	verifyNotNullOrUndefined : function(object, message) {
		if (arguments.length != 2) {
			debug.error("verifyNotNullOrUndefined(): there should be two arguments",
				"received [" + arguments.length + "] instead");
		}

		else if (isNullOrUndefined(object)) {
			debug.error("verifyNotNullOrUndefined(): object is null or undefined",
					"The message is [" + message + "]");
		}
	},
	
	
	/**
	* Verifies that object specified is of the type specified.
	*
	* @param object  object to check
	* @param type    "typeof" expected value
	* @param message debug.error message to display in case of verification failure
	* @throws debug.error  if object specified is null or indefined or it's "typeof"
	*                returns value different from "type"
	*/
	verifyType : function(object, type, message) {

		if (arguments.length != 3) {
		debug.error("verifyType(): there should be three arguments",
				"received [" + arguments.length + "] instead");
		}

		this.verifyNotNullOrUndefined(object, message);

		if (! (typeof object == type)) {
			debug.error("verifyType(): type of [" + object + "] is " +
				"[" + (typeof object) + "] instead of [" + type + "]",
				"The message is [" + message + "]");
		}
	},


	/**
	* Verifies that condition specified is *true*.
	*
	* @param condition boolean condition to check
	* @param message   debug.error message to display in case of verification failure
	* @throws debug.error    if condition specified is false
	*/
	verifyTrue : function(condition, message) {

		verifyType(condition, "boolean", "verifyTrue(): condition");
		verifyType(message,   "string",  "verifyTrue(): message");

		if (! condition) {
			debug.error("The condition specified is *false* !",
				"The message is [" + message + "]");
		}
	},


	/**
	* Verifies that condition specified is *false*.
	*
	* @param condition boolean condition to check
	* @param message   debug.error message to display in case of verification failure
	* @throws debug.error    if condition specified is true
	*/
	verifyFalse : function(condition, message) {

		verifyType(condition, "boolean", "verifyFalse(): condition");
		verifyType(message,   "string",  "verifyFalse(): message");

		if (condition) {
			debug.error("The condition specified is *true* !",
				"The message is [" + message + "]");
		}
	},


	/**
	* Verifies that string specified is identical to the value specified
	* (case-insensitive).
	*
	* @param string  string to check
	* @param value   value to compare with
	* @param message debug.error message to display in case of verification failure
	* @throws debug.error  if string specified differs from the value specified (case-insensitive)
	*/
	verifyString : function(string, value, message) {

		verifyType(string,  "string", "verifyString(): string");
		verifyType(value,   "string", "verifyString(): value");
		verifyType(message, "string", "verifyString(): message");

		if (string.toLowerCase() != value.toLowerCase()) {
			debug.error("verifyString(): [" + string + "] != [" + value + "] (case-insensitive)",
				"The message is [" + message + "]");
		}
	},


	/**
	* Verifies that node specified has a required name.
	*
	* @param node     Node to check
	* @param nodeName name that Node should have
	* @param message debug.error message to display in case of verification failure
	* @throws debug.error  if node.nodeName differs from nodeName (case-insensitive)
	*/
	verifyNodeName : function(node, nodeName, message) {

		verifyType(node,     "object", "verifyNodeName(): node:     [" + message + "]");
		verifyType(nodeName, "string", "verifyNodeName(): nodeName: [" + message + "]");
		verifyType(message,  "string", "verifyNodeName(): message:  [" + message + "]");

		if (node.nodeName.toLowerCase() != nodeName.toLowerCase()) {
			debug.error("Node.nodeName = [" + node.nodeName + "] instead of " +
				"[" + nodeName + "] (case-insensitive)",
				"The message is [" + message + "]");
		}
	},


	/**
	* Verifies type of the <input node specified.
	*
	* @param  inputNode Node (with "input" nodeName) to check
	* @param  nodeType  node type to check against
	* @param  message debug.error message to display in case of verification failure
	* @throws debug.error if node specified has node.nodeName different from "input" or
	*               node.type differs from nodeType (case-insensitive)
	*/
	verifyInputType : function(inputNode, nodeType, message) {

		verifyType(inputNode, "object", "verifyInputType(): inputNode: [" + message + "]");
		verifyType(nodeType,  "string", "verifyInputType(): nodeType:  [" + message + "]");
		verifyType(message,   "string", "verifyInputType(): message:   [" + message + "]");

		verifyNodeName(inputNode, "input", message);

		if (inputNode.type.toLowerCase() != nodeType.toLowerCase()) {
			debug.error("Node.type = [" + inputNode.type + "] " +
				"instead of [" + nodeType + "] (case-insensitive)",
				"The message is [" + message + "]");
		}
	}
}