/**
 * @author Kingda.Sun 黑羽翔天
 * @version 1.5
 * @link http://www.kingda.org/
 */
class org.kingda.tools.EventSender {
	static var symbolName	:String = "EventSender";
	static var symbolOwner	:Object = org.kingda.tools.EventSender;
	public var className	:String = "EventSender";
	
	private var dispatchEvent : Function;
	public 	var addEventListener : Function;
	public	var removeEventListener : Function;
	
	private var eventQueue:Array;//	{type:String, listener:Object}
	private var deletedQueue:Array;
	
	private static var _instance:EventSender;
	public  static var debug:Boolean = false;
	
	function EventSender () {
		init();
	}
	
	// ==================== API below =========================
	
	public static function send(evtType:String, targetObj:Object):Void {
		getInstance().sendEvt(targetObj, evtType);
	}
	
	public static function dispatch(evtObj:Object):Void {
		getInstance().dispatchEvt(evtObj);
	}
	
	public static function addListener(evtType:String, lisObj:Object) {
		if (getInstance().searchInQueue(evtType, lisObj) != undefined) {
			getInstance().dtrace ("\r<<<< EventSender:!!!!Warning:\reventtype=" + evtType + " or listener=" + lisObj +" is already in the EventSender's queue\r\r");	
		}
		getInstance().addEventListener(evtType, lisObj);
		getInstance().addInQueue(evtType, lisObj);			
	}
	
	public static function removeListener(evtType:String, lisObj:Object) {
		if (getInstance().searchInQueue(evtType, lisObj) == undefined) {
			if(getInstance().searchInDeletedQueue(evtType, lisObj) == undefined) {
				getInstance().dtrace ("\r<<<< EventSender:!!!!Error:\reventtype=" + evtType + " or listener=" + lisObj +" is not in the EventSender's queue\r\r");
			} else {
				getInstance().dtrace ("\r<<<< EventSender:!!!!Warning:\reventtype=" + evtType + " or listener=" + lisObj +" is already removed\r\r");
			}			
				
		} else {
			getInstance().removeEventListener(evtType, lisObj);
			getInstance().removeFromQueue(evtType, lisObj);
		}
	}
	
	//abandoned: reserve to keep campatibility to old applications;
	public static function showQueue():Void {
		getInstance().show();		
	}
	
	public static function getQueue():Array {
		getInstance().show();
		return getInstance().eventQueue;
	}
	
	public static function removeEvents (evtType:String):Void {
		getInstance().removeListenersByEvent(evtType);
	}
	
	public static function removeListeners(lisObj:Object):Void {
		getInstance().removeListenersByListener(lisObj);
	}
	
	public static function reset():Void {
		getInstance().empty();
	}
	//==================== API above =========================
	
	public static function getInstance():EventSender {
		if (_instance == undefined) {
			_instance = new EventSender();
		}
		return _instance;
	}
	
	private function addInQueue(eventType:String, lisObject:Object) : Void {
		eventQueue.push({type:eventType, listener:lisObject});
	}
	
	private function show():Void {
		dtrace ("EventSender:==========all events and listeners ======");
		for (var i : Number = 0; i < eventQueue.length; i++) {
			dtrace ("No."+ i + "\t type:" + eventQueue[i].type + "\t\t listener:" + eventQueue[i].listener);
		}
		dtrace ("============ END ===============");
	}
	
	private function removeFromQueue(eventType:String, lisObject:Object) : Void {
		for (var i : Number = 0; i < eventQueue.length; i++) {
			if (eventQueue[i].type == eventType 
				&& eventQueue[i].listener == lisObject) {
					deletedQueue.push(eventQueue.splice(i,1)[0]);
					return;
			}
		}		
	}
	
	private function searchInQueue(eventType:String, lisObject:Object):Object {
		for (var i : Number = 0; i < eventQueue.length; i++) {
			if (eventQueue[i].type == eventType 
				&& eventQueue[i].listener == lisObject) {
					return eventQueue[i];
			}
		}	
	}
	
	private function searchInDeletedQueue(eventType:String, lisObject:Object):Object {
		for (var i : Number = 0; i < deletedQueue.length; i++) {
			if (deletedQueue[i].type == eventType 
				&& deletedQueue[i].listener == lisObject) {
					return deletedQueue[i];
			}
		}	
	}
	
	private function searchInDeletedQueueByListener(lisObject:Object):Number {
		var counter:Number = 0; 
		for (var i : Number = 0; i < deletedQueue.length; i++) {
			if (deletedQueue[i].listener == lisObject) {
					counter ++;
			}
		}
		return counter;
	}
	
	private function searchInDeletedQueueByEvent(eventType:String):Number {
		var counter:Number = 0; 
		for (var i : Number = 0; i < deletedQueue.length; i++) {
			if (deletedQueue[i].listener == eventType) {
					counter ++;
			}
		}
		return counter;
	}
	
		
	private function dispatchEvt(evtObj:Object):Void {
		dispatchEvent(evtObj);
	}
	
	private function sendEvt(sendObj:Object, evtType:String) {
		dispatchEvent({type:evtType, target:sendObj});
	}
	
	private function init() : Void {
		mx.events.EventDispatcher.initialize(this);
		eventQueue = new Array();
		deletedQueue = new Array();
	}
	
	private function removeListenersByEvent(eventType : String) : Void {
		var count:Number = 0;
		
		for (var i : Number = 0; i < eventQueue.length; i++) {
			if (eventQueue[i].type == eventType	) {
					this.removeEventListener(eventQueue[i].type, eventQueue[i].listener);
					deletedQueue.push(eventQueue.splice(i,1)[0]);
					i--;
			}
		}
		if(count == 0) {
			var deletedCount:Number = searchInDeletedQueueByEvent(eventType);
			if(deletedCount == 0) {
				dtrace ("\r<<<< EventSender:!!!!Error:\rEvent=" + eventType +" is not in the EventSender's queue\r\r");
			} else {
				dtrace ("\r<<<< EventSender:!!!!Warnging:\rEvent=" + eventType +" is not found this time!!\r this Event was removed" + deletedCount +" times before. please check again.\r\r");
			}
						
		} else {
			dtrace ("EventSender:==========found Event=" + eventType +":"+ count+ " times, and removed all of them  ======");
		}	
	}
	
	private function removeListenersByListener(lisObj : Object) : Void {
		var count:Number = 0;
		
		for (var i : Number = 0; i < eventQueue.length; i++) {
			if (eventQueue[i].listener == lisObj	) {
					this.removeEventListener(eventQueue[i].type, eventQueue[i].listener);
					deletedQueue.push(eventQueue.splice(i,1)[0]);
					i--;
					count++;
			}
		}
		if(count == 0) {
			var deletedCount:Number = searchInDeletedQueueByListener(lisObj);
			if(deletedCount == 0) {
				dtrace ("\r<<<< EventSender:!!!!Error:\rlistener=" + lisObj +" is not in the EventSender's queue\r\r");
			} else {
				dtrace ("\r<<<< EventSender:!!!!Warnging:\rlistener=" + lisObj +" is not found this time!!\r this Listener was removed" + deletedCount +" times before. please check again.\r\r");
			}
						
		} else {
			dtrace ("EventSender:==========found Listener=" + lisObj +":"+ count+ " times, and removed all of them  ======");
		}
			
	}
	
	private function empty():Void {
		var count:Number = eventQueue.length;
		for (var i : Number = 0; i < eventQueue.length; i++) {
			this.removeEventListener(eventQueue[i].type, eventQueue[i].listener);			
		}
		dtrace ("EventSender:==========all events and listeners are cleared. Total Number:" + count);
		eventQueue 		= new Array();
		deletedQueue 	= new Array();	
		
	}
	
	private function dtrace(msg:String):Void {
		if (debug == true) {
			trace (msg);
		}	
	}

}