////////////////////////////////////////////////////////////////////////////////
//
//  Licensed to the Apache Software Foundation (ASF) under one or more
//  contributor license agreements.  See the NOTICE file distributed with
//  this work for additional information regarding copyright ownership.
//  The ASF licenses this file to You under the Apache License, Version 2.0
//  (the "License"); you may not use this file except in compliance with
//  the License.  You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
//
////////////////////////////////////////////////////////////////////////////////

package mx.automation
{
import flash.display.DisplayObject;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.system.ApplicationDomain;
import flash.utils.describeType;
import flash.utils.getQualifiedClassName;

import mx.core.mx_internal;
import mx.managers.ISystemManager;
import mx.managers.SystemManagerProxy;
import mx.utils.ObjectUtil;

use namespace mx_internal;

/**
 * Provides serializable class information for external automation tools.
 * Some classes are represented as the same AutomationClass (HSlider and VSlider, forinstance).
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */

public class AutomationClass implements IAutomationClass2
{
	//--------------------------------------------------------------------------
	//
	//  Constructor
	//
	//--------------------------------------------------------------------------

    public function AutomationClass(name:String, superClassName:String = null)
    {
		super();

        _name = name;
        _superClassName = superClassName;
    }

	//--------------------------------------------------------------------------
	//
	//  Variables
	//
	//--------------------------------------------------------------------------

    /**
	 *  @private
	 */
    private var _implementationClassNames:Array = [];
    
    /**
	 *  @private
	 */
	private var _properties:Array = [];
	
    /**
	 *  @private
	 */
	private var _verificationProperties:Array = [];
	
    /**
	 *  @private
	 */
	private var _descriptionProperties:Array = [];
	
    /**
	 *  @private
	 */
	private var _event2descriptor:Object = {};
    
    /**
	 *  @private
	 */
	private var _method2descriptor:Object = {};
    
    /**
	 *  @private
	 */
	private var _propertyASTypesInitialized:Boolean = false;
	
	
	//--------------------------------------------------------------------------
	//
	//  Properties
	//
	//--------------------------------------------------------------------------

	//----------------------------------
	//  name
	//----------------------------------

    /**
	 *  @private
	 */
    private var _name:String;

    /**
	 * the class name
	 *  
	 *  @langversion 3.0
	 *  @playerversion Flash 9
	 *  @playerversion AIR 1.1
	 *  @productversion Flex 3
	 */
    public function get name():String
    {
        return _name;
    }

	//----------------------------------
	//  superClassName
	//----------------------------------

    /**
	 *  @private
	 */
    private var _superClassName:String;

    /**
	 * The name of the class's superclass.
	 *  
	 *  @langversion 3.0
	 *  @playerversion Flash 9
	 *  @playerversion AIR 1.1
	 *  @productversion Flex 3
	 */
    public function get superClassName():String
    {
        return _superClassName;
    }
    
    //----------------------------------
	// previousVersionClassNames
	//----------------------------------
    
    /**
	 *  @private
	 */
	private var _previousVersionClassNames:Array = [];
	
	/**
     * An array of names of the classes that are compatible with current class.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 4
     */
    public function get previousVersionClassNames():Array
    {
    	return _previousVersionClassNames;
    }
    
    /**
     *  @private
     */
    public function set previousVersionClassNames(value:Array):void
    {
    	_previousVersionClassNames = value;
    } 
    
    /**
	 *  @private
	 */
	private var _implementationVersion:int = 0;
	
	/**
     * @inheritDoc
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 4
     */
    public function get implementationVersion():int
    {
    	return _implementationVersion;
    }
    
    /**
     *  @private
     */
    public function set implementationVersion(value:int):void
    {
    	_implementationVersion = value;
    } 
    
    /**
	 *  @private
	 *  A map of property name to property descriptor.
	 *  Useful in getting the descriptor based on property names.
	 */
	private var _propertyNameMap:Object = {};
 
	//--------------------------------------------------------------------------
	//
	//  Methods
	//
	//--------------------------------------------------------------------------

    /**
	 * Add Flex class names which match this class description.
	 *
	 * @param className the name of the Flex class
	 *  
	 *  @langversion 3.0
	 *  @playerversion Flash 9
	 *  @playerversion AIR 1.1
	 *  @productversion Flex 3
	 */
    public function addImplementationClassName(className:String):void
    {
        _implementationClassNames.push(className);
    }

    /**
	 * @private
	 * Add a property descriptor to the class object
	 */
    public function addPropertyDescriptor(p:IAutomationPropertyDescriptor):void
    {
        _properties.push(p);
        if (p.forVerification)
	        _verificationProperties.push(p);
	    
	    if (p.forDescription)
	      	_descriptionProperties.push(p);
	            	
	    _propertyNameMap[p.name] = p;
    }

    /**
	 * @inheritDoc
	 *  
	 *  @langversion 3.0
	 *  @playerversion Flash 9
	 *  @playerversion AIR 1.1
	 *  @productversion Flex 3
	 */
    public function getPropertyDescriptors(objForInitialization:Object = null,
                                           forVerification:Boolean = true,
                                           forDescription:Boolean = true):Array
    {
        // This is for nested app support. Since a component may not be loaded
        // until the sub-app is loaded, we need to delay accessing any
        // Class or describeType info until we have an instance who's loaderInfo
        // we can use. This assumes that objForInitialization is the type we need
        if (!_propertyASTypesInitialized && objForInitialization != null)
        {
            _propertyASTypesInitialized = true;
            
            var dt:XML = describeType(objForInitialization);
            
            //dt shouldn't be null when it gets here
            fillInASTypesFromProperties(dt, _properties);
		}
		
		var result:Array = [];
        if (forVerification && forDescription)
        	result = _properties;
        else if (forVerification)
        	result = _verificationProperties;
        else if (forDescription)
        	result = _descriptionProperties;
        	
       	return result;
    }
    
    /**
	 * @private
	 */
	public function addMethod(m:IAutomationMethodDescriptor):void
    {
        var hash:String = m.name;
                            
        _method2descriptor[hash] = m;
    }

    /**
	 * @private
	 */
	public function addEvent(m:IAutomationEventDescriptor):void
    {
        var hash:String = hash(m.eventClassName, m.eventType);
                            
        _event2descriptor[hash] = m;
    }

    /**
     *  Translates between component event and Automation method descriptor
     *
     *  @param event The event object for which a method descrptor is required.
	 *
     *  @return The method descriptor for the event passed if one is available. 
     *          Otherwise null.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function getDescriptorForEvent(
						event:Event):IAutomationEventDescriptor
    {
        var eventType:String = event.type;
        if (event is KeyboardEvent)
            eventType = "keyPress";
        var eventClassName:String = getClassName(event);
        var hash:String = hash(eventClassName, eventType);
        return hash in _event2descriptor ? _event2descriptor[hash] : null;
    }

     /**
      * Returns a full methodDescriptor from its name
      *
      *  @param methodName The method name for which the descriptor is required.
      *
      *  @return The method descriptor for the name passed if one is available. 
      *          Otherwise null.
      *  
      *  @langversion 3.0
      *  @playerversion Flash 9
      *  @playerversion AIR 1.1
      *  @productversion Flex 3
      */
    public function getDescriptorForMethodByName(
						methodName:String):IAutomationMethodDescriptor
    {
        for (var i:Object in _method2descriptor)
        {
            if (_method2descriptor[i].name == methodName)
                return _method2descriptor[i];
        }

        return null;
    }

    public function getDescriptorForEventByName(
						eventName:String):IAutomationEventDescriptor
    {
        for (var i:Object in _event2descriptor)
        {
            if (_event2descriptor[i].name == eventName)
                return _event2descriptor[i];
        }

        return null;
    }
    
    /**
	 * Returns the fully qualified name of the class to which the object belongs.
	 *  
	 * @param obj The object whose class name is desired
	 * 
	 * @return Fully qualified name of the class
	 * 
	 *  
	 *  @langversion 3.0
	 *  @playerversion Flash 9
	 *  @playerversion AIR 1.1
	 *  @productversion Flex 3
	 */
    public static function getClassName(obj:Object):String
    {
    	return getQualifiedClassName(obj).replace("::", ".");
    }
    
    /**
     * Returns the major from current version number
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 4
     */
    public static function getMajorVersion():String
    {
    	return AutomationManager.VERSION.charAt(0);
    }  

	private static function getRootForThePopupObject(obj:DisplayObject):ISystemManager
	{
		var requiredSystemManager:ISystemManager = null;
		
		if(obj)
		{
			var objFound:Boolean = false;
		 	while((!objFound) && (obj.parent))
	    	{
	    		if(obj.parent is SystemManagerProxy)
	    		{
	    			requiredSystemManager = obj.parent.hasOwnProperty("systemManager")?obj.parent["systemManager"]:null;
	    			objFound = true;
	    		}
	    		obj = obj.parent;
	    	}
  		}
    	return requiredSystemManager;
	}
	
    /**
     *  Utility function that returns the class definition from the domain of a
     *  object instance
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public static function getDefinitionFromObjectDomain(obj:Object, className:String):Class
    {
		var eventClass:Class ;
		try
		{
			var dispObj:DisplayObject = obj as DisplayObject;
			
			// if the object is related to Popup's we need to get the application domain
			// from where the object is created. the root of the object here will corresponds to
			// the main application hence we getting the defintion from the main appl will not be correct
			var systemmanager:ISystemManager = getRootForThePopupObject(dispObj);
			
			if(systemmanager != null)
				eventClass = Class(systemmanager.loaderInfo.applicationDomain.getDefinition(className));
			else
				eventClass = Class(dispObj.root.loaderInfo.applicationDomain.getDefinition(className));
		}
		catch(e:Error)
		{
			// we can get a reference or security exception
			// in which case we try to access the objects own domain
			try
			{
				eventClass = Class(ApplicationDomain.currentDomain.getDefinition(className));
			}
			catch(e:Error)
			{
				// we can get a reference or security exception

				// In this case we assume that the class definition is not available
				// as the class has not been referenced in the app and it has 
				// not been linked in.
			}
		}

		return eventClass;		
    }

    /**
     *  Fills in the AS types for the provided propertyDescriptors based
     *  on the information provided in the describeType XML.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public static function fillInASTypesFromProperties(
								dtForClass:XML, 
                                propertyDescriptors:Array):void
    {
		// If DT was on a Class, we need to go to the factory node instead
		var isFactory:Boolean = dtForClass.hasOwnProperty("factory");
		var dtListForClass:XML = isFactory ? dtForClass.factory[0] : dtForClass;

        for (var propNo:int = 0; propNo < propertyDescriptors.length; ++propNo)
        {
		    // First try a property.
		    var propASTypeXML:XMLList = 
                dtListForClass.variable.(@name == propertyDescriptors[propNo].name);
		    
		    // If not there try an accessor.
		    if (propASTypeXML.length() == 0)
			    propASTypeXML = dtListForClass.accessor.
								(@name == propertyDescriptors[propNo].name);
    		
		    propertyDescriptors[propNo].asType = propASTypeXML.length() > 0 ?
												 propASTypeXML[0].@type.toString() :
												 null;
        }
    }

    /**
     *  Fills in the AS types for the provided propertyDescriptors based
     *  on the information provided in the describeType XML.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public static function fillInASTypesFromMethods(dtForClass:XML, 
                                                    methodName:String,
                                                    argDescriptors:Array):void
    {
		// If DT was on a Class, we need to go to the factory node instead
		var isFactory:Boolean = dtForClass.hasOwnProperty("factory");
		var dtListForClass:XML = isFactory ? dtForClass.factory[0] : dtForClass;

		var propMethodXML:XMLList = 
            dtListForClass.method.(@name == methodName);

        if (propMethodXML != null)
        {
            for (var argNo:int = 0; argNo < argDescriptors.length; ++argNo)
			{
		        argDescriptors[argNo].asType =
					propMethodXML[0].parameter[argNo].@type.toString(); 
			}
        }
    }

    /**
	 *  @private
	 */
	private static function getASTypeForMethodArgument(dtForClass:XML,
                                                       methodName:String,
                                                       argName:String):String
    {
        var propASType:String = null;
        
		// If DT was done a class, we need to go to the factory node instead.
		var isFactory:Boolean = dtForClass.hasOwnProperty("factory");
		var dtListForClass:XML = isFactory ? dtForClass.factory[0] : dtForClass;
		var propASTypeXML:XMLList =  dtListForClass.variable.(@name==argName);
		if (propASTypeXML.length() == 0)
			propASTypeXML = dtListForClass.accessor.(@name==argName);
		
		propASType = propASTypeXML.length() > 0 ?
					 propASTypeXML[0].@type.toString() :
					 null;
    		
		return propASType;
    }

    /**
     *  Puts an event in string form for hashing
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    private static function hash(eventClassName:String, eventType:String):String
    {
        return eventClassName.replace("::", ".") + "|" + eventType;
    }
    
    /**
     * private
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function get propertyNameMap():Object
    {
    	return _propertyNameMap;
    }

    /**
     *  @return name, superClassName, and event/method mappings.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function toString():String
    {
        return "name: " + _name + "\n" +
               "superClassName: " + _superClassName + "\n" +
               "event2descriptor: " + ObjectUtil.toString(_event2descriptor);
    }
}

}