import fv.utils.Delegate;

/**
Loads an XML document and parses the data contained within the file into an array data structure for easy access. Supports the sending of POST data for use with dynamic XML documents.
*/
class fv.XMLParser
{
	/**
	Invoked when the XML document has been parsed successfully after loading.

	@params
	<code>data:Array</code> - see <a href="#data">data</a>
	*/
	public function onLoad(data:Array):Void {}

	/**
	Invoked if the XML document could not be loaded or parsed successfully.

	@params
	<code>code:Number</code> - A quantitative representation of the error that has occured.</a>
	<code>message:String</code> - A qualitative representation of the error that has occured.</a>

	The following are the 11 possible error codes with their respective error messages:

	<code>-1</code> : The XML document could not be loaded.
	<code>-2</code> : A CDATA section was not properly terminated.
	<code>-3</code> : The XML declaration was not properly terminated.
	<code>-4</code> : The DOCTYPE declaration was not properly terminated.
	<code>-5</code> : A comment was not properly terminated.
	<code>-6</code> : An XML element was malformed.
	<code>-7</code> : Out of memory.
	<code>-8</code> : An attribute value was not properly terminated.
	<code>-9</code> : A start-tag was not matched with an end-tag.
	<code>-10</code> : An end-tag was encountered without a matching start-tag.
	<code>default</code> : An unknown error has occurred.
	*/
	public function onError(code:Number, message:String):Void {}

	private var __data:Array;
	/**
	The data extracted from the loaded XML document represented as an Array. 

	@usageNote Child nodes are accessed as elements of the node <code>Array</code> (<code>node[ChildNodeIndex]</code>) and attributes are accessed as properties of the node <code>Array</code> (<code>node[attributeName]</code>).
	*/
	public function get data():Array { return __data; }

	private var __thisObject:Object;
	private var __callback;

	private var __lv:LoadVars;
	private var __xml:XML;

	private var __status:Number;

	/**
	@params
	<code>url:String</code> - The URL of the XML document to be loaded.

	<code>queryObject:Object</code> (optional) - An object whos enumerable variables are concentrated into a string and posted to the URL using the HTTP POST method.

	<code>thisObject:Object</code> (optional) - The object that will be referenced whenever the keyword "this" is used in the body of the <code>callback</code> function.

	<code>callback:Mixed</code> (optional) - The function that will be executed after the XML document has been parsed. The parsed data will be passed as a parameter to this function.

	@usageNote The method parameter can either be a <code>String</code> or a <code>Function</code>. If a <code>String</code> is passed, the method of the same name assigned to the <code>thisObject</code> will be executed (<code>thisObject[method]</code>).

	@example
	<code>
	var input = new Object();
	input.page = 2;
	input.category = "music";
	
	var xml = new XMLParser("data.xml", input);
	xml.onLoad = function(data:Array):Void
	{
		trace(data);
	}
	</code>
	*/
	function XMLParser(url:String, queryObject:Object, thisObject:Object, callback)
	{
		System.useCodepage = true;
	
		__thisObject = (thisObject == undefined ? this : thisObject);
		__callback = (callback == undefined ? "onLoad" : callback);

		if (url.indexOf("www.") != -1 && _root._url.indexOf("www.") == -1)
		{
			url = url.split("www.").join("");
		}

		__xml = new XML();
		__xml.ignoreWhite = true;
		__xml.onLoad = Delegate.create(this, "onData");

		__lv = new LoadVars();

		for (var name in queryObject)
		{
			var value = queryObject[name];
			if (value != undefined) __lv[name] = value;
		}

		__lv.sendAndLoad(url, __xml);
	}

	private function onData(success:Boolean):Void
	{
		delete __lv;

		try
		{
			if (!success) __status = -1;
			else __status = __xml.status;

			if (__status != 0) throw new Error(errorMessage(__status));
		}
		catch(error:Error)
		{
			trace(error.message);
			onError(__status, error.message);
		}
		finally
		{
			if (__status == 0)
			{			
				var callback = (typeof __callback == "string" ? __thisObject[__callback] : __callback);
				__data = parseNode(__xml.firstChild);
				callback.apply(__thisObject, [__data]);
			}
		}
	}

	private function parseNode(xml):Array
	{
		var attributes = xml.attributes;
		var childNodes = xml.childNodes;
		var data = new Array();

		for (var i in attributes)
		{
			data[i] = parseValue(attributes[i]);
		}

		for (var i = 0; i < childNodes.length; i++)
		{
			var childNode = childNodes[i];

			if (childNode.nodeType == 3)
			{
				data.push(parseValue(childNode.nodeValue));
			}
			else
			{
				data.push(parseNode(childNode));
				data[childNode.nodeName] = data[i];
			}
		}

		return data;
	}

	private function parseValue(value)
	{
		if (value == "true" || value == "false") return value == "true";
		if (!isNaN(value)) return Number(value);
		return value;
	}

	private function errorMessage(status:Number):String
	{
		switch (status)
		{
			case -1 : return "The XML document could not be loaded."
			case -2 : return "A CDATA section was not properly terminated.";
			case -3 : return "The XML declaration was not properly terminated.";
			case -4 : return "The DOCTYPE declaration was not properly terminated.";
			case -5 : return "A comment was not properly terminated.";
			case -6 : return "An XML element was malformed.";
			case -7 : return "Out of memory.";
			case -8 : return "An attribute value was not properly terminated.";
			case -9 : return "A start-tag was not matched with an end-tag.";
			case -10 : return "An end-tag was encountered without a matching start-tag.";
			default : return "An unknown error has occurred.";
		}
	}

	private function toString():String
	{
		return __xml.toString();
	}
}