package net.davidtucker.air.update {
	
	import com.adobe.serialization.json.JSONDecoder;
	
	import flash.desktop.NativeApplication;
	import flash.desktop.Updater;
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.HTTPStatusEvent;
	import flash.events.IOErrorEvent;
	import flash.events.SecurityErrorEvent;
	import flash.filesystem.File;
	import flash.filesystem.FileMode;
	import flash.filesystem.FileStream;
	import flash.net.URLLoader;
	import flash.net.URLRequest;
	import flash.net.URLStream;
	import flash.net.URLVariables;
	import flash.utils.ByteArray;
	
	import net.davidtucker.air.update.events.*;
	
	[Event(name="updateAvailable", type="net.davidtucker.air.events.UpdateManagerResultEvent")]
	[Event(name="applicationCurrent", type="net.davidtucker.air.events.UpdateManagerResultEvent")]
	[Event(name="updateFault", type="net.davidtucker.air.events.UpdateManagerFaultEvent")]
	[Event(name="applicationNotFound", type="net.davidtucker.air.events.UpdateManagerFaultEvent")]

	public class UpdateManager extends EventDispatcher {
		
		public static const UPDATE_AVAILABLE:uint = 1;
		public static const APPLICATION_NOT_FOUND:uint = 2;
		public static const APPLICATION_CURRENT:uint = 3;
		
		private var _updateServer:String;
		private var _applicationID:String;
		private var _applicationName:String;
		private var _applicationVersion:String;		
		private var _update:AIRUpdate;

		private var loader:URLLoader;
		private var urlStream:URLStream;
		private var updateFileData:ByteArray;
		private var updateFile:File;
		
		private var _autoCheck:Boolean;
		
		public function set autoCheck(val:Boolean):void {
			_autoCheck = val;
		}
		
		public function get autoCheck():Boolean {
			return _autoCheck;
		}
		
		public function UpdateManager(server:String,autoCheck:Boolean=false):void {
			
			// Set Server
			_updateServer = server;
			
			// Set Autocheck
			_autoCheck = autoCheck;
			
			// Get Application Information
			var appXML:XML = NativeApplication.nativeApplication.applicationDescriptor;
			
			// Set AIR Namespace
			var air:Namespace = appXML.namespaceDeclarations()[0];
			
			// Set the Application Information Values
			_applicationID = appXML.air::id;
			_applicationVersion = appXML.air::version;
			_applicationName = appXML.air::name;
						
			super();
			
			// Check if autoCheck
			if(_autoCheck) {
				check();
			}
			
		}
		
		public function check():void {
			
			loader = new URLLoader();
			loader.addEventListener(Event.COMPLETE,onResult);
			loader.addEventListener(IOErrorEvent.IO_ERROR,onFault);
			loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR,onSecurityError);
			loader.addEventListener(HTTPStatusEvent.HTTP_STATUS,onHTTPStatus);
			var request:URLRequest = new URLRequest(_updateServer);
			var params:URLVariables = new URLVariables();
			params.method = "getUpdateJSON";
			params.applicationID = _applicationID;
			params.currentVersion = _applicationVersion;
			request.data = params;
			request.method = "GET";
			
			loader.load(request);
			
		}
		
		private function onHTTPStatus(e:HTTPStatusEvent):void {
			
			if(e.status != 200) {
				this.dispatchEvent( new UpdateManagerFaultEvent(UpdateManagerFaultEvent.UPDATE_FAULT,'HTTP Status Error: ' + e.status) );
			}
			
		}
		
		private function onSecurityError(e:SecurityErrorEvent):void {
			
			this.dispatchEvent( new UpdateManagerFaultEvent(UpdateManagerFaultEvent.UPDATE_FAULT,'Security Error: ' + e.errorID) );
			
		}
		
		private function onFault(e:IOErrorEvent):void {
			
			this.dispatchEvent( new UpdateManagerFaultEvent(UpdateManagerFaultEvent.UPDATE_FAULT,'IOError: ' + e.errorID) );
			
		}
		
		private function onResult(e:Event):void {
			
			if(e.target.data) {
				
				var result:Object = new JSONDecoder(e.target.data).getValue();
				switch(result.UPDATECODE) {
					
					case UpdateManager.UPDATE_AVAILABLE:
						_update = new AIRUpdate(result.UPDATEINFO);
						dispatchEvent( new UpdateManagerResultEvent(UpdateManagerResultEvent.UPDATE_AVAILABLE,_update) );
						break;
						
					case UpdateManager.APPLICATION_NOT_FOUND:
						dispatchEvent( new UpdateManagerFaultEvent(UpdateManagerFaultEvent.APPLICATION_NOT_FOUND,"Application Not in Database") );
						break;
						
					case UpdateManager.APPLICATION_CURRENT:
						dispatchEvent( new UpdateManagerResultEvent(UpdateManagerResultEvent.APPLICATION_CURRENT) );
						break;
					
				}
			
			}
			
		}
		
		public function update():void {
			
			if(this._update.updateURL != null) {			
				var request:URLRequest = new URLRequest(_update.updateURL);
				urlStream = new URLStream();
				updateFileData = new ByteArray();
				urlStream.addEventListener(Event.COMPLETE, onStreamComplete);
				urlStream.load(request);
			} else {
				trace("No Update Available");
			}
			
		}

		private function onStreamComplete(event:Event):void {
			
			urlStream.readBytes(updateFileData, 0, urlStream.bytesAvailable);
			writeUpdateFile();
			
		}

		private function writeUpdateFile():void {
			
			updateFile = File.applicationStorageDirectory.resolvePath("Update.air");
			var fileStream:FileStream = new FileStream();
			fileStream.addEventListener(Event.CLOSE, performUpdate);
			fileStream.openAsync(updateFile, FileMode.WRITE);
			fileStream.writeBytes(updateFileData, 0, updateFileData.length);
			fileStream.close();
			
		}
	
		private function performUpdate(event:Event):void {
			
			var updater:Updater = new Updater();
			updater.update(updateFile,_update.updateVersion);
			
		}
		
	}
}