/*
	This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
	
	Author: Sam Tsvilik
	Version: 4.0 Beta
	Last Modified: 08/29/2009
*/
(function($) {
	//Converts XML DOM to JSON				
	//Helper functions
	var util = {
		isIE: function(){ return (+"\0"===0); },
		isStr: function(o) { return typeof(o) === "string"; },
		isFn: function(o) { return typeof(o) === "function"; },
		isDef: function(o) {return (typeof(o) !== "undefined");	},
		isArr: function(o) { return o instanceof Array; },
		isInt: function(o) { return o instanceof Number && !isNaN(o); },
		isNum: function(s) {
			var out = false;					
			if(util.isStr(s)) { 
				var pattern = /^((-)?([0-9]*)((\.{0,1})([0-9]+))?$)/;
				out = pattern.test(s);
			}
			return out;
		},
		isXNode: function(o) { return (typeof(o) === "object" && this.isDef(o.nodeName)); },
		isNodeSet: function(o) { return o instanceof INodeSet; },
		//Alters attribute and collection names to comply with JS
		trim: function(str) {
			var out = str;
			if(this.isStr(str)) {
				out = str.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
			}
			return out;
		},
		formatName: function(name) {					
			var tName = this.trim(String(name));
			return tName;
		}
	};
	
	var XMLSerializer = {
		//Creates an XMLDomDocument instance
		newDocument: function(rootTagName, namespaceURL) {
		  if (!rootTagName) rootTagName = "";
		  if (!namespaceURL) namespaceURL = "";
		  if (document.implementation && document.implementation.createDocument) {
			// This is the W3C standard way to do it
			return document.implementation.createDocument(namespaceURL, rootTagName, null);
		  } else { // This is the IE way to do it
			// Create an empty document as an ActiveX object
			// If there is no root element, this is all we have to do
			var doc = new ActiveXObject("MSXML2.DOMDocument");
			// If there is a root tag, initialize the document
			if (rootTagName) {
			  // Look for a namespace prefix
			  var prefix = "";
			  var tagname = rootTagName;
			  var p = rootTagName.indexOf(':');
			  if (p !== -1) {
				prefix = rootTagName.substring(0, p);
				tagname = rootTagName.substring(p+1);
			  }
			  // If we have a namespace, we must have a namespace prefix
			  // If we don't have a namespace, we discard any prefix
			  if (namespaceURL) {
				if (!prefix) prefix = "a0"; // What Firefox uses
			  } else prefix = "";
			  // Create the root element (with optional namespace) as a
			  // string of text
			  var text = "<" + (prefix?(prefix+":"):"") +  tagname +
				  (namespaceURL
				   ?(" xmlns:" + prefix + '="' + namespaceURL +'"')
				   :"") +
				  "/>";
			  // And parse that text into the empty document
			  doc.loadXML(text);
			}
			return doc;
		  }
		},
		//Recursively converts JSON object to an XML node
		objToNode: function(curNode, obj) {
			var subElement, val, newNode;
			if(util.isDef(curNode) && util.isDef(obj)) {
				for(subElement in obj) {
					if(obj.hasOwnProperty && obj.hasOwnProperty(subElement)) {
						val = obj[subElement];
						if(subElement.indexOf("@") !== -1) {
							curNode.setAttribute(subElement.replace('@',''), val);
						} else if(subElement === "$comments") {
							if(!!val.length) {
								var c = 0, clen = val.length-1, cc;									
								do {
									cc = val[c];
									curNode.appendChild(this.createComment(cc));
								} while(c++ < clen); 
							}
						} else if(util.isNodeSet(val)) {
							var n = 0, nlen = val.length-1, nn;
							do {
								nn = val[n];
								if(!!nn.ns) {
									if(util.isDef(this.createElementNS)) {
										newNode = curNode.appendChild(this.createElementNS(nn.ns, subElement));
									} else {										
										newNode = curNode.appendChild(this.createNode(1, subElement, nn.ns));
									}
								} else {
									newNode = curNode.appendChild(this.createElement(subElement));
								}								
								if(!!nn.Text) {	newNode.appendChild(util.isDef(nn.hasCDATA)?this.createCDATASection(nn.Text):this.createTextNode(nn.Text)); }
								XMLSerializer.objToNode.call(this, newNode, nn);
							} while(n++ < nlen);																		
						}
					}
				}
			}
		}
	};
	//Base child element
	var IChild = function(parent) {
		this.parent = parent || null;
	};
	//Root Node Class
	var IRoot = function(name) {				
		this.nodeName = name || "";
		this.ns = "";				
	};	
	//Node Class
	var INode = function() {
		var parent = null, name = null, value = null;
		switch(arguments.length) {
			case 1: name = arguments[0]; break;
			case 2: parent = arguments[0]; name = arguments[1]; break;
			case 3: parent = arguments[0]; name = arguments[1]; value = arguments[2]; break;
			default: name = "noname";
		}
		IRoot.apply(this, [name]);
		IChild.apply(this, [parent]);
		this.Text = value || "";				
	};	
	//Node Object - can have children
	var INodeSet = function() {
		this.length = 0;
		this.push = function(elem){ Array.prototype.push.call( this, elem ); };
		this.sort = function() { Array.prototype.sort.apply( this, arguments ); };
	};
	INodeSet.prototype = {
		getNodesByAttribute: function(attr, obj){
			var out = [];
			if(!!this.length && util.isStr(attr) && util.isDef(obj)) {
				var n = this.length, node, aval;
				while(n--) {
					node = this[n]; aval = node[attr];
					if(util.isDef(aval) && aval === obj) { out.unshift(node); }
				}
			}
			return (!out.length)?null:out;
		},
		getNodesByValue: function(obj){
			var out = [];
			if(!!this.length && util.isDef(obj)) {
				var n = this.length, node;
				while(n--) {
					node = this[n];
					if(node.Text === obj) { out.unshift(node); }
				}
			}
			return (!out.length)?null:out;
		},
		contains: function(attr, obj){
			var out = false;
			if(!!this.length && util.isStr(attr) && util.isDef(obj)) {
				var n = this.length, node, aval;
				while(n--) {
					node = this[n]; aval = node[attr];
					if(util.isDef(aval) && aval === obj) { out = true; break; }
				}
			}
			return out;
		},
		indexOf: function(){
			var out = -1, attr, obj;
			if(!!this.length) {
				var n = this.length, node, val;
				switch(arguments.length) {
					case 1: obj = arguments[0];
						while(n--) {
							node = this[n]; val = node.val();
							if(util.isDef(val) && val === obj) { out = n; break; }
						}
						break;
					case 2: attr = arguments[0]; obj = arguments[1];
						while(n--) {
							node = this[n]; val = node[attr];
							if(util.isDef(val) && val === obj) { out = n; break; }
						}
						break;
				}						
			}
			return out;	
		},
		sortByAttribute: function(attr, dir){
			if(!!this.length && util.isStr(attr)) {
				this.sort(function(a,b) {
					var _a = (a.attr(attr)), 
						_b = (b.attr(attr));
					_a = util.isNum(_a)?parseFloat(_a):_a;
					_b = util.isNum(_b)?parseFloat(_b):_b;
					var _out = (_a<_b)?-1:(_b<_a)?1:0;
						_out = (util.isDef(dir) && dir.toLowerCase() === "desc")?(0-_out):_out;
					return _out;
				});
			}
		},	
		sortByValue: function(dir){
			if(!!this.length) {
				this.sort(function(a,b) {
					var _a = (a.Text), 
						_b = (b.Text);
					_a = util.isNum(_a)?parseFloat(_a):_a;
					_b = util.isNum(_b)?parseFloat(_b):_b;
					var _out = (_a<_b)?-1:(_b<_a)?1:0;
						_out = (util.isDef(dir) && dir.toLowerCase() === "desc")?(0-_out):_out;
					return _out;
				});
			}	
		},
		sortByChildNode: function(nodeName, dir){
			if(!!this.length && util.isStr(nodeName)) {
				this.sort(function(a,b) {
					var _a = a[nodeName],
						_b = b[nodeName];
					_a = (util.isDef(_a) && !!_a.length)?_a[0].Text:null;
					_b = (util.isDef(_b) && !!_b.length)?_b[0].Text:null;
					//---------------------------------------------------//
					_a = util.isNum(_a)?parseFloat(_a):_a;
					_b = util.isNum(_b)?parseFloat(_b):_b;
					var _out = (_a<_b)?-1:(_b<_a)?1:0;
						_out = (util.isDef(dir) && dir.toLowerCase() === "desc")?(0-_out):_out;
					return _out;
				});
			}	
		},	
		first: function() {
			var out = null;
			if(!!this.length) { out = this[0]; }
			return out;
		},
		last: function() {
			var out = null;
			if(!!this.length) { out = this[this.length-1]; }
			return out;
		}	
	};
	//Engine Factory
	var XMLObjectifierEngine = (function() {				
		var _public = {
			makeNodeSet: function() {
				var node = new INodeSet();				
				return node;
			},
			makeNode: function(parent, obj)	{
				var name = obj.localName||obj.baseName;
					name = util.formatName(name);
				var node = new INode(parent, name);
					node.ns = obj.prefix || "";							
					this.setAttributes(node, obj);
				return node;
			},
			setAttributes: function(obj, xnode) {
				if(util.isDef(xnode) && !!xnode.attributes.length) {							
					var a = xnode.attributes.length-1, attName = null, objParent = null;
					do { //Order is irrelevant (speed-up)
						attName = "@"+xnode.attributes[a].name;							
						obj.attr(attName, xnode.attributes[a].value);
					} while(a--);
				}
			},
			run: function(parent, xobj) {
				var curChild, newNode;
				if(util.isDef(parent) && util.isDef(xobj)) {
					if(xobj.hasChildNodes()) {
						var nodesLen = xobj.childNodes.length-1, n = 0;
						do {
							curChild = xobj.childNodes[n];
							switch(curChild.nodeType) {
								case 1: //Node										
									//Create a single node
									newNode = _public.makeNode(parent, curChild);
									if(util.isFn(this.decorator)) {
										var _dout = this.decorator.call(newNode);
										//Skip node if decorator returns false
										if(_dout === false) { continue; }
									}
									if(!!newNode) {
										//Add child node to parent
										parent.appendChild(newNode);
										//Recursive call if node contains children
										if(curChild.hasChildNodes()){ _public.run.apply(this, [newNode, curChild]); }												
									}
									break;
								case 3: //Text Value
									parent.val(util.trim(curChild.nodeValue));	
									break;
								case 4: //CDATA										
									parent.hasCDATA = true;
									parent.val(util.isDef(curChild.text)?util.trim(curChild.text):util.trim(curChild.nodeValue));												
									break;
								case 8: //Comments
									if(!util.isDef(this.noComments) || !this.noComments) {
										if(!util.isDef(parent.$comments)) { parent.$comments = []; }
										parent.$comments.push(util.trim(curChild.nodeValue));
									}
									break;											
							}
						} while(n++ < nodesLen);
					}
				}
			},
			init: function(xobj, opt) {
				opt = opt || {noComments: true};
				if(util.isStr(xobj)){
					xobj = this.textToXML(xobj);
				} else if(util.isXNode(xobj)){ xobj = xobj;
				} else { xobj = null; }
				//If invalid xml object - abort
				if(!xobj){ return null; }
				//Determine a document root node
				var xroot = (xobj.nodeType === 9)?xobj.documentElement:(xobj.nodeType === 11)?xobj.firstChild:xobj;
				//Root Node
				var root = new IRoot(xroot.nodeName);
				if(util.isFn(opt.decorator)) {
					opt.decorator.call(root);
				}
				//If init argument is just a text or CDATA return value
				if(xobj.nodeType === 3 || xobj.nodeType === 4) {
					return xobj.nodeValue;
				}
				//Begins a recursive process to build out a JSON structure						
				this.run.apply(opt, [root, xroot]);
				this.setAttributes(root, xroot);
				return root;
			},
			textToXML: function(strXML) {
				var xmlDoc = null;
				try {
					xmlDoc = (util.isIE())?new ActiveXObject("MSXML2.DOMDocument"):new DOMParser();
					xmlDoc.async = false;
				} catch(e) {throw new Error("XML Parser could not be instantiated");}
				var out = null, isParsed = true;
				if(util.isIE()) {
					isParsed = xmlDoc.loadXML(strXML);
					out = (isParsed)?xmlDoc:false;
				} else {
					out = xmlDoc.parseFromString(strXML, "text/xml");
					isParsed = (out.documentElement.tagName !== "parsererror");
				}
				if(!isParsed){throw new Error("Error parsing XML string");}
				return out;
			}
		};
		
		return _public;				 
	})();
	IRoot.prototype = {
		typeOf: "xmlObjectifier",
		attr: function() {
			var out, attr, val;
			if(!!arguments.length) {
				switch(arguments.length) {
					case 1:	attr = util.formatName(arguments[0]);
							val = this["@"+attr]||this[attr];
							if(util.isDef(val) && !util.isArr(val)) { out = val; } break;
					case 2: attr = util.formatName(arguments[0]);
							val = arguments[1];
							if(util.isStr(attr)) { this[(/^@/.test(attr))?attr:"@"+attr] = val; out = this;} break;
				}
			}
			return out;
		},
		find: function(sel) {
			var out = null, tokens, token, tokenOnly;
			if(util.isStr(sel)) {
				var curMatch, subNode;
				var condMatch = /\[(\d+|@\w+(=\w+)?)\]/, conditionStr, parts, partA, partB;
				var rx = /(?=\.)?([A-Za-z\-]+(\[(\d+|@\w+(=\w+)?)\])?)/g;
				var attrMatch = /^@\w+/, attr;
				//If selector is an attribute, then just find attribute and return it
				if(sel.match(attrMatch)) {
					attr = sel.match(attrMatch)[0];
					return this.attr(attr);
				}
				tokens = sel.match(rx);
				if(!!tokens.length) {
					var t = 0, tLen = tokens.length-1;
					do {								
						token = tokens[t];
						tokenOnly = token.match(/[A-Za-z\-]+/)[0];
						curMatch = !!curMatch?(util.isArr(curMatch)?curMatch[0]:curMatch)[tokenOnly]:this[tokenOnly];
						if(!curMatch) { break; }
						conditionStr = !!token.match(condMatch) && token.match(condMatch)[0].replace("[","").replace("]","");
						if(conditionStr && !!conditionStr.length) {
							if(conditionStr.indexOf("=")!==-1) {
								parts = conditionStr.split("=");
								partA = util.trim(parts[0]); partB = util.trim(parts[1]);
								if(partA.indexOf("@")!==-1) {
									attr = partA;
									curMatch = curMatch.getNodesByAttribute(attr, partB);
								} else {
									subNode = util.trim(curMatch[partA]);
									if(subNode) {
										curMatch = subNode.getNodesByValue(partB);
									}
								}
							} else if(util.isNum(conditionStr)){ 
								curMatch = curMatch[parseInt(conditionStr, 10)];
							}
						}								
					} while(t++ < tLen);
					out = curMatch;
				}
			}
			return out;
		},
		addComment: function(comment) {
			if(util.isStr(comment)) {
			if(!util.isDef(this.$comments)) { this.$comments = []; }
				this.$comments.push(comment);
			}
			return this;
		},
		val: function(v) {
			var out = this;
			if(util.isDef(v)) {
				this.Text = v;
			} else { out = this.Text; }
			return out;
		},
		toXML: function() {
			var root = XMLSerializer.newDocument(this.nodeName, this.ns);
			XMLSerializer.objToNode.call(root, root.documentElement, this);
			return root;
		},
		toString: function() {
			var root = this.toXML();
			var out = "";
			if(util.isDef(root.xml)) {
				out = root.xml;
			} else if(util.isDef(XMLSerializer)){
				var serializer = new window.XMLSerializer();
				out = serializer.serializeToString(root);
			}
			return out;
		},
		appendChild: function(nodeClassInst) {
			if(util.isDef(nodeClassInst) && nodeClassInst instanceof INode) {
				nodeClassInst.parent = this;
				if(!util.isDef(this[nodeClassInst.nodeName])) { this[nodeClassInst.nodeName] = XMLObjectifierEngine.makeNodeSet(); }
				this[nodeClassInst.nodeName].push(nodeClassInst);
			}
		}
	};
	INode.prototype = {
		attr: IRoot.prototype.attr,
		val: IRoot.prototype.val,
		find: IRoot.prototype.find,
		addComment: IRoot.prototype.addComment,
		appendChild: IRoot.prototype.appendChild
	};
	//All Public members
	var _publicMapping = {
		xmlToJSON: function(xdoc, opt) {
			return XMLObjectifierEngine.init(xdoc, opt);
		},
		//Converts Text to XML DOM
		textToXML: XMLObjectifierEngine.textToXML,
		//Classes exposed for prototype extensibility
		xmlObjectifier: {
			RootClass: IRoot, //Root node only
			NodeClass: INode,  //Node element
			NodeSetClass: INodeSet //NodeSet class
		}
	};

	if(util.isDef($)) {
		$.extend ( _publicMapping );
	} else {
		window.XMLObjectifier = _publicMapping;
	}
})((typeof(jQuery) !== "undefined") && jQuery || undefined);