var MooTreeIcon = ['I','L','Lminus','Lplus','Rminus','Rplus','T','Tminus','Tplus','_closed','_doc','_open','minus','plus'];
var MooTreeControl = new Class({
	initialize: function(config, options) {
			options.control = this;               // make sure our new MooTreeNode knows who it's owner control is
		options.div = config.div;             // tells the root node which div to insert itself into
		this.root = new MooTreeNode(options); // create the root node of this tree control
			this.index = new Object();            // used by the get() method
			this.enabled = true;                  // enable visual updates of the control
			this.theme = config.theme || 'mootree.gif';
			this.loader = config.loader || {icon:'mootree_loader.gif', text:'Loading...', color:'#a0a0a0'};
			this.selected = null;                 // set the currently selected node to nothing
		this.mode = config.mode;              // mode can be "folders" or "files", and affects the default icons
		this.grid = config.grid;              // grid can be turned on (true) or off (false)
			this.onExpand = config.onExpand || new Function(); // called when any node in the tree is expanded/collapsed
		this.onSelect = config.onSelect || new Function(); // called when any node in the tree is selected/deselected
		this.onClick = config.onClick || new Function(); // called when any node in the tree is clicked
			this.root.update(true);
		},
	insert: function(options) {
		options.control = this;
		return this.root.insert(options);
	},
	select: function(node) {
		this.onClick(node); node.onClick(); // fire click events
		if (this.selected === node) return; // already selected
		if (this.selected) {
			// deselect previously selected node:
			this.selected.select(false);
			this.onSelect(this.selected, false);
		}
		// select new node:
		this.selected = node;
		node.select(true);
		this.onSelect(node, true);
	},
	expand: function() {
		this.root.toggle(true, true);
	},

	collapse: function() {
		this.root.toggle(true, false);
	},
	get: function(id) {
		return this.index[id] || null;
	},
	adopt: function(id, parentNode) {
		if (parentNode === undefined) parentNode = this.root;
		this.disable();
		this._adopt(id, parentNode);
		parentNode.update(true);
		$(id).remove();
		this.enable();
	},
	_adopt: function(id, parentNode) {
		/* adopts a structure of ul/li elements into this tree */
		e = $(id);
		var i=0, c = e.getChildren();
		for (i=0; i<c.length; i++) {
			if (c[i].nodeName == 'LI') {
				var con={text:''}, comment='', node=null, subul=null;
				var n=0, z=0, se=null, s = c[i].getChildren();
				for (n=0; n<s.length; n++) {
					switch (s[n].nodeName) {
						case 'A':
							for (z=0; z<s[n].childNodes.length; z++) {
								se = s[n].childNodes[z];
								switch (se.nodeName) {
									case '#text': con.text += se.nodeValue; break;
									case '#comment': comment += se.nodeValue; break;
								}
							}
							con.data = s[n].getProperties('href','target','title','name');
						break;
						case 'UL':
							subul = s[n];
						break;
					}
				}
				if (con.label != '') {
					con.data.url = con.data['href']; // (for backwards compatibility)
					if (comment != '') {
						var bits = comment.split(';');
						for (z=0; z<bits.length; z++) {
							var pcs = bits[z].trim().split(':');
							if (pcs.length == 2) con[pcs[0].trim()] = pcs[1].trim();
						}
					}
					node = parentNode.insert(con);
					if (subul) this._adopt(subul, node);
				}
			}
		}
	},
	disable: function() {
		this.enabled = false;
	},

	enable: function() {
		this.enabled = true;
		this.root.update(true, true);
	}
});

var MooTreeNode = new Class({
	initialize: function(options) {
			this.text = options.text || null;       // the text displayed by this node
		this.url = options.url || null;       // the text displayed by this node
		this.link = options.link || null;       // the text displayed by this node
		this.id = options.id || null;   // the node's unique id
		this.nodes = new Array();       // subnodes nested beneath this node (MooTreeNode objects)
		this.parent = null;             // this node's parent node (another MooTreeNode object)
		this.last = true;               // a flag telling whether this node is the last (bottom) node of it's parent
		this.control = options.control; // owner control of this node's tree
		this.selected = false;          // a flag telling whether this node is the currently selected node in it's tree
			this.color = options.color || null; // text color of this node
			this.data = options.data || {}; // optional object containing whatever data you wish to associate with the node (typically an url or an id)
			this.onExpand = options.onExpand || new Function(); // called when the individual node is expanded/collapsed
		this.onSelect = options.onSelect || new Function(); // called when the individual node is selected/deselected
		this.onClick = options.onClick || new Function(); // called when the individual node is clicked
			this.open = options.open ? true : false; // flag: node open or closed?
			this.icon = options.icon;
		this.openicon = options.openicon || this.icon;
			// add the node to the control's node index:
		if (this.id) this.control.index[this.id] = this;
			// create the necessary divs:
		this.div = {
			main: new Element('div').addClass('mooTree_node'),
			indent: new Element('div'),
			gadget: new Element('div'),
			icon: new Element('div'),
			text: new Element('div').addClass('mooTree_text'),
			sub: new Element('div')
		}
			// put the other divs under the main div:
		this.div.main.adopt(this.div.indent);
		this.div.main.adopt(this.div.gadget);
		this.div.main.adopt(this.div.icon);
		this.div.main.adopt(this.div.text);

		// put the main and sub divs in the specified parent div:
		$(options.div).adopt(this.div.main);
		$(options.div).adopt(this.div.sub);
			// attach event handler to gadget:
		this.div.gadget._node = this;
		this.div.gadget.onclick = this.div.gadget.ondblclick = function() {
			this._node.toggle();
		}
			// attach event handler to icon/text:
		this.div.icon._node = this.div.text._node = this;
		this.div.icon.onclick = this.div.icon.ondblclick = this.div.text.onclick = this.div.text.ondblclick = function() {
			this._node.control.select(this._node);
		}
		},
	insert: function(options) {
			// set the parent div and create the node:
		options.div = this.div.sub;
		options.control = this.control;
		var node = new MooTreeNode(options);
			// set the new node's parent:
		node.parent = this;
			// mark this node's last node as no longer being the last, then add the new last node:
		var n = this.nodes;
		if (n.length) n[n.length-1].last = false;
		n.push(node);
			// repaint the new node:
		node.update();
			// repaint the new node's parent (this node):
		if (n.length == 1) this.update();
			// recursively repaint the new node's previous sibling node:
		if (n.length > 1) n[n.length-2].update(true);
			return node;
		},
	remove: function() {
		var p = this.parent;
		this._remove();
		p.update(true);
	},
	_remove: function() {
			// recursively remove this node's subnodes:
		var n = this.nodes;
		while (n.length) n[n.length-1]._remove();
			// remove the node id from the control's index:
		delete this.control.index[this.id];
			// remove this node's divs:
		this.div.main.remove();
		this.div.sub.remove();
			if (this.parent) {
					// remove this node from the parent's collection of nodes:
			var p = this.parent.nodes;
			p.remove(this);
					// in case we removed the parent's last node, flag it's current last node as being the last:
			if (p.length) p[p.length-1].last = true;
				}
		},
	clear: function() {
		this.control.disable();
		while (this.nodes.length) this.nodes[this.nodes.length-1].remove();
		this.control.enable();
	},
	update: function(recursive, invalidated) {
			var draw = true;
			if (!this.control.enabled) {
			// control is currently disabled, so we don't do any visual updates
			this.invalidated = true;
			draw = false;
		}
			if (invalidated) {
			if (!this.invalidated) {
				draw = false; // this one is still valid, don't draw
			} else {
				this.invalidated = false; // we're drawing this item now
			}
		}
			if (draw) {
					var x;
					// make selected, or not:
			this.div.main.className = 'mooTree_node' + (this.selected ? ' mooTree_selected' : '');
					// update indentations:
			x = this.div.indent;
			this.empty(x);
			var p = this, i;
			while (p.parent) {
				p = p.parent;
				i = this.getImg(p.last || !this.control.grid ? '' : 'I');
				if (x.firstChild) {
					i.injectBefore( x.firstChild );
				} else {
					x.adopt(i);
				}
			}
					// update the text:
			if(this.text) {
				x = this.div.text;
				this.empty(x);
				x.appendText(this.text);
				if (this.color) x.style.color = this.color;
			}
			else {
				if(this.url) {
					x = this.div.text;
					this.empty(x);
					var _link = new Element('a');
					_link.href = this.url;
					_link.setHTML(this.link);
					x.adopt(_link);													}			}
					// update the icon:
			x = this.div.icon;
			this.empty(x);
			this.getImg( this.nodes.length ? ( this.open ? (this.openicon || this.icon || '_open') : (this.icon || '_closed') ) : ( this.icon || (this.control.mode == 'folders' ? '_closed' : '_doc') ), x );
					// update the plus/minus gadget:
			x = this.div.gadget;
			this.empty(x);
			this.getImg( ( this.control.grid ? ( this.control.root == this ? (this.nodes.length ? 'R' : '') : (this.last?'L':'T') ) : '') + (this.nodes.length ? (this.open?'minus':'plus') : ''), x );
					// show/hide subnodes:
			this.div.sub.style.display = this.open ? 'block' : 'none';
			}
			// if recursively updating, update all child nodes:
		if (recursive) this.nodes.forEach( function(node) {
			node.update(true, invalidated);
		});
		},
	getImg: function(name, div) {
			// if no div was specified, create a new one:
		if (div === undefined) div = new Element('div');
			// apply the mooTree_img CSS class:
		div.addClass('mooTree_img');
			// if a blank image was requested, simply return it now:
		if (name == '') return div;
			var img = this.control.theme;
		var i = MooTreeIcon.indexOf(name);
		if (i == -1) {
			// custom (external) icon:
			var x = name.split('#');
			img = x[0];
			i = (x.length == 2 ? parseInt(x[1])-1 : 0);
		}
		div.style.backgroundImage = 'url(' + img + ')';
		div.style.backgroundPosition = '-' + (i*18) + 'px 0px';
			return div;
		},
	toggle: function(recursive, state) {
			this.open = (state === undefined ? !this.open : state);
		this.update();

		this.onExpand(this.open);
		this.control.onExpand(this, this.open);

		if (recursive) this.nodes.forEach( function(node) {
			node.toggle(true, this.open);
		}, this);
		},
	select: function(state) {
		this.selected = state;
		this.update();
		this.onSelect(state);
	},	load: function(url, vars) {		if (this.loading) return; // if this node is already loading, return
		this.loading = true;      // flag this node as loading			this.toggle(false, true); // expand the node to make the loader visible			this.clear();
		this.insert(this.control.loader);
			var f = function() {
			new XHR({
				method: 'GET',
				onSuccess: this._loaded.bind(this),
				onFailure: this._load_err.bind(this)
			}).send(url, vars || '');
		};
		window.setTimeout(f.bind(this), 20); // allowing a small delay for the browser to draw the loader-icon.
	},
	_loaded: function(text, xml) {
		// called on success - import nodes from the root element:
		this.control.disable();
		this.clear();
		this._import(xml.documentElement);
		this.control.enable();
		this.loading = false;
	},
	_import: function(e) {
		// import childnodes from an xml element:
		var n = e.childNodes;
		for (var i=0; i<n.length; i++) if (n[i].tagName == 'node') {
			var opt = {data:{}};
			var a = n[i].attributes;
			for (var t=0; t<a.length; t++) {
				switch (a[t].name) {
					case 'text':
					case 'id':
					case 'icon':
					case 'openicon':
					case 'color':
					case 'open':
						opt[a[t].name] = a[t].value;
						break;
					default:
						opt.data[a[t].name] = a[t].value;
				}
			}
			var node = this.insert(opt);
			if (node.data.load) {
				node.open = false; // can't have a dynamically loading node that's already open!
				node.insert(this.control.loader);
				node.onExpand = function(state) {
					this.load(this.data.load);
					this.onExpand = new Function();
				}
			}
			// recursively import subnodes of this node:
			if (n[i].childNodes.length) node._import(n[i]);
		}
	},
	_load_err: function(req) {
		window.alert('Error loading: ' + this.text);
	},
	empty: function(e) {
		while (e.lastChild) e.removeChild(e.lastChild);
	}
});