package actionscript.as3.com.teknision.net.local.peernetwork
{
	
	import flash.events.*;
	import flash.net.*;
	import flash.utils.Timer;
	import com.finetune.gateway.events.*;
	
	public class LocalConnectionNetwork extends EventDispatcher{
		
		
//////////////////////////////////////////////////////////////////////
//PRIVATE PROPERTIES

		private var __id:Object=null;
		
		private var __networkname:String;
		private var __members:Array;
		
		private var __lc_host:LocalConnection;
		private var __lc_me:LocalConnection;
		private var __lc_reg:LocalConnection;
		
		
		private var __ishost:Boolean;
		
		//timers
		
		private var __startuptimer:Timer;
		private var __hostpoll:Timer;
		private var __registerpoll:Timer;
		
		
//////////////////////////////////////////////////////////////////////
//PUBLIC PROPERTIES


		public function get name():String{
			return this.__networkname;
		}
		
		public function get isHost():Boolean{
			return this.__ishost;
		}
		
		public function get id():Number{
			var u_id:Number=-1;
			if(this.__id!=null){
				u_id=this.__id as Number;
			}
			return u_id;
		}

//////////////////////////////////////////////////////////////////////
//CONSTRUCTOR

		public function LocalConnectionNetwork(name:String){
			this.__networkname=name;
			this.__members=new Array();
			
			__startuptimer=new Timer(3000);
			__startuptimer.addEventListener(TimerEvent.TIMER,handleStartupTimer);
			__startuptimer.start();
		}

		private function handleStartupTimer(event:TimerEvent):void{
			__startuptimer.stop();
			__startuptimer=null;
			attemptHost();
		}

//////////////////////////////////////////////////////////////////////


		public function close(){
			this.__lc_me.close();
			this.__lc_host.close();
		}
		
		
		public function allowLCDomains(sendingDomain:String):Boolean{
			return true;
		}

//////////////////////////////////////////////////////////////////////


		private function getHostName():String{
			var str:String="_"+this.name+"_host";
			return str;
		}
		
		
		private function getSOName():String{
			var str:String="LCNetwork."+this.name;
			return str;
		}

		private function getMyLCName():String{
		var str="_"+this.name+"_"+this.id+"_lc";
		return str;
	}
	
		private function getOtherLCName(id:Number):String{
			var str:String="_"+this.name+"_"+id+"_lc";
			return str;
		}
		
		private function getRegisterLCName():String{
			var str:String="_"+this.name+"_register_lc";
			return str;
		}
		
		private function initRegisterConnection():void{
			
			if(this.__registerpoll!=null){
				this.__registerpoll.stop();
			}
			
			if(this.__lc_reg==null){
				
				this.__lc_reg=new LocalConnection();
				this.__lc_reg.addEventListener(StatusEvent.STATUS,handleLCStatus);
				this.__lc_reg.addEventListener(SecurityErrorEvent.SECURITY_ERROR,handleSecurityError);
				this.__lc_reg.allowDomain("*");
				
				var i_conn:Boolean=true;
				trace("ATTEMPTING LCN REGISTER");
				try{
					this.__lc_reg.connect(this.getRegisterLCName());
				}catch(e:Error){
					i_conn=false;
				}
				
				if(i_conn){		
					var lc_client:LocalConnectionNetworkClient=new LocalConnectionNetworkClient();
					this.__lc_reg.client=lc_client;
					lc_client.addEventListener(LCNCRecieveIDEvent.RECIEVE_ID,recieveID);
					this.askForMembers();
					
				}else{
					this.__lc_reg=null;
					__registerpoll=new Timer(2000);
					__registerpoll.addEventListener(TimerEvent.TIMER,handleRegisterPoll);
					this.__registerpoll.start();
				}
			}
			
		}
		
		
		private function handleRegisterPoll(event:TimerEvent):void{
			this.__registerpoll.stop();
			this.__registerpoll=null;
			initRegisterConnection();
		}
		
		private function initMyConnection():void{
			this.__lc_me=new LocalConnection();
			this.__lc_me.addEventListener(StatusEvent.STATUS,handleLCStatus);
			this.__lc_me.addEventListener(SecurityErrorEvent.SECURITY_ERROR,handleSecurityError);
			this.__lc_me.allowDomain("*");
			//trace("OPENING MY CONNECTION AS:"+this.getMyLCName());
			
			try{
				var i_conn=this.__lc_me.connect(this.getMyLCName());
			}catch(e:Error){
				trace("Error Opening My Connection");
			}
			
			var lc_client:LocalConnectionNetworkClient=new LocalConnectionNetworkClient();
			lc_client.addEventListener(LCNCRecieveMembersEvent.RECIEVE_MEMBERS,recieveMembers);
			lc_client.addEventListener(LCNCRecieveEvent.RECIEVE_EVENT,recieveEvent);
			this.__lc_me.client=lc_client;
		}
		
	//////////////////////////////////////////////////////////////////////////	
		
		private function startHostPoll(){
			if(this.__hostpoll!=null){
				this.__hostpoll.stop();
			}
			this.__hostpoll=new Timer(30000);
			this.__hostpoll.start();
		}
		
		private function handleHostPoll(event:TimerEvent):void{
			this.__hostpoll.stop();
			attemptHost();
		}
		
		
		private function getNextID():Number{
			var nnum:Number=0;
			if(this.__members.length>0){
				this.__members.sort(Array.NUMERIC);
				nnum=this.__members[this.__members.length-1]+1;
			}
			return nnum;
		}
		
		private function sortNumeric(a, b):Number {
			var max:Number=Math.max(a,b);
			if(max==a){
				return -1;
			}else{
				return 1;
			}
		}
	
		
		private function attemptHost():void{
			if(this.__ishost!=true){
				this.__lc_host=new LocalConnection();
				this.__lc_host.addEventListener(StatusEvent.STATUS,handleLCStatus);
				this.__lc_host.addEventListener(SecurityErrorEvent.SECURITY_ERROR,handleSecurityError);
				this.__lc_host.allowDomain("*");
				
				this.__ishost=true;
				
				try{
					this.__lc_host.connect(this.getHostName());
				}catch(e:Error){
					this.__ishost=false;
				}
				
				if(this.__ishost){
					
					var lc_client:LocalConnectionNetworkClient=new LocalConnectionNetworkClient();
					lc_client.addEventListener(LCNCRegisterEvent.REGISTER,registerMember);
					lc_client.addEventListener(LCNCRecieveEvent.RECIEVE_EVENT,recieveEvent);
					lc_client.addEventListener(LCNCRecieveHostEvent.RECIEVE_HOST_EVENT,recieveHostEvent);
					
					this.__lc_host.client=lc_client;
					
					if(this.__id==null){
						this.__id=this.getNextID();
						this.__members.push(this.id);
						
						var ev:LCNConnectEvent=new LCNConnectEvent();
						ev.ishost=true;	
						this.dispatchEvent(ev);
					}
					trace("IS LCN HOST:"+this.__id);
					this.broadcastMembers();
				}else{
					trace("IS NOT LCN HOST");
					if(this.__id==null){
						this.initRegisterConnection();
					}
				}
			}else{
				this.broadcastMembers();
			}
			
			
			this.startHostPoll();
		}
		
		
		
		private function auditAsHost(){
			this.broadcastMembers();
		}
		
	
	
	//////////////////////////////////////////////////////////////////////////
	
		public function sendEvent(data:Object):void{
			try{
			this.attemptHost();
			var transmission:Object={sender:this.id,data:data};
			if(this.isHost){
				this.sendHostEvent(transmission);
			}else{
				this.__lc_me.send(this.getHostName(),"recieveHostEvent",transmission);
			}
			}catch(e:Error){
				trace("LCNetwork Error:"+e.message);
			}
		}
		
		public function sendHostEvent(data:Object):void{
			if(this.isHost){
				this.auditAsHost();
				
				var members:Array=this.__members;
				for(var i=0;i<members.length;i++){
					var member:Number=members[i] as Number;
					
					if(member!=data.sender && member!=this.id){
						var con_name:String=this.getOtherLCName(member);
						this.__lc_host.send(con_name,"recieveEvent",data);
					}
					
				}
			}
		}
		
		
		
		public function recieveEvent(event:LCNCRecieveEvent):void{
			var finalevent:Object=event.data;
			this.processEvent(finalevent);
		}
		
		private function processEvent(data:Object):void{
			var finalevent:Object=data;
			if(finalevent.sender!=this.id){
				var ev:LCNOnEventEvent=new LCNOnEventEvent();
				ev.data=finalevent;	
				this.dispatchEvent(ev);
			}
		}
		
		public function recieveHostEvent(event:LCNCRecieveHostEvent):void{
			var finalevent:Object=event.data
			if(this.isHost){
				this.sendHostEvent(finalevent);
				this.processEvent(finalevent);
			}
		}
	
	
	//////////////////////////////////////////////////////////////////////////
	//non-host
		
		public function askForMembers():void{
			trace("ASKING FOR LCN MEMBERS:"+this.id);
			this.__lc_reg.send(this.getHostName(),"registerMember",this.__id);
		}
		
		public function recieveMembers(event:LCNCRecieveMembersEvent){
			//trace("GOT MEMBERS:"+event.members.length);
			for(var i:uint=0;i<event.members.length;i++){
				//trace("	member:"+event.members[i]);
			}
			this.__members=event.members;
		}
		
		public function recieveID(event:LCNCRecieveIDEvent):void{
			
			this.__lc_reg.client.removeEventListener(LCNCRecieveIDEvent.RECIEVE_ID,recieveID);
			
			trace("GOT MY ID:"+event.id);
			this.__id=event.id;
			this.__lc_reg.close();
			this.initMyConnection();
			
			var ev:LCNConnectEvent=new LCNConnectEvent();
			ev.ishost=false;	
			this.dispatchEvent(ev);
		}
	
	
	//////////////////////////////////////////////////////////////////////////
	//host
	
		public function registerMember(ev:LCNCRegisterEvent):void{
			
			var i_id:Number=ev.id;
			
			if(i_id<=0){
				i_id=this.getNextID();
			}
			
			trace("REGISTERING MEMBER WITH HOST:"+i_id);
			
			this.addMember(i_id);
			this.broadcastMembers();
		}
		
		private function addMember(i_id:Number=-1):void{
			trace("ADDING MEMBER:"+this.hasMember(i_id));
			if(this.hasMember(i_id)==false){
				this.__members.push(i_id);
				trace("SENDing Back ID:"+i_id);
				this.__lc_host.send(this.getRegisterLCName(),"recieveID",i_id);
			}
		}
		
		private function hasMember(i_id:Number=-1):Boolean{
			for(var i=0;i<this.__members.length;i++){
				if(i_id==this.__members[i]){
					return true;
				}
			}
			return false;
		}
	
		private function broadcastMembers():void{
			trace("Broadcasting members");
			var members=this.__members;
			for(var i=0;i<members.length;i++){
				var member=members[i];
				if(member!=this.id){
					var con_name:String=this.getOtherLCName(member);
					trace("	members to:"+con_name);
					this.__lc_host.send(con_name,"yourMembersMadamme",this.__members);
				}
			}
		}
		
		
		
		private function handleSecurityError(event:SecurityErrorEvent):void{
			trace("LC SECURITY:"+event.text);
		
		}
	
		
		
		private function handleLCStatus(event:StatusEvent):void{
			trace("LC STATUS:"+event.level+":");
		
		}


//////////////////////////////////////////////////////////////////////
		
		
	}
}