// ========================================================================
//  XML.ObjTree -- XML source code from/to JavaScript object like E4X
// ========================================================================

if (typeof(XML) == 'undefined') 
	XML = function(){
		};

//  constructor

XML.ObjTree = function(){
	return this;
};

//  class variables

XML.ObjTree.VERSION = "0.24";

//  object prototype

XML.ObjTree.prototype.xmlDecl = '<?xml version="1.0" encoding="UTF-8" ?>\n';
XML.ObjTree.prototype.attr_prefix = '';
XML.ObjTree.prototype.overrideMimeType = 'text/xml';

//  method: parseXML( xmlsource )

XML.ObjTree.prototype.parseXML = function(xml){
	var root;
	if (window.DOMParser) {
		var xmldom = new DOMParser();
		//      xmldom.async = false;           // DOMParser is always sync-mode
		var dom = xmldom.parseFromString(xml, "application/xml");
		if (!dom) 
			return;
		root = dom.documentElement;
	}
	else 
		if (window.ActiveXObject) {
			xmldom = new ActiveXObject('Microsoft.XMLDOM');
			xmldom.async = false;
			xmldom.loadXML(xml);
			root = xmldom.documentElement;
		}
	if (!root) 
		return;
	return this.parseDOM(root);
};

//  method: parseHTTP( url, options, callback )

XML.ObjTree.prototype.parseHTTP = function(url, options, callback){
	var myopt = {};
	for (var key in options) {
		myopt[key] = options[key]; // copy object
	}
	if (!myopt.method) {
		if (typeof(myopt.postBody) == "undefined" &&
		typeof(myopt.postbody) == "undefined" &&
		typeof(myopt.parameters) == "undefined") {
			myopt.method = "get";
		}
		else {
			myopt.method = "post";
		}
	}
	if (callback) {
		myopt.asynchronous = true; // async-mode
		var __this = this;
		var __func = callback;
		var __save = myopt.onComplete;
		myopt.onComplete = function(trans){
			var tree;
			if (trans && trans.responseXML && trans.responseXML.documentElement) {
				tree = __this.parseDOM(trans.responseXML.documentElement);
			}
			else 
				if (trans && trans.responseText) {
					tree = __this.parseXML(trans.responseText);
				}
			__func(tree, trans);
			if (__save) 
				__save(trans);
		};
	}
	else {
		myopt.asynchronous = false; // sync-mode
	}
	var trans;
	if (typeof(HTTP) != "undefined" && HTTP.Request) {
		myopt.uri = url;
		var req = new HTTP.Request(myopt); // JSAN
		if (req) 
			trans = req.transport;
	}
	else 
		if (typeof(Ajax) != "undefined" && Ajax.Request) {
			var req = new Ajax.Request(url, myopt); // ptorotype.js
			if (req) 
				trans = req.transport;
		}
	//  if ( trans && typeof(trans.overrideMimeType) != "undefined" ) {
	//      trans.overrideMimeType( this.overrideMimeType );
	//  }
	if (callback) 
		return trans;
	if (trans && trans.responseXML && trans.responseXML.documentElement) {
		return this.parseDOM(trans.responseXML.documentElement);
	}
	else 
		if (trans && trans.responseText) {
			return this.parseXML(trans.responseText);
		}
}

//  method: parseDOM( documentroot )

XML.ObjTree.prototype.parseDOM = function(root){
	if (!root) 
		return;
	
	this.__force_array = {};
	if (this.force_array) {
		for (var i = 0; i < this.force_array.length; i++) {
			this.__force_array[this.force_array[i]] = 1;
		}
	}
	
	var json = this.parseElement(root); // parse root node
	if (this.__force_array[root.nodeName]) {
		json = [json];
	}
	if (root.nodeType != 11) { // DOCUMENT_FRAGMENT_NODE
		var tmp = {};
		tmp[root.nodeName] = json; // root nodeName
		json = tmp;
	}
	return json;
};

//  method: parseElement( element )

XML.ObjTree.prototype.parseElement = function(elem){
	//  COMMENT_NODE
	if (elem.nodeType == 7) {
		return;
	}
	
	//  TEXT_NODE CDATA_SECTION_NODE
	if (elem.nodeType == 3 || elem.nodeType == 4) {
		var bool = elem.nodeValue.match(/[^\x00-\x20]/);
		if (bool == null) 
			return; // ignore white spaces
		return elem.nodeValue;
	}
	
	var retval;
	var cnt = {};
	
	//  parse attributes
	if (elem.attributes && elem.attributes.length) {
		retval = {};
		for (var i = 0; i < elem.attributes.length; i++) {
			var key = elem.attributes[i].nodeName;
			if (typeof(key) != "string") 
				continue;
			var val = elem.attributes[i].nodeValue;
			if (!val) 
				continue;
			key = this.attr_prefix + key;
			if (typeof(cnt[key]) == "undefined") 
				cnt[key] = 0;
			cnt[key]++;
			this.addNode(retval, key, cnt[key], val);
		}
	}
	
	//  parse child nodes (recursive)
	if (elem.childNodes && elem.childNodes.length) {
		var textonly = true;
		if (retval) 
			textonly = false; // some attributes exists
		for (var i = 0; i < elem.childNodes.length && textonly; i++) {
			var ntype = elem.childNodes[i].nodeType;
			if (ntype == 3 || ntype == 4) 
				continue;
			textonly = false;
		}
		if (textonly) {
			if (!retval) 
				retval = "";
			for (var i = 0; i < elem.childNodes.length; i++) {
				retval += elem.childNodes[i].nodeValue;
			}
		}
		else {
			if (!retval) 
				retval = {};
			for (var i = 0; i < elem.childNodes.length; i++) {
				var key = elem.childNodes[i].nodeName;
				if (typeof(key) != "string") 
					continue;
				var val = this.parseElement(elem.childNodes[i]);
				if (!val) 
					continue;
				if (typeof(cnt[key]) == "undefined") 
					cnt[key] = 0;
				cnt[key]++;
				this.addNode(retval, key, cnt[key], val);
			}
		}
	}
	return retval;
};

//  method: addNode( hash, key, count, value )

XML.ObjTree.prototype.addNode = function(hash, key, cnts, val){
	if (this.__force_array[key]) {
		if (cnts == 1) 
			hash[key] = [];
		hash[key][hash[key].length] = val; // push
	}
	else 
		if (cnts == 1) { // 1st sibling
			hash[key] = val;
		}
		else 
			if (cnts == 2) { // 2nd sibling
				hash[key] = [hash[key], val];
			}
			else { // 3rd sibling and more
				hash[key][hash[key].length] = val;
			}
};

//  method: writeXML( tree )

XML.ObjTree.prototype.writeXML = function(tree){
	var xml = this.hash_to_xml(null, tree);
	return this.xmlDecl + xml;
};

//  method: hash_to_xml( tagName, tree )

XML.ObjTree.prototype.hash_to_xml = function(name, tree){
	var elem = [];
	var attr = [];
	for (var key in tree) {
		if (!tree.hasOwnProperty(key)) 
			continue;
		var val = tree[key];
		if (key.charAt(0) != this.attr_prefix) {
			if (typeof(val) == "undefined" || val == null) {
				elem[elem.length] = "<" + key + " />";
			}
			else 
				if (typeof(val) == "object" && val.constructor == Array) {
					elem[elem.length] = this.array_to_xml(key, val);
				}
				else 
					if (typeof(val) == "object") {
						elem[elem.length] = this.hash_to_xml(key, val);
					}
					else {
						elem[elem.length] = this.scalar_to_xml(key, val);
					}
		}
		else {
			attr[attr.length] = " " + (key.substring(1)) + '="' + (this.xml_escape(val)) + '"';
		}
	}
	var jattr = attr.join("");
	var jelem = elem.join("");
	if (typeof(name) == "undefined" || name == null) {
		// no tag
	}
	else 
		if (elem.length > 0) {
			if (jelem.match(/\n/)) {
				jelem = "<" + name + jattr + ">\n" + jelem + "</" + name + ">\n";
			}
			else {
				jelem = "<" + name + jattr + ">" + jelem + "</" + name + ">\n";
			}
		}
		else {
			jelem = "<" + name + jattr + " />\n";
		}
	return jelem;
};

//  method: array_to_xml( tagName, array )

XML.ObjTree.prototype.array_to_xml = function(name, array){
	var out = [];
	for (var i = 0; i < array.length; i++) {
		var val = array[i];
		if (typeof(val) == "undefined" || val == null) {
			out[out.length] = "<" + name + " />";
		}
		else 
			if (typeof(val) == "object" && val.constructor == Array) {
				out[out.length] = this.array_to_xml(name, val);
			}
			else 
				if (typeof(val) == "object") {
					out[out.length] = this.hash_to_xml(name, val);
				}
				else {
					out[out.length] = this.scalar_to_xml(name, val);
				}
	}
	return out.join("");
};

//  method: scalar_to_xml( tagName, text )

XML.ObjTree.prototype.scalar_to_xml = function(name, text){
	if (name == "#text") {
		return this.xml_escape(text);
	}
	else {
		return "<" + name + ">" + this.xml_escape(text) + "</" + name + ">\n";
	}
};

//  method: xml_escape( text )

XML.ObjTree.prototype.xml_escape = function(text){
	return String(text).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
};