package com.cloudmade.mappingtool.model;

	import com.cloudmade.mappingtool.business.externalization.IXMLListSerializer;

	import com.cloudmade.mappingtool.business.externalization.IXMLSerializer;

	import com.cloudmade.mappingtool.business.externalization.osm.ListExternalizer;

	import com.cloudmade.mappingtool.business.externalization.osm.TagExternalizer;

	import com.cloudmade.mappingtool.business.externalization.osm.ValidTagsSerializer;

	import com.cloudmade.mappingtool.events.OSMProxyCommitErrorEvent;

	import com.cloudmade.mappingtool.events.OSMProxyLoadErrorEvent;

	import com.cloudmade.mappingtool.events.OSMProxyResultEvent;

	import com.cloudmade.mappingtool.events.OSMProxySaveEvent;

	import com.cloudmade.mappingtool.map.geo.LatLong;

	import com.cloudmade.mappingtool.map.geo.LatLongBounds;

	import com.cloudmade.mappingtool.map.model.Member;

	import com.cloudmade.mappingtool.map.model.Node;

	import com.cloudmade.mappingtool.map.model.Relation;

	import com.cloudmade.mappingtool.map.model.Tag;

	import com.cloudmade.mappingtool.map.model.Way;

	import com.cloudmade.mappingtool.model.osm.ElementDiff;

	import com.cloudmade.mappingtool.model.osm.OAuthAuthorizator;

	import com.cloudmade.mappingtool.model.osm.Transaction;

	import com.cloudmade.mappingtool.model.osm.TransactionQueue;

	import flash.errors.IOError;

	import flash.events.ErrorEvent;

	import flash.events.Event;

	import flash.events.EventDispatcher;

	import flash.events.HTTPStatusEvent;

	import flash.events.IOErrorEvent;

	import flash.events.SecurityErrorEvent;

	import flash.net.URLLoader;

	import flash.net.URLRequest;

	import flash.system.Security;

	import flash.utils.ByteArray;

	import mx.managers.CursorManager;

	/*[Event(name="save", type="com.cloudmade.mappingtool.events.OSMProxyResultEvent")]*/

	/*[Event(name="result", type="com.cloudmade.mappingtool.events.OSMProxyResultEvent")]*/

	/*[Event(name="saveFailed", type="com.cloudmade.mappingtool.events.OSMProxySaveEvent")]*/

	/*[Event(name="saveComplete", type="com.cloudmade.mappingtool.events.OSMProxySaveEvent")]*/

	/*[Event(name="loadError", type="com.cloudmade.mappingtool.events.OSMProxyLoadErrorEvent")]*/

	/*[Event(name="commitError", type="com.cloudmade.mappingtool.events.OSMProxyCommitErrorEvent")]*/

	/*[Event(name="loadingChanged", type="flash.events.Event")]*/

	// TODO: Use polymorphism.

	public final class OSMProxy extends EventDispatcher {

		public var changesetOpened(getChangesetOpened, null) : Bool ;

		public var loading(getLoading, null) : Bool ;

		/*[Embed(source="../../../../config/map.xml", mimeType="application/octet-stream")]*/

		CONFIG::local

		static var LOCAL_MAP:Class<Dynamic>;

		static var instance:OSMProxy = null;

		public static function getInstance():OSMProxy {

			if (instance == null) {

				instance = new OSMProxy(new SingletonEnforcer());

			}

			return instance;

		}

		CONFIG::public debug

		var errorModeEnabled:Bool ;

		var nodeMap:Dynamic;

		var changesetId:String;

		var lastHttpStatus:Int;

		var createdWays:Array<Dynamic> ;

		var modifiedWays:Array<Dynamic> ;

		var deletedWays:Array<Dynamic> ;

		var createdNodes:Array<Dynamic> ;

		var modifiedNodes:Array<Dynamic> ;

		var deletedNodes:Array<Dynamic> ;

		var modifiedRelations:Array<Dynamic> ;

		var mapLoader:URLLoader ;

		var authorizator:OAuthAuthorizator ;

		var openTransaction:Transaction (authorizator, true, CONFIG::osm + "changeset/create");

		var closeTransaction:Transaction (authorizator, true, CONFIG::osm + "changeset/");

		var commitTransaction:Transaction (authorizator, false, CONFIG::osm + "changeset/");

		var transactionQueue:TransactionQueue ;

		var tagsSerializer:IXMLListSerializer; 

		public function new(enforcer:SingletonEnforcer) {

			errorModeEnabled = false;

			createdWays = new Array();

			modifiedWays = new Array();

			deletedWays = new Array();

			createdNodes = new Array();

			modifiedNodes = new Array();

			deletedNodes = new Array();

			modifiedRelations = new Array();

			mapLoader = new URLLoader();

			authorizator = new OAuthAuthorizator();

			openTransaction = new Transaction;

			closeTransaction = new Transaction;

			commitTransaction = new Transaction;

			transactionQueue = new TransactionQueue();

			super();

			Security.loadPolicyFile(CONFIG::crossdomain);

			transactionQueue.addTransaction(openTransaction);

			transactionQueue.addTransaction(commitTransaction);

			transactionQueue.addTransaction(closeTransaction);

			mapLoader.addEventListener(Event.COMPLETE, mapLoader_completeHandler);

			mapLoader.addEventListener(IOErrorEvent.IO_ERROR, mapLoader_errorHandler);

			mapLoader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, mapLoader_errorHandler);

			transactionQueue.addEventListener(Event.COMPLETE, transactionQueue_completeHandler);

			transactionQueue.addEventListener(IOErrorEvent.IO_ERROR, transactionQueue_ioErrorHandler);

			commitTransaction.addEventListener(IOErrorEvent.IO_ERROR, commitTransaction_ioErrorHandler);

			transactionQueue.addEventListener(HTTPStatusEvent.HTTP_STATUS, transactionQueue_httpStatusHandler);

			openTransaction.addEventListener(Event.COMPLETE, openTransaction_completeHandler, false, 1);

			tagsSerializer = createTagsSerializer();

		}

		var _changesetOpened:Bool;

		public function getChangesetOpened():Bool {

			return _changesetOpened;

		}

		var _loading:Bool ;

		/*[Bindable("loadingChanged")]*/

		public function getLoading():Bool {

			return _loading;

		}

		public function getMap(bounds:LatLongBounds):Void {

			CONFIG::local {

				var bytes:ByteArray = new LOCAL_MAP();

				mapLoader.data = bytes.toString();

				mapLoader_completeHandler(null);

				return;

			}

			setLoading(true);

			var boundsArray:Array<Dynamic> = [bounds.westLong, bounds.southLat, bounds.eastLong, bounds.northLat];

			var url:String = CONFIG::osm + "map?bbox=" + boundsArray.join(",");

			mapLoader.load(new URLRequest(url));

		}

		public function close():Void {

			try {

				mapLoader.close();

			} catch (error:IOError) {

			}

			setLoading(false);

		}

		public function setCredentials(username:String, password:String):Void {

			transactionQueue.setCredentials(username, password);

		}

		public function openChangeset(tags:Array<Dynamic>):Void {

			if (!_changesetOpened) {

				_changesetOpened = true;

				var xml:XML = Xml.parse("<changeset></changeset>");

				serializeTags(xml, tags);

				openTransaction.requestData = "<osm>" + xml.toXMLString() + "</osm>";

			}

		}

		public function createNode(node:Node):Void {

			createdNodes.push(node);

		}

		public function modifyNode(node:Node):Void {

			modifiedNodes.push(node);

		}

		public function deleteNode(node:Node):Void {

			deletedNodes.push(node);

		}

		public function createWay(way:Way):Void {

			createdWays.push(way);

		}

		public function modifyWay(way:Way):Void {

			modifiedWays.push(way);

		}

		public function deleteWay(way:Way):Void {

			deletedWays.push(way);

		}

		public function modifyRelation(relation:Relation):Void {

			modifiedRelations.push(relation);

		}

		public function closeChangeset():Void {

			if (_changesetOpened) {

				lastHttpStatus = 0;

				transactionQueue.send();

			}

		}

		function serializeNodes(xml:XML, nodes:Array<Dynamic>):Void {

			for (node in nodes) {

				var nodeXml:XML = Xml.parse("<node></node>");

				nodeXml.@id = node.id;

				nodeXml.@version = node.version;

				nodeXml.@lat = node.position.lat;

				nodeXml.@lon = node.position.long;

				nodeXml.@changeset = changesetId;

				serializeTags(nodeXml, node.tags.source);

				xml.appendChild(nodeXml);

			}

		}

		function serializeWays(xml:XML, ways:Array<Dynamic>):Void {

			for (way in ways) {

				var wayXml:XML = Xml.parse("<way></way>");

				wayXml.@id = way.id;

				wayXml.@version = way.version;

				wayXml.@changeset = changesetId;

				var nodes:Array<Dynamic> = way.nodes.source;

				for (node in nodes) {

					wayXml.appendChild(Xml.parse("<nd ref={node.id}/>"));

				}

				serializeTags(wayXml, way.tags.source);

				xml.appendChild(wayXml);

			}

		}

		function serializeRelations(xml:XML, relations:Array<Dynamic>):Void {

			for (relation in relations) {

				var relationXml:XML = Xml.parse("<relation></relation>");

				relationXml.@id = relation.id;

				relationXml.@version = relation.version;

				relationXml.@changeset = changesetId;

				serializeMembers(relationXml, relation.members.source);

				serializeTags(relationXml, relation.tags.source);

				xml.appendChild(relationXml);

			}

		}

		function serializeMembers(xml:XML, members:Array<Dynamic>):Void {

			for (member in members) {

				var memberXml:XML = Xml.parse("<member/>");

				memberXml.@type = member.type;

				memberXml.@ref = member.elementId;

				memberXml.@role = member.role;

				xml.appendChild(memberXml);

			}

		}

		function serializeTags(xml:XML, tags:Array<Dynamic>):Void {

			var tagsXml:XMLList = tagsSerializer.serialize(tags);

			for (tagXml in tagsXml) {

				xml.appendChild(tagXml);

			}

		}

		function createTagsSerializer():IXMLListSerializer {

			var tagSerializer:IXMLSerializer = new TagExternalizer();

			var tagsSerializer:IXMLListSerializer = new ListExternalizer(tagSerializer, null);

			return new ValidTagsSerializer(tagsSerializer);

		} 

		function deserializeNodes(xml:XMLList):Array<Dynamic> {

			var nodes:Array<Dynamic> = new Array();

			var node:Node;

			xml.(

				node = new Node(@id, deserializeTags(elements("tag")), new LatLong(@lat, @lon)),

				node.version = @version,

				nodes.push(node)

			);

			return nodes;

		}

		function deserializeWays(xml:XMLList):Array<Dynamic> {

			var ways:Array<Dynamic> = new Array();

			var nodes:Array<Dynamic>;

			var way:Way;

			xml.(

				nodes = new Array(),

				nd.(nodes.push(nodeMap[@ref])),

				way = new Way(@id, deserializeTags(elements("tag")), nodes),

				way.version = @version,

				ways.push(way)

			);

			return ways;

		}

		function dererializeRelations(xml:XMLList):Array<Dynamic> {

			var relations:Array<Dynamic> = new Array();

			var members:Array<Dynamic>;

			var relation:Relation;

			xml.(

				members = deserializeRelationMembers(elements("member")),

				relation = new Relation(@id, deserializeTags(elements("tag")), members),

				relation.version = @version,

				relations.push(relation)

			);

			return relations;

		}

		function deserializeTags(xml:XMLList):Array<Dynamic> {

			var tags:Array<Dynamic> = new Array();

			xml.(tags.push(new Tag(@k, @v)));

			return tags;

		}

		function deserializeRelationMembers(xml:XMLList):Array<Dynamic> {

			var members:Array<Dynamic> = new Array();

			xml.(members.push(new Member(@ref, @type, @role)));

			return members;

		}

		function deserializeDiffs(xml:XMLList):Array<Dynamic> {

			var diffs:Array<Dynamic> = new Array();

			// Parse create or modify, but not delete.

			xml.(hasOwnProperty("@new_version")).

				(diffs.push(new ElementDiff(@old_id, @new_id, @new_version)));

			return diffs;

		}

		function setLoading(value:Bool):Void {

			if (value == _loading) return;

			_loading = value;

			dispatchEvent(new Event("loadingChanged"));

			/*if (value) {

				CursorManager.setBusyCursor();

			} else {

				CursorManager.removeBusyCursor();

			}*/

		}

		function endChangeset():Void {

			createdWays = new Array();

			modifiedWays = new Array();

			deletedWays = new Array();

			createdNodes = new Array();

			modifiedNodes = new Array();

			deletedNodes = new Array();

			modifiedRelations = new Array();

			_changesetOpened = false;

		}

		function mapLoader_completeHandler(event:Event):Void {

			var xml:XML = new XML(mapLoader.data);

			var nodes:Array<Dynamic> = deserializeNodes(xml.node);

			nodeMap = new Object();

			for (node in nodes) {

				nodeMap[node.id] = node;

			}

			var ways:Array<Dynamic> = deserializeWays(xml.way);

			var relations:Array<Dynamic> = dererializeRelations(xml.relation);

			dispatchEvent(new OSMProxyResultEvent(OSMProxyResultEvent.RESULT, nodes, ways, relations));

			setLoading(false);

		}

		function mapLoader_errorHandler(event:ErrorEvent):Void {

			setLoading(false);

			dispatchEvent(new OSMProxyLoadErrorEvent(OSMProxyLoadErrorEvent.LOAD_ERROR));

		}

		function openTransaction_completeHandler(event:Event):Void {

			changesetId = String(openTransaction.data);

			var xml:XML = new XML("<osmChange></osmChange>");

			var createXml:XML = new XML("<create></create>");

			serializeNodes(createXml, createdNodes);

			serializeWays(createXml, createdWays);

			xml.appendChild(createXml);

			var modifyXml:XML = new XML("<modify></modify>");

			serializeNodes(modifyXml, modifiedNodes);

			serializeWays(modifyXml, modifiedWays);

			serializeRelations(modifyXml, modifiedRelations);

			xml.appendChild(modifyXml);

			var deleteXml:XML = new XML("<delete></delete>");

			serializeWays(deleteXml, deletedWays);

			serializeNodes(deleteXml, deletedNodes);

			xml.appendChild(deleteXml);

			commitTransaction.requestData = xml.toXMLString();

			commitTransaction.url = changesetId + "/upload";

			closeTransaction.url = changesetId + "/close";

			CONFIG::debug {

				if (errorModeEnabled) {

					commitTransaction.requestData = commitTransaction.requestData.substr(1);

				}

			}

		}

		function transactionQueue_completeHandler(event:Event):Void {

			endChangeset();

			var xml:XML = new XML(commitTransaction.data);

			var nodeDiffs:Array<Dynamic> = deserializeDiffs(xml.node);

			var wayDiffs:Array<Dynamic> = deserializeDiffs(xml.way);

			var relationDiffs:Array<Dynamic> = deserializeDiffs(xml.relation);

			dispatchEvent(new OSMProxySaveEvent(OSMProxySaveEvent.SAVE_COMPLETE, changesetId));

			dispatchEvent(new OSMProxyResultEvent(OSMProxyResultEvent.SAVE, nodeDiffs, wayDiffs, relationDiffs));

		}

		function transactionQueue_ioErrorHandler(event:IOErrorEvent):Void {

			endChangeset();

			//Alert.show("httpStatus: " + lastHttpStatus);

			dispatchEvent(new OSMProxySaveEvent(OSMProxySaveEvent.SAVE_FAILED));

		}

		function transactionQueue_httpStatusHandler(event:HTTPStatusEvent):Void {

			lastHttpStatus = event.status;

		}

		function commitTransaction_ioErrorHandler(event:IOErrorEvent):Void {

			dispatchEvent(new OSMProxyCommitErrorEvent(OSMProxyCommitErrorEvent.COMMIT_ERROR, commitTransaction.requestData));

		}

	}