//
// Licensed under the MIT License
//
// Copyright (C) 2008  TAKANAWA Tomoaki (http://nutsu.com) and
//					   Spark project (www.libspark.org)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//

package snapfit.events
{
	import flash.events.IEventDispatcher;
	use namespace ns_fadapter;
	
	/**
	* Abstract Static Adapter
	* @author nutsu
	* @version 0.2
	*/
	public class FAbstractFixAdapter implements IAdapter
	{
		private var _adapter:FAdapter;
		
		public function FAbstractFixAdapter( dispatcher_:IEventDispatcher ) 
		{
			_adapter = new FAdapter( dispatcher_ );
		}
		
		public function get dispatcher():IEventDispatcher { return _adapter.dispatcher; }
		public function set dispatcher( value:IEventDispatcher ):void 
		{
			_adapter.dispatcher = value;
		}
		
		public function get adapter():FAdapter
		{
			return _adapter;
		}
		
		/**
		 * Inject Event Handler
		 * 
		 * value:Function
		 * value:makeListenerInfo()
		 * value:null ( remove )
		 * value:Boolean ( abort, resume )
		 * 
		 * @param	eventType
		 * @param	value
		 */
		protected function inject( eventType:String, value:* ):void
		{
			if ( value is $listenerInfo )
			{
				_adapter.addEventListener( eventType, value.handler, value.useCapture, value.priority, value.useWeakReference );
			}
			else
			{
				try 
				{
					_adapter[eventType] = value;
				}
				catch (e:Error)
				{
					throw new TypeError("FAbstractFixAdapter : Type Error");
				}
			}
		}
		
		protected function getlistener( eventType:String ):*
		{
			return _adapter[eventType];
		}
		
		public function bind( target:* ):void
		{
			;
		}
		
		protected function bindHandlers( target:*, ...handlerNames ):void
		{
			for each( var handlerName:String in handlerNames )
			{
				try
				{
					if ( target[handlerName] is Function )
						this[handlerName] = target[handlerName];
				}
				catch ( e:Error )
				{
					try
					{
						if ( target.ns_fadapter::[handlerName] is Function )
							this[handlerName] = target.ns_fadapter::[handlerName];
					}
					catch ( e:Error )
					{
						;
					}
				}
			}
		}
		
		/**
		 * @see FAdapterCheckResult
		 */
		public function check( eventType:String ):int
		{
			return _adapter.check( eventType );
		}
		
		public function abort( eventType:String=null ):void
		{
			_adapter.abort( eventType );
		}
		
		public function resume( eventType:String=null ):void
		{
			_adapter.resume( eventType );
		}
		
		public function removeAll():void
		{
			_adapter.removeAll();
		}
		
		public function getTypes( active_kind:int=-1 ):Array
		{
			return _adapter.getTypes();
		}
		
		public function oneTime( lo:* ):Boolean
		{
			return FAdapter.oneTime( lo );
		}
		
		public function filter( lo:*, filterfunc:Function, remove:Boolean = false ):Boolean
		{
			return FAdapter.filter( lo, filterfunc, remove );
		}
		
		public function clearFilter( lo:* ):Boolean
		{
			return FAdapter.clearFilter( lo );
		}
		
		public function makeListenerInfo( handler:Function, useCapture:Boolean=false, priority:int=0, useWeakReference:Boolean=false ):$listenerInfo
		{
			return new $listenerInfo( handler, useCapture, priority, useWeakReference );
		}
	}
}

class $listenerInfo
{
	public var handler:Function;
	public var useCapture:Boolean;
	public var priority:int;
	public var useWeakReference:Boolean;	
	
	public function $listenerInfo( handler_:Function, useCapture_:Boolean, priority_:int, useWeakReference_:Boolean ) 
	{
		handler          = handler_;
		useCapture       = useCapture_;
		priority         = priority_;
		useWeakReference = useWeakReference_;
	}
}