////////////////////////////////////////////////////////////////////////////////
//
//  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 bxf.ui.controls
{
	import bxf.ui.inspectors.HotTextInput;
	import bxf.ui.utils.EffectiveStage;
	
	import flash.display.CapsStyle;
	import flash.display.LineScaleMode;
	import flash.display.DisplayObject;
	import flash.events.FocusEvent;
	import flash.events.MouseEvent;
	import flash.text.TextLineMetrics;
	
	import mx.controls.TextInput;
	import mx.core.UIComponent;
	import mx.core.UITextField;
	import mx.events.FlexEvent;
	import mx.managers.CursorManager;
	
	[Event(name="change", type="bx.controls.HotTextEvent")]
	[Event(name="finishChange", type="bx.controls.HotTextEvent")]
	[Event(name="active", type="bx.controls.HotTextEvent")]
	[Event(name="inactive", type="bx.controls.HotTextEvent")]
	
	public class HotText extends UIComponent
	{
		[Embed(source="../assets/finger_scrub_cur.png")]
		private static var sHorizResizeCursor:Class;

	    //----------------------------------
	    //  textField
	    //----------------------------------
	
	    /**
	     *  The internal UITextField object that renders the value of the hotext control.
	     * 
	     *  @default null 
	     */
	    protected var textField:HotTextInput;

	    //----------------------------------
	    //  labelField
	    //----------------------------------
	
	    /**
	     *  The internal UITextField object that renders the label of the hotext control.
	     * 
	     *  @default null 
	     */
		protected var labelField:UITextField;
		
		protected var inPlaceEdit:TextInput;
		
		private var currCapture:IMouseCapture = null;
		private var _fontSize:uint;
		private var _textLabel:String;
		private var _valueString:String;
		private var _valueConflict:Boolean = true;
		
		private var _labelColor:Number = 0x000000;
				
		private var _displayUnderline:Boolean = false;
		
		private var _suffix:String="";
		
		private var _maxChars:int = 0;	// for inPlaceEdit
		
		private var _stage:DisplayObject;	// if we get unexpectedly removed from the stage, we still need to find it to 
									// remove stageBubbleClickHandler
		private var labelStyle:String = "ActionLabels";
		private var detailStyle:String = "hotTextStyle";
		
		// for activity event debouncing
		private var _hovering:Boolean = false;	// basically, "mouse over" regardless of focus
		private var _editing:Boolean = false;	// inPlaceEdit active
		private var _suspended:Boolean = false;	// inPlaceEdit suspended
		private var _genericallyFocused:Boolean = false;	// focused by keyboard or after drag; e.g. "blue box showing"
		
		public function HotText()
		{
			super();
		}

		private function mouseUpHandler(e:MouseEvent):void{
			if (currCapture) {
				currCapture.EndTracking(e);
				currCapture = null;
				if (null != EffectiveStage(this)) {
		        	EffectiveStage(this).removeEventListener(MouseEvent.MOUSE_UP, mouseUpHandler, true);
		       		EffectiveStage(this).removeEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler, true);
		  		}
				if (e.target == textField.internalTextField) { //bug 217661
					CursorManager.setCursor(sHorizResizeCursor);
				}
				else {
					CursorManager.removeAllCursors();
				}
				e.stopPropagation();
			}
		}

		private function mouseDownHandler(e:MouseEvent):void{
			currCapture = ServeMouseCapture();
			if (null == currCapture)
				return;
	
	        EffectiveStage(this).addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler, true);
	        EffectiveStage(this).addEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler, true);
				
			currCapture.BeginTracking(e, true);
		}

		private function mouseMoveHandler(e:MouseEvent):void {
			if (currCapture) {
				currCapture.ContinueTracking(e);
				e.stopPropagation();
			}
		}

		private function clickHandler(e:MouseEvent):void {
			
		}
		
		private function set hovering(value:Boolean) : void {
			_hovering = value;
//			if (value) {
//				addActivity();
//			} else {
//				subtractActivity();
//			}
		}
		
		private function set editing(value:Boolean) : void {
			_editing = value;
			if (value) {
				addActivity();
			} else {
				subtractActivity();
			}
		}
		
		private function set focused(value:Boolean) : void {
			_genericallyFocused = value;
			if (value) {
				addActivity();
			} else {
				subtractActivity();
			}
		}
		
		public function setValueConflict():void
		{
			_valueConflict = true;
			if (textField) {
				textField.text = "---";
	            invalidateSize();
    	        invalidateDisplayList();
			}
		}
		
		public function get valueConflict() : Boolean {
			return _valueConflict;
		}

		private function addActivity() : void
		{
			const degreeOfActivity:int = int(_editing) + /* int(_hovering) + */ int(_genericallyFocused);
			
//			trace(bx.utils.StackTrace("addFocus: degree " + degreeOfActivity + "; editing " + _editing + "; hovering " + _hovering + "; focused " + _genericallyFocused));

			if (degreeOfActivity == 1)	// e.g. we're going 0->1
			{
				dispatchEvent(new HotTextEvent(HotTextEvent.ACTIVE, this));
			}
		}

		private function subtractActivity() : void
		{
			const degreeOfActivity:int = int(_editing) + /* int(_hovering) + */ int(_genericallyFocused);

//			trace(bx.utils.StackTrace("subtractFocus: degree " + degreeOfActivity + "; editing " + _editing + "; hovering " + _hovering + "; focused " + _genericallyFocused));

			if (degreeOfActivity == 0)	// totally done
			{	
				dispatchEvent(new HotTextEvent(HotTextEvent.INACTIVE, this));
			}
		}

		private function rollOverHandler(e:MouseEvent):void {
			if (!e.buttonDown) {
				if (e.target == e.currentTarget) {
					CursorManager.setCursor(sHorizResizeCursor);
					hovering = true;
				}
			}
		}

		private function rollOutHandler(e:MouseEvent):void {
			
			if (null == currCapture && !e.buttonDown && e.target == e.currentTarget) {
				CursorManager.removeAllCursors();
				hovering = false;
			}
		}

		private function focusGainHandler(e:FocusEvent):void {
			focused = true;
		}

		private function focusLossHandler(e:FocusEvent):void {
			focused = false;
		}

		public function set suffix(inSuffix:String):void {
			_suffix = inSuffix;
		}
		
		public function set textLabel(inLabel:String):void {
			_textLabel = inLabel;
			if (labelField) {
			
				labelField.text = inLabel;
	            invalidateSize();
    	        invalidateDisplayList();
			}
		}
	
		public function set displayUnderline(inDisplay:Boolean):void {
			_displayUnderline = inDisplay;
    	    invalidateDisplayList();    			
		}

		public function get textLabel():String {
			return _textLabel;
		}
	
		protected function set valueString(inValStr:String):void {
			_valueConflict = false;
			_valueString = inValStr;
			if (textField) {
				textField.text = _valueString + _suffix;
	            invalidateSize();
    	        invalidateDisplayList();
			}
		}
		
		public function set labelColor(color:Number):void {
			_labelColor = color;
			if (labelField)
				labelField.setColor(_labelColor);
		}
		
		/// Max chars for in-place edit
		public function set maxChars(chars:int):void {
			_maxChars = chars;
		}
		
		public function get maxChars():int {
			return _maxChars;
		}
		
		/** 
		 * Internal functions used for subclass extension
		 * */
		 
		protected function UpdateStringFromValue():void {
			
		}

		protected function SetValueFromText(inString:String):void {
			
		}

		protected function ServeMouseCapture():IMouseCapture {
			return null;
		}

		/**
		 * Flex Overrides
		 * */
	    override protected function createChildren():void
	    {
	        super.createChildren();
	
	        // Create a UITextField to display the label.
	 		if (!labelField) {
	 			labelField = new UITextField;//(createInFontContext(UITextField));
				labelField.styleName = labelStyle;

	 			addChild(labelField);
	 			//labelField.setColor(_labelColor);
	 		}
	 		
	        if (!textField)
	        {
	            textField = new HotTextInput;//UITextField(createInFontContext(UITextField));
	            textField.addEventListener(MouseEvent.ROLL_OVER, rollOverHandler);
	            textField.addEventListener(MouseEvent.ROLL_OUT, rollOutHandler);
	            //textField.addEventListener(MouseEvent.CLICK, clickHandler);
	            textField.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);
	            textField.addEventListener(flash.events.FocusEvent.FOCUS_IN, focusGainHandler);
	            textField.addEventListener(flash.events.FocusEvent.FOCUS_OUT, focusLossHandler);
	            this.styleName = detailStyle;
	            addChild(textField);
	        }
	        
	        if (!inPlaceEdit) 
	        {
	        	inPlaceEdit = new TextInput;//TextInput(createInFontContext(TextInput));
	        	inPlaceEdit.setStyle("color", "#000000");
	        	addChild(inPlaceEdit);
	        	inPlaceEdit.visible = false;
	        }
	    }
	
	    override public function get baselinePosition():Number
	    {
	        if (!myValidateBaselinePosition())
	            return NaN;
	
	        return textField.y + textField.baselinePosition;
	    }
	    
		private function myValidateBaselinePosition():Boolean
	    {
	        // If this component isn't parented,
	        // then it doesn't know its text styles
	        // and we can't compute a baselinePosition.
	        if (!parent)
	            return false;
	            
	        // If this component hasn't been sized yet, assign it
	        // an actual size that's based on its explicit or measured size.
	        if (width == 0 && height == 0)
	        {
	            validateNow();
	            
	            var w:Number = getExplicitOrMeasuredWidth();
	            var h:Number = getExplicitOrMeasuredHeight();
	            
	            setActualSize(w, h);
	        }
	        
	        // Ensure that this component's internal TextFields
	        // are properly laid out, so that we can use
	        // their locations to compute a baselinePosition.
	        validateNow();
	        
	        return true;
	    }	    

		private static const TEXT_HEIGHT_PADDING:int = 4;
		private static const TEXT_WIDTH_PADDING:int = 6;
	    
	    override protected function measure():void
    	{
	   		super.measure();

	        var textWidth:Number = 0;
    	    var textHeight:Number = 0;
			var paddingLeft:Number = getStyle("paddingLeft");
			var paddingRight:Number = getStyle("paddingRight");
			var paddingTop:Number = 4;//getStyle("paddingTop");
			var paddingBottom:Number = getStyle("paddingBottom");
			var horizontalGap:Number = 2;
			//horizontalGap = getStyle("horizontalGap");

			if (textLabel)
		    {
				var lineMetrics:TextLineMetrics = measureText(textLabel);
				textWidth = lineMetrics.width + TEXT_WIDTH_PADDING;
				textHeight = lineMetrics.height + TEXT_HEIGHT_PADDING;
		        
				textWidth += paddingLeft + paddingRight + getStyle("textIndent"); 
				textHeight += paddingTop + paddingBottom;         
				textWidth += (horizontalGap-2);
			}
		    
		    if (_valueString) 
		   	{
				lineMetrics = measureText(_valueString + _suffix);
				textWidth += lineMetrics.width + TEXT_WIDTH_PADDING;
				textHeight += lineMetrics.height + TEXT_HEIGHT_PADDING;
		        
				textWidth += paddingLeft + paddingRight + getStyle("textIndent"); 
				textHeight += paddingTop + paddingBottom;         		   		
		   	}

			measuredMinWidth = measuredWidth = textWidth;
        	measuredMinHeight = measuredHeight = textHeight;
	   	}
	   	 
	    override protected function updateDisplayList(unscaledWidth:Number,
    	                                              unscaledHeight:Number):void
    	{
    		var dispStr:String = _valueConflict ? "---" : _valueString + _suffix;
    		if (textField.text != dispStr) {
 	            textField.text = dispStr;
    		}
    		
    		if (labelField.text != _textLabel) {
 	            labelField.text = _textLabel;
    		}
   
	         layoutContents(unscaledWidth, unscaledHeight,
    	                   /*phase == ButtonPhase.DOWN*/false);
    	     
			if (_displayUnderline) {
	    	    // Draw a dashed underline
	    	    var beginOfLineX:int = textField.x + (0.25 * TEXT_WIDTH_PADDING);
	    	    var endOfLineX:int = textField.x + textField.width - (0.5 * TEXT_WIDTH_PADDING);
	    	    if (beginOfLineX < endOfLineX)
	    	    {
		    	    var lineY:int = textField.y + textField.height - TEXT_HEIGHT_PADDING - 2;
		    	     
					this.graphics.clear();
		    	    
					this.graphics.lineStyle(1, getStyle("color"), 1, true, LineScaleMode.NONE, CapsStyle.NONE);
					for (var currentPoint:int = beginOfLineX; currentPoint <= endOfLineX; currentPoint += 2) {
						this.graphics.moveTo(currentPoint, lineY);
						this.graphics.lineTo(currentPoint, lineY+1);
					}
					this.graphics.lineStyle(1, getStyle("backColor"), 1, true, LineScaleMode.NONE, CapsStyle.NONE);
					this.graphics.moveTo(beginOfLineX-1, lineY+1);
					this.graphics.lineTo(endOfLineX+1, lineY+1);
	    	    }
			}
    	}
    	
    	protected function layoutContents(unscaledWidth:Number,
                                        unscaledHeight:Number,
                                        offset:Boolean):void
        {
			var labelWidth:Number = 0;
			var labelHeight:Number = 0;

			var labelX:Number = 0;
			var labelY:Number = 0;
       
			var textWidth:Number = 0;
			var textHeight:Number = 0;

			var textX:Number = 0;
			var textY:Number = 0;

			var horizontalGap:Number = 0;
			var verticalGap:Number = 2;

			var paddingLeft:Number = getStyle("paddingLeft");
			var paddingRight:Number = getStyle("paddingRight");
			var paddingTop:Number = getStyle("paddingTop");
			var paddingBottom:Number = getStyle("paddingBottom");

        	var lineMetrics:TextLineMetrics;

			if (_textLabel) {
    	        lineMetrics = measureText(_textLabel);
        	    labelWidth = lineMetrics.width + TEXT_WIDTH_PADDING;
            	labelHeight = lineMetrics.height + TEXT_HEIGHT_PADDING;
        	} else {
            	lineMetrics = measureText("Wj");
            	textHeight = lineMetrics.height + TEXT_HEIGHT_PADDING;
        	}

			if (_valueString) {
	   	        lineMetrics = measureText(_valueString + _suffix);
        	    textWidth = lineMetrics.width + TEXT_WIDTH_PADDING;
            	textHeight = lineMetrics.height + TEXT_HEIGHT_PADDING;
			} else {
            	lineMetrics = measureText("Wj");
            	textHeight = lineMetrics.height + TEXT_HEIGHT_PADDING;
        	}

			var viewWidth:Number = unscaledWidth;
			var viewHeight:Number = unscaledHeight;

           // horizontalGap = getStyle("horizontalGap");
			if (textWidth == 0 || labelWidth == 0)
				horizontalGap = 0;
			
           
           	labelField.width = labelWidth;
            labelField.height = labelHeight = Math.min(viewHeight, labelHeight);
            
            if (textWidth > 0)
            {
            	if (unscaledWidth > 0) 
                	textField.width = textWidth = 
                    	Math.max(Math.min(viewWidth - labelWidth - horizontalGap -
                        	              paddingLeft - paddingRight, textWidth), 0);
                else
                	textField.width = textWidth;
            }
            else
            {
                textField.width = labelWidth = 0;
            }
            
			textField.height = labelHeight = Math.min(viewHeight, textHeight);
			labelX += paddingLeft;
			textX = labelX + labelWidth + horizontalGap;
            labelY  = ((viewHeight - labelHeight - paddingTop - paddingBottom) / 2) + paddingTop;
            textY = ((viewHeight - textHeight - paddingTop - paddingBottom) / 2) + paddingTop;

	        textField.x = Math.round(textX);
    	    textField.y = Math.round(textY);

	        labelField.x = Math.round(labelX);
    	    labelField.y = Math.round(labelY);
        }
		
		private function handleInPlaceEditEnd():void {
			if (_editing || _suspended)
			{
				inPlaceEdit.visible = false;
				inPlaceEdit.removeEventListener(mx.events.FlexEvent.ENTER, onNumberChanged);
				inPlaceEdit.removeEventListener(flash.events.FocusEvent.KEY_FOCUS_CHANGE, onKeyFocusOut);
				inPlaceEdit.removeEventListener(flash.events.FocusEvent.FOCUS_OUT, inPlaceFocusLossHandler);
				
				_stage.removeEventListener(MouseEvent.CLICK, stageBubbleClickHandler, true);		
				
				if (!valueConflict || inPlaceEdit.text.length > 0)
					SetValueFromText(inPlaceEdit.text);
				inPlaceEdit.horizontalScrollPosition = 0.0;
				editing = false;
				_suspended = false;
			}
		}
		
		/**
		 * Turns off editing (call from loss of focus), but puts control into a suspended state so that a subsequent
		 * event (from tab or enter key) can still cause it to set the value of the property.
		 */
		private function handleInPlaceEditSuspend():void {
			if (_editing)
			{
				inPlaceEdit.visible = false;
				inPlaceEdit.removeEventListener(mx.events.FlexEvent.ENTER, onNumberChanged);
				inPlaceEdit.removeEventListener(flash.events.FocusEvent.KEY_FOCUS_CHANGE, onKeyFocusOut);
				inPlaceEdit.removeEventListener(flash.events.FocusEvent.FOCUS_OUT, inPlaceFocusLossHandler);
				
				_stage.removeEventListener(MouseEvent.CLICK, stageBubbleClickHandler, true);		
				inPlaceEdit.horizontalScrollPosition = 0.0;
				editing = false;
				_suspended = true;
			}
		}
		
		private function onNumberChanged(evt:mx.events.FlexEvent):void {
			textField.setFocus(); // Return focus to the Mouse Control
			handleInPlaceEditEnd();
		}
		
		private function onKeyFocusOut(evt:flash.events.FocusEvent):void {
			textField.setFocus(); // Return focus to the Mouse Control
			handleInPlaceEditEnd();
		}
		
		
		private function stageBubbleClickHandler(evt:MouseEvent):void {
			if (evt.target == textField.internalTextField)
				return;
			var targetAsUITextField:UITextField = evt.target as UITextField;
			if (targetAsUITextField != null) {
				if (targetAsUITextField.parent == inPlaceEdit)
					return;
			}
			handleInPlaceEditEnd();
		}
		
		private function inPlaceFocusLossHandler(e:FocusEvent):void {
			handleInPlaceEditSuspend();
		}

		public function beginInPlaceEdit():void {
			inPlaceEdit.addEventListener(mx.events.FlexEvent.ENTER, onNumberChanged);
			inPlaceEdit.addEventListener(flash.events.FocusEvent.KEY_FOCUS_CHANGE, onKeyFocusOut);
			inPlaceEdit.addEventListener(flash.events.FocusEvent.FOCUS_OUT, inPlaceFocusLossHandler);
			
			// remember the stage because e.g. due to deselection we can get removed from the stage before we get 
			// notified of it - but we will still need to unhook stageBubbleClickHandler. See bug 214627/215494
			_stage = EffectiveStage(this);
			
			_stage.addEventListener(MouseEvent.CLICK, stageBubbleClickHandler, true);
			
	
			inPlaceEdit.horizontalScrollPosition = 0;
			inPlaceEdit.setSelection(0,0);
			inPlaceEdit.visible = true;
					
			inPlaceEdit.x = textField.x-2;
			inPlaceEdit.y = textField.y-2;
			inPlaceEdit.width = Math.max(textField.width+4, 40);
			inPlaceEdit.height = textField.height+4;
			inPlaceEdit.text = _valueConflict ? "" : _valueString;
			inPlaceEdit.maxChars = _maxChars;
			inPlaceEdit.setFocus();
			inPlaceEdit.setSelection(0, textField.text.length);	
			inPlaceEdit.horizontalScrollPosition = 0;	
			inPlaceEdit.setFocus();
			editing = true;
		}
	}
}