package {
	import flash.display.Sprite;

	import mx.rpc.events.FaultEvent;
	import mx.rpc.events.ResultEvent;
	import mx.messaging.ChannelSet;
	import mx.messaging.Channel;
	import mx.messaging.channels.AMFChannel;
	import mx.messaging.events.*;
	import mx.rpc.remoting.RemoteObject;
	import mx.core.mx_internal;
	import mx.messaging.config.LoaderConfig; 

	import mx.logging.targets.TraceTarget;

	import mx.messaging.messages.*;
	import mx.messaging.config.ConfigMap;
	import mx.collections.ArrayList;
	import mx.collections.ArrayCollection;
	import mx.utils.ObjectProxy;
	import flash.net.registerClassAlias;
	
	public class Main extends Sprite {
		
		public function Main():void {
			//mx.messaging.messages.Message implementations have not called flash.net.registerClassAlias() for each of their types
			//Thanks Peter Farland 
			//http://www.adobeforums.com/webx/?13@618.wIQPiTpvUo4@.59b6384e/0
			registerClassAlias("flex.messaging.messages.CommandMessage",CommandMessage);
			registerClassAlias("flex.messaging.messages.RemotingMessage",RemotingMessage);
			registerClassAlias("flex.messaging.messages.AcknowledgeMessage", AcknowledgeMessage);
			registerClassAlias("flex.messaging.messages.ErrorMessage",ErrorMessage);
			registerClassAlias("DSC", CommandMessageExt);
			registerClassAlias("DSK", AcknowledgeMessageExt);
			registerClassAlias("flex.messaging.io.ArrayList", ArrayList);
			registerClassAlias("flex.messaging.config.ConfigMap",ConfigMap);
			registerClassAlias("flex.messaging.io.ArrayCollection",ArrayCollection);
			registerClassAlias("flex.messaging.io.ObjectProxy",ObjectProxy);
			registerClassAlias("flex.messaging.messages.HTTPMessage",HTTPRequestMessage);
			registerClassAlias("flex.messaging.messages.SOAPMessage",SOAPMessage);
			registerClassAlias("flex.messaging.messages.AsyncMessage",AsyncMessage);
			registerClassAlias("DSA", AsyncMessageExt);
			registerClassAlias("flex.messaging.messages.MessagePerformanceInfo", MessagePerformanceInfo);
			
			//Sets up some more descriptive tracing on the client
			var target:TraceTarget = new TraceTarget();
			target.level = 0;
			
			//This is needed so the Flex libraries have access to the root objects properties
			var swfURL:String = this.loaderInfo.url;
			LoaderConfig.mx_internal::_url = this.loaderInfo.url;
			LoaderConfig.mx_internal::_parameters = this.loaderInfo.parameters;
			
			//This is the channel definition
			//This tells RemoteObject where to go
			var amfChannel:AMFChannel = new AMFChannel("my-amf", "http://localhost:8400/samples/messagebroker/amf");
			amfChannel.requestTimeout = 3;
			amfChannel.connectTimeout = 3;
			var channelSet:ChannelSet = new ChannelSet();
			channelSet.addChannel( amfChannel );
			
			amfChannel.addEventListener(ChannelFaultEvent.FAULT, handleChannelFault);
			amfChannel.addEventListener(ChannelEvent.CONNECT, handleChannelConnect);
			amfChannel.addEventListener(ChannelEvent.DISCONNECT, handleChannelDisconnect);
			
			//Make sure you include the right RemoteObject at 
			//import mx.rpc.remoting.RemoteObject;
			//not
			//import  mx.rpc.remoting.mxml.RemoteObject;
			var ro:RemoteObject = new RemoteObject();
			//ro.destination must be set to destination id of the class you want to execute that youve defined in remoting-config.xml
			ro.destination = "product";
			ro.channelSet = channelSet;
			ro.addEventListener(ResultEvent.RESULT, onResult);
            ro.addEventListener(FaultEvent.FAULT, onFault);
			//The operation is literally the method on the class defined in definition
			ro.getOperation("getProducts").send();
			//or you can do
			//ro.getProducts();
			trace("----Finished----");
        }
      
		//Everything is async so we need event handlers to handle responces, errors etc...
        private function onResult(e:ResultEvent):void {
			trace("RPC Ok");
            trace(e.result);
			var index:int;
			for each (var obj:Object in e.result) {
				trace("-----Item "+index++);
				for each (var item:Object in obj) {
					trace(item);
				}
			}
        }
      
        private function onFault(e:FaultEvent):void {
			trace("RPC Fail");
            trace(e.message);
        }

		public function handleChannelFault(e:ChannelFaultEvent):void {
		    trace("Channel Fault");
			trace(e);
		}		
		
		public function handleChannelConnect(e:ChannelEvent):void {
		    trace("Channel Connect");
			trace(e);
		}
		
		public function handleChannelDisconnect(e:ChannelEvent):void {
		    trace("Channel Disconnect");
			trace(e);
		}
		
	}
}