////////////////////////////////////////////////////////////////////////////////
//
//  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 com.flexcapacitor.utils {
	import com.flexcapacitor.controller.Radiate;
	import com.flexcapacitor.events.InspectorEvent;
	import com.flexcapacitor.graphics.LayoutLines;
	import com.flexcapacitor.model.VisualElementVO;
	
	import flash.desktop.Clipboard;
	import flash.desktop.ClipboardFormats;
	import flash.display.DisplayObject;
	import flash.display.DisplayObjectContainer;
	import flash.events.IEventDispatcher;
	import flash.utils.describeType;
	import flash.utils.getQualifiedClassName;
	import flash.utils.getQualifiedSuperclassName;
	
	import mx.collections.ArrayCollection;
	import mx.core.IVisualElement;
	import mx.core.IVisualElementContainer;
	import mx.core.UIComponent;
	import mx.managers.ISystemManager;
	import mx.utils.NameUtil;
	import mx.utils.ObjectUtil;

	public class InspectorUtils {


		public function InspectorUtils() {


		}
		
		/**
		 * Get unqualified class name of the target object
		 * */
		public static function getClassName(element:Object):String {
			var name:String = NameUtil.getUnqualifiedClassName(element);
			return name;
		}
		
		/**
		 * Get unqualified class name of the document of the target object
		 * returns null if element is not a UIComponent
		 * */
		public static function getDocumentName(element:Object):String {
			var name:String;
			if (element is UIComponent) {
				name = NameUtil.getUnqualifiedClassName(UIComponent(element).document);
			}
			return name;
		}
		
		/**
		 * Get the type of the value passed in
		 * */
		public static function getValueType(value:*):String {
			var type:String = getQualifiedClassName(value);
			
			if (type=="int") {
				if (typeof value=="number") {
					type = "Number";
				}
			}
			
			return type;
		}
		
		/**
		 * Get package of the target object
		 * */
		public static function getPackageName(element:Object):String {
			var name:String = flash.utils.getQualifiedClassName(element);
			if (name && name.indexOf("::")) {
				name = name.split("::")[0];
			}
			
			return name;
		}

		/**
		 * Get super class name of the target object
		 * */
		public static function getSuperClassName(element:Object):String {
			var name:String = flash.utils.getQualifiedSuperclassName(element);
			if (name && name.indexOf("::")) {
				name = name.split("::")[name.split("::").length-1]; // i'm sure theres a better way to do this
			}
			
			return name;
		}

		/**
		 * Get the package of the super class name of the target
		 * */
		public static function getSuperClassPackage(element:Object):String {
			var name:String = flash.utils.getQualifiedSuperclassName(element);
			if (name && name.indexOf("::")) {
				name = name.split("::")[0];
			}
			
			return name;
		}
		
		/**
		 * Clears outline drawn around target display object
		 * */
		public static function clearSelection(target:Object, systemManager:ISystemManager, remove:Boolean = false):void {
			LayoutLines.getInstance().clear(target, systemManager, remove);
		}
		
		/**
		 * Draws outline around target display object
		 * */
		public static function drawSelection(target:Object, systemManager:ISystemManager):void {
			throw new Error("CANNOT USE DRAW SELECTION");
			//Radiate.drawSelection(target);
			/*if (target is DisplayObject) {
				LayoutLines.getInstance().drawLines(target, systemManager);
			}
			else if (target!=null) {
				trace("Is not displayObject", NameUtil.getUnqualifiedClassName(target));
			}*/
		}

		/**
		 * Copy text to clipboard
		 * */
		public static function copyToClipboard(text:String, format:String=ClipboardFormats.TEXT_FORMAT):void {
			Clipboard.generalClipboard.setData(ClipboardFormats.TEXT_FORMAT, text);
		}

		/**
		 * Returns an array of display objects of type VisualElementVO
		 * Optionally returns elements
		 * */
		public static function getElementChildrenArray(displayObject:DisplayObject, getElements:Boolean = false, getSkins:Boolean = true):ArrayCollection {
			var displayObject:DisplayObject = DisplayObject(displayObject);
			var displayObjectContainer:DisplayObjectContainer;

			var visualElementContainer:IVisualElementContainer;
			var visualElement:IVisualElement;

			var visualElementVO:VisualElementVO = new VisualElementVO();

			var children:ArrayCollection = new ArrayCollection();


			// attempt to cast to a specific type and assign in the process
			displayObjectContainer = displayObject as DisplayObjectContainer;
			visualElementContainer = displayObject as IVisualElementContainer;
			visualElement = displayObject as IVisualElement;


			// gather all the display objects on the current display object
			if (displayObjectContainer) {

				for (var bb:int = 0; bb < displayObjectContainer.numChildren; bb++) {
					
						// visualElementVO = createDisplayObjectVO(displayObjectContainer.getChildAt(bb));
					visualElementVO = VisualElementVO.unmarshall(displayObjectContainer.getChildAt(bb));
					children.addItem(visualElementVO);
				}
			}

			if (visualElementContainer && getElements) {

				for (var cc:int = 0; cc < visualElementContainer.numElements; cc++) {
						//visualElementVO = createDisplayObjectVO(displayObjectContainer.getChildAt(cc));
					visualElementVO = VisualElementVO.unmarshall(DisplayObject(visualElementContainer.getElementAt(cc)));
					children.addItem(visualElementVO);
				}
			}

			return children;
		}


		/**
		 * Gets the ID of the target object
		 * returns null if no ID is specified or target is not a UIComponent
		 * */
		public static function getIdentifier(element:Object):String {
			var id:String;

			if (element is UIComponent && UIComponent(element).id) {
				id = UIComponent(element).id;
			}
			return id;
		}

		/**
		 * Get name of target object or null if not available
		 * */
		public static function getName(element:Object):String {
			var name:String;

			if (element.hasOwnProperty("name") && element.name) {
				name = element.name;
			}

			return name;
		}

		/**
		 * Get qualified class name of the target object
		 * */
		public static function getQualifiedClassName(element:Object):String {
			var name:String = flash.utils.getQualifiedClassName(element);
			return name;
		}

		/**
		 * With the given target it returns a regexp pattern to find the exact instance in MXML
		 * If isScript is true it attempts to returns a pattern to find the exact instance in AS3
		 * The MXML pattern will find the instance with that ID. If the instance doesn't have an ID it no worky.
		 * NOTE: Press CMD+SHIFT+F to and check regular expression in the Find in Files dialog
		 * */
		public static function getRegExpSearchPattern(target:DisplayObject, isScript:Boolean = false):String {
			var id:String = getIdentifier(target);
			var className:String = NameUtil.getUnqualifiedClassName(target);
			var pattern:String;
			var scriptPattern:String;

			if (id == null) {
				pattern = className + "(.*)";
			}
			else {
				pattern = className + "(.*)id\\s?=\\s?[\"|']" + id + "[\"|']";
				scriptPattern = id + ".addEventListener";
			}


			if (isScript) {
				return scriptPattern;
			}

			return pattern;
		}


		/**
		 * Get ancestors of element 
		 * 
		 * @param target
		 * @param collection
		 * @param ancestors
		 * @return
		 */
		public static function getVisualElementsArray(element:*, items:Array, ancestors:int = 0, topMostDisplayObject:Object = null):Array {
			var vo:VisualElementVO;

			// do the worm up the display list
			while (element!= null && ancestors>-1)
			{
				// store display element information
				vo = VisualElementVO.unmarshall(element);
				
				// save reference to display element VO's for tree
				if (!items) items = new Array();
				items.push(vo);
				
				if ("owner" in element) {
					element = element.owner as IVisualElement;
				}
				
				ancestors--;
				
				if (element==topMostDisplayObject) {
					ancestors = 0; //bail after the next run through
				}
			}
			
			return items;

		}
		
		/**
		 * Get the parent of the target that is also a UIComponent
		 * 
		 * @return
		 */
		public static function getParentUIComponent(target:DisplayObject):UIComponent {
			var found:Boolean;
			
			// run up the display list
			while (target) {
				target = target.parent;
				
				// check if next parent exists
				if (!target) {
					break;
				}
				
				if (target is UIComponent) {
					found = true;
					break;
				}
				
			}
			
			if (found) return UIComponent(target);
			return null;
		}
		
		/**
		 * Get the name of the target parent that is also a UIComponent
		 * 
		 * @return
		 */
		public static function getParentUIComponentName(target:DisplayObject):String {
			var parent:DisplayObject = getParentUIComponent(target);
			var className:String = getClassName(parent);
			return className;
		}
		
		
		/**
		 * Get parent document name
		 * 
		 * @return null if target is not a UIComponent
		 */
		public static function getParentDocumentName(target:Object):String {
			var className:String;
			if (target is UIComponent) {
				className = getClassName(target.parentDocument);
			}
			return className;
		}
		
		
		/**
		 * Get parent document name
		 * 
		 * @return
		 */
		public static function getClassNameAndPackage(target:Object):Array {
			var className:String;
			var classPath:String;
			
			className = getClassName(target);
			classPath = getPackageName(target);
			
			return [className, classPath];
		}
		
		
		/**
		 * Dispatch target change event
		 * 
		 * @return
		 */
		public static function dispatchTargetChangeEvent(target:Object, source:IEventDispatcher):void {
			
			// let other inspectors know there is a new target selected
			var selectionChangeEvent:InspectorEvent = new InspectorEvent(InspectorEvent.CHANGE);
			selectionChangeEvent.targetItem = target;
			
			// store previous targets in a dictionary
			
			if (source) {
				source.dispatchEvent(selectionChangeEvent);
			}			
		}
		
		
		/**
		 * Change target. Use this instead of dispatchTargetChangeEvent()
		 * 
		 * TODO: Add a weak reference to the old target in a static array for history type navigation
		 * 
		 * @return
		 */
		public static function updateTarget(target:Object, source:IEventDispatcher):void {
			// TODO: Add a weak reference to the old target in a static array for history type navigation
			
			// let other inspectors know there is a new target selected
			var selectionChangeEvent:InspectorEvent = new InspectorEvent(InspectorEvent.CHANGE);
			selectionChangeEvent.targetItem = target;
			
			if (source) {
				source.dispatchEvent(selectionChangeEvent);
			}			
		}
		
		/**
		 * Converts an integer to hexidecimal. 
		 * For example, 16117809 returns "#EEEEEE" or something
		 * @return
		 */
		public static function convertIntToHex(item:Object):String {
			var hex:String = Number(item).toString(16);
			return ("00000" + hex.toUpperCase()).substr(-6);
		}
		
		
		/**
		 * Sets the property on the target. Supports styles. 
		 * We should probably switch to the set property method 
		 * @return
		 */
		public static function setTargetProperty(target:Object, property:String, value:*, type:String = "String", isPropertyStyle:Object=null):void {
			var newAssignedValue:* = TypeUtils.getTypedValue(value, type);
			TypeUtils.applyProperty(target, property, newAssignedValue, type, isPropertyStyle);
		}
		
			
		/**
		 * @copy spark.components.gridClasses.GridItemEditor#save();
		 */
		public static function setProperty(target:Object, field:String, value:*):Boolean {
			
			var newData:Object = value;
			var property:String = field;
			var data:Object = target;
			var typeInfo:String = "";
			
			for each(var variable:XML in describeType((data).variable)) {
				if (property == variable.@name.toString()) {
					typeInfo = variable.@type.toString();
					break;
				}
			}
			
			if (typeInfo == "String") {
				if (!(newData is String))
					newData = newData.toString();
			}
			else if (typeInfo == "uint") {
				if (!(newData is uint))
					newData = uint(newData);
			}
			else if (typeInfo == "int") {
				if (!(newData is int))
					newData = int(newData);
			}
			else if (typeInfo == "Number") {
				if (!(newData is Number))
					newData = Number(newData);
			}
			else if (typeInfo == "Boolean") {
				if (!(newData is Boolean)) {
					var strNewData:String = newData.toString();
					
					if (strNewData) {
						newData = (strNewData.toLowerCase() == "true") ? true : false;
					}
				}
			}
			
			if (property && data[property] !== newData) {
				data[property] = newData;
			}
			
			return true;
		}
		
		/**
		 *  Returns <code>true</code> if the object reference specified
		 *  is a simple data type. The simple data types include the following:
		 *  <ul>
		 *    <li><code>String</code></li>
		 *    <li><code>Number</code></li>
		 *    <li><code>uint</code></li>
		 *    <li><code>int</code></li>
		 *    <li><code>Boolean</code></li>
		 *    <li><code>Date</code></li>
		 *    <li><code>Array</code></li>
		 *  </ul>
		 *
		 *  @param value Object inspected.
		 *
		 *  @return <code>true</code> if the object specified
		 *  is one of the types above; <code>false</code> otherwise.
		 *  */
		public static function isSimple(value:*):Boolean {
			return ObjectUtil.isSimple(value);
		}
	}
}