////////////////////////////////////////////////////////////////////////////////
//
//  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 {
import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;
import flash.display.InteractiveObject;
import flash.events.Event;
import flash.events.FocusEvent;
import flash.events.KeyboardEvent;
import flash.events.TextEvent;
import flash.system.Capabilities;
import flash.text.TextField;
import flash.ui.Keyboard;


/**
 *  The test step that fakes a keyboard event
 *  MXML attributes:
 *  type (optional)
 *  charCode
 *  ctrlKey (optional)
 *  keyCode (optional)
 *  keyLocation (optional)
 *  shiftKey (optional)
 *  waitTarget (optional)
 *  waitEvent (optional)
 *  timeout (optional);
 *  cancelable (optional)
 */


public class DispatchKeyEvent extends TestStep
{
	// These are constants from flash.ui.Keyboard.  They are not
	// available in non-AIR compilations, so they are reproduced here
	// to avoid compile errors.
	// If they change in AIR, these will need to be updated.
	public static const FLASH_UI_KEYBOARD_BACK:uint = 0x01000016;
	public static const FLASH_UI_KEYBOARD_MENU:uint = 0x01000012;
	public static const FLASH_UI_KEYBOARD_SEARCH:uint = 0x0100001F;
	
    private var inDispatchKey:Boolean;
    private var gotFocusIn:Boolean;
    private var charSequence:Array;
    private var keySequence:Array;
    private var currentRepeat:int;
    private var currentKey:int;
    private var sendBoth:Boolean;
    
    /**
     *  Set the target's property to the specified value
     */
    override protected function doStep():void
    {
        UnitTester.blockFocusEvents = false;

        sendBoth = false;

        if (!type)
        {
            sendBoth = true;
            type = "keyDown";
        }
        
        var i:int;
        var n:int;
        charSequence = new Array();
        keySequence = new Array();
		
		
        if (charCode)
        {
            charSequence.push(charCode);
            keySequence.push(keyCode ? keyCode : CharCodeToKeyCode[charCode] ? CharCodeToKeyCode[charCode] : charCode);
        }
        else if (keyCode)
        {
            charSequence.push(KeyCodeToCharCode[keyCode] ? KeyCodeToCharCode[keyCode] : 0);
            keySequence.push(keyCode);
        }
        else if (char)
        {
            n = char.length;
            for (i = 0; i < n; i++)
            {
                var c:uint = char.charCodeAt(i) 
                charSequence.push(c);
                keySequence.push(CharCodeToKeyCode[c]);
            }
        }
        else if (key || keys)
        {
            var sequence:Array;
            if (key)
                sequence = [ key ];
            else
                sequence = keys;
            n = sequence.length;
            for (i = 0; i < n; i++)
            {
                var kc:uint = Keyboard[sequence[i]];
                if (kc == 0)
                {
                    testResult.doFail(key + " is not a valid flash.ui.Keyboard constant");
                    UnitTester.blockFocusEvents = true;
                    return;
                }
                keySequence.push(kc);
                charSequence.push(KeyCodeToCharCode[kc] ? KeyCodeToCharCode[kc] : 0);
            }
        }
        else
        {
            testResult.doFail("no keys specified");
            UnitTester.blockFocusEvents = true;
            return;
        }
		
        try
        {
            for (i = 0; i < repeatCount; i++)
            {
                var m:int = charSequence.length;
                for (var j:int = 0; j < m; j++)
                {
                    var event:KeyboardEvent = new KeyboardEvent(type, true, cancelable); // all keyboard events bubble
                    event.ctrlKey = ctrlKey;
                    event.shiftKey = shiftKey;
                    event.charCode = charSequence[j];
                    event.keyCode = keySequence[j];
                    event.keyLocation = keyLocation;

                    if (keySequence[j] == Keyboard.TAB)
                    {
                        // if we don't see a focusIn, focus is being set
                        // asynchronously so we need to wait.
                        currentRepeat = i;
                        currentKey = j;
                        gotFocusIn = false;
                        root.addEventListener("focusIn", focusInHandler);
                        inDispatchKey = true;
                        dispatchKey(j, event);
                        inDispatchKey = false;
                        if (!gotFocusIn)
                            break;
                    }
                    else
                        dispatchKey(j, event);
                }
            }
        }
        catch (e1:Error)
        {
            TestOutput.logResult("Exception thrown in DispatchKeyEvent.");
            testResult.doFail (e1.getStackTrace()); 
        }

        UnitTester.blockFocusEvents = true;
    }

    /**

     *  (Optional) name of a UI object whose Window/Stage

     *  will be used to dispatch the event

     */

    public var window:String;


    /**
     *  The type of the event to send (keyUp, keyDown, etc).
     *  If not set, we'll send both a keyDown and a keyUp
     */
    public var type:String;

    /**
     *  The char or sequence of chars to send as a string/char if you don't know the charCode (optional)
     */
    public var char:String;

    /**
     *  The charCode property on the KeyboardEvent (optional)
     */
    public var charCode:uint;

    /**
     *  The ctrlKey property on the KeyboardEvent (optional)
     */
    public var ctrlKey:Boolean;

    /**
     *  The Keyboard key if you don't know the keyCode (optional)
     */
    public var key:String;

    /**
     *  The sequence of keys (optional) e.g ["LEFT", "UP"]
     */
    public var keys:Array;

    /**
     *  The keyCode property on the KeyboardEvent (optional)
     */
    public var keyCode:uint;

    /**
     *  The keyLocation property on the KeyboardEvent (optional)
     */
    public var keyLocation:uint;

    /**
     *  The number of times to repeat the sequence (optional)
     */
    public var repeatCount:uint = 1;

    /**
     *  The shiftKey property on the KeyboardEvent (optional)
     */
    public var shiftKey:Boolean;

    /**
     *  Designate the created event to be cancelable. by default, they are not
     */
    public var cancelable:Boolean = false;

    /**
     *  The FlashPlayer TextField doesn't actually handle keyboard events so we have to
     *  emulate them
     */
    private function emulateKey(actualTarget:Object, event:KeyboardEvent):void
    {
        var begin:int = actualTarget.selectionBeginIndex;
        var end:int = actualTarget.selectionEndIndex;
        var caret:int = actualTarget.caretIndex;
        // trace("begin =", begin, "end =", end, "caret =", caret);

        if (event.keyCode == Keyboard.LEFT)
        {
            if (event.shiftKey)
            {
                if (caret > 0)
                {
                    if (caret == begin)
                    {
                        begin--;
                        // last param defines caret position
                        actualTarget.setSelection(end, begin);
                    }
                    else if (caret == end)
                    {
                        end--;
                        if (end < begin)
                            begin = end;
			            actualTarget.setSelection(end, begin);

                    }
                }
            }
            else
            {
                if (begin != end)
                    actualTarget.setSelection(begin, begin);

               else if (caret > 0)
                    actualTarget.setSelection(caret - 1, caret - 1);
            }
        }
        else if (event.keyCode == Keyboard.RIGHT)
        {
            if (event.shiftKey)
            {
                if (caret < actualTarget.length)
                {
                    if (caret == end)
                    {
                        end++;
                        actualTarget.setSelection(begin, end);

                    }
                    else if (caret == begin)
                    {
                        begin++;
                        if (end < begin)
                            end = begin;
                        // last param defines caret position
                        actualTarget.setSelection(end, begin);

                    }
                }
            }
            else
            {
                if (begin != end)
                    actualTarget.setSelection(end, end); 

               else if (caret > 0)
                    actualTarget.setSelection(caret + 1, caret + 1);
            }
        }
    }

    private function focusInHandler(focusEvent:Event):void
    {
        gotFocusIn = true;        
        root.removeEventListener("focusIn", focusInHandler);
        if (inDispatchKey)
            return;
        
        for (var i:int = currentRepeat; i < repeatCount; i++)
        {
            var m:int = charSequence.length;
            for (var j:int = currentKey + 1; j < m; j++)
            {
                var event:KeyboardEvent = new KeyboardEvent(type, true, cancelable); // all keyboard events bubble
                event.ctrlKey = ctrlKey;
                event.shiftKey = shiftKey;
                event.charCode = charSequence[j];
                event.keyCode = keySequence[j];
                event.keyLocation = keyLocation;
                
                if (keySequence[j] == Keyboard.TAB)
                {
                    currentRepeat = i;
                    currentKey = j;
                    gotFocusIn = false;
                    root.addEventListener("focusIn", focusInHandler);
                    inDispatchKey = true;
                    dispatchKey(j, event);
                    inDispatchKey = false;
                    if (!gotFocusIn)
                        break;
                }                
                else
                    dispatchKey(j, event);
            }
        }
    }
    
    private function dispatchKey(index:int, event:KeyboardEvent):void
    {
        // note that we don't check Window activation since we want to run in the background
        // and window activation is a player function
        
        var actualTarget:Object;
        
        if (window)
        {
            actualTarget = context.stringToObject(window);
            actualTarget = actualTarget.stage.focus;
        }
        else
        {
            actualTarget = root.stage.focus;
            if (!actualTarget)
            {
                actualTarget = UnitTester.getFocus();
            }
        }
        
        // BACK, MENU, and SEARCH are buttons on mobile (Android) devices.  
        // On Android devices right now, actualTarget is still null at this point.  Dispatching the event to the stage works.
        // Using the constants in flash.ui.Keyboard will cause an error in a non-AIR runs, so the constants are also defined
        // in this file, above.  There is risk here.
        if (keySequence[index] == FLASH_UI_KEYBOARD_BACK ||
            keySequence[index] == FLASH_UI_KEYBOARD_MENU ||
            keySequence[index] == FLASH_UI_KEYBOARD_SEARCH){
            
            actualTarget = root.stage;
        }
        
        if (actualTarget)
        {
            var targetType:TypeInfo = context.getTypeInfo(actualTarget);
            var isTextView:Boolean = targetType.isAssignableTo("spark.components::RichEditableText");
            
            
            if (actualTarget is TextField)
            {
                if (event.charCode)
                {
                    if (actualTarget.type == "input")
                    {
                        actualTarget.replaceSelectedText(String.fromCharCode(event.charCode));
                        // actualTarget.dispatchEvent(new Event("change", true));
                        actualTarget.dispatchEvent(new Event("change"));
                    }
                }
                else
                {
                    if (actualTarget.selectable)
                        emulateKey(actualTarget, event);
                }
            }
            
            actualTarget.dispatchEvent(event);
            
            
            if (isTextView)
            {
                if (event.keyCode == Keyboard.DELETE ||
                    
                    event.keyCode == Keyboard.BACKSPACE ||
                    
                    event.keyCode == Keyboard.INSERT ||
                    
                    ctrlKey)
                    
                {
                    
                    // don't send TEXT_INPUT event
                    
                }
                    
                else
                    
                {
                    
                    var textEvent:TextEvent = new TextEvent(TextEvent.TEXT_INPUT, true, true);
                    
                    textEvent.text = String.fromCharCode(charSequence[index]);
                    
                    actualTarget.dispatchEvent(textEvent);
                    
                }
                
            }
            
            if (keySequence[index] == Keyboard.TAB && type == "keyDown")
            {
                var fm:Object;
                var newTarget:Object = actualTarget;
                while (!fm && newTarget)
                {   
                    if ("focusManager" in newTarget)
                        fm = newTarget["focusManager"];
                    newTarget = newTarget.parent;
                }
                newTarget = null;
                if (fm)
                {
                    try
                    {
                        newTarget = fm.getNextFocusManagerComponent(shiftKey);
                    }
                    catch (e:Error)
                    {
                        // ignore error thrown here.  Should only throw if the
                        // current FM became inactive as a result of dispatching
                        // the key event.  We don't really care too much about
                        // getting an accurate newTarget in this case because
                        // newTarget is often wrong since the Player is offering
                        // it up and the Player has that wonky algorithm for
                        // determining newTarget.   In theory, none of our code
                        // truly cares as long as it doesn't point to old focus
                        // object.
                    }
                }
                
                actualTarget.dispatchEvent(new FocusEvent(FocusEvent.KEY_FOCUS_CHANGE, true, true, InteractiveObject(newTarget), shiftKey, Keyboard.TAB));
            }
            
            if (sendBoth)
            {
                event = new KeyboardEvent("keyUp", true, cancelable);
                event.ctrlKey = ctrlKey;
                event.shiftKey = shiftKey;
                event.charCode = charSequence[index];
                event.keyCode = keySequence[index];
                event.keyLocation = keyLocation;
                actualTarget.dispatchEvent(event);
            }
        }
        else
        {
            if (keySequence[index] == Keyboard.TAB && type == "keyDown")
            {
                
                var thisRoot:DisplayObject
                
                // note that we don't check Window activation since we want to run in the background
                // and window activation is a player function
                if (window)
                {
                    thisRoot = context.stringToObject(window).root;
                }
                else
                    thisRoot = root;
                try
                {
                    thisRoot.stage.dispatchEvent(new FocusEvent(FocusEvent.KEY_FOCUS_CHANGE, true, true, InteractiveObject(actualTarget), shiftKey, Keyboard.TAB));
                }
                catch(se2:SecurityError)
                {
                    thisRoot.dispatchEvent(new FocusEvent(FocusEvent.KEY_FOCUS_CHANGE, true, true, InteractiveObject(actualTarget), shiftKey, Keyboard.TAB));
                }
            }						
            
        }
    }
    
    private var KeyCodeToCharCode:Object = {
                    8: 8,
                    13: 13,
                    96: 48,
                    97: 49,
                    98: 50,
                    99: 51,
                    100: 52, 
                    101: 53,
                    102: 54,
                    103: 55,
                    104: 56,
                    105: 57,
                    106: 42,
                    107: 43,
                    109: 45,
                    110: 46,
                    111: 47
    }

    private var CharCodeToKeyCode:Object = {
                    13: 13,
                    33: 49,
                    34: 222,
                    35: 51,
                    36: 52,
                    37: 53,
                    38: 55,
                    39: 222,
                    40: 57,
                    41: 48,
                    42: 56,
                    43: 187,
                    44: 188,
                    45: 189,
                    46: 190,
                    47: 191,
                    48: 48,
                    49: 49,
                    50: 50,
                    51: 51,
                    52: 52,
                    53: 53,
                    54: 54,
                    55: 55,
                    56: 56,
                    57: 57,
                    58: 186,
                    59: 186,
                    60: 188,
                    61: 187,
                    62: 190,
                    63: 191,
                    64: 50,
                    65: 65,
                    66: 66,
                    67: 67,
                    68: 68,
                    69: 69,
                    70: 70,
                    71: 71,
                    72: 72,
                    73: 73,
                    74: 74,
                    75: 75,
                    76: 76,
                    77: 77,
                    78: 78,
                    79: 79,
                    80: 80,
                    81: 81,
                    82: 82,
                    83: 83,
                    84: 84,
                    85: 85,
                    86: 86,
                    87: 87,
                    88: 88,
                    89: 89,
                    90: 90,
                    91: 219,
                    92: 220,
                    93: 221,
                    94: 54,
                    95: 189,
                    96: 192,
                    97: 65,
                    98: 66,
                    99: 67,
                    100: 68,
                    101: 69,
                    102: 70,
                    103: 71,
                    104: 72,
                    105: 73,
                    106: 74,
                    107: 75,
                    108: 76,
                    109: 77,
                    110: 78,
                    111: 79,
                    112: 80,
                    113: 81,
                    114: 82,
                    115: 83,
                    116: 84,
                    117: 85,
                    118: 86,
                    119: 87,
                    120: 88,
                    121: 89,
                    122: 90,
                    123: 219,
                    124: 220,
                    125: 221,
                    126: 192
    }

    /**
     *  customize string representation
     */
    override public function toString():String
    {
        var s:String = "DispatchKeyEvent";
        if (charCode)
            s += ": charCode = " + charCode.toString();
        if (keyCode)
            s += ": keyCode = " + keyCode.toString();
        if (char)
            s += ": char = " + char;
        if (key)
            s += ": key = " + key;
        if (keys)
            s += ": keys = " + keys.toString();
        if (type)
            s += ", type = " + type;
        if (shiftKey)
            s += ", shiftKey = " + shiftKey.toString();
        if (ctrlKey)
            s += ", ctrlKey = " + ctrlKey.toString();
        if (repeatCount)
            s += ", repeatCount = " + repeatCount.toString();
        return s;
    }
}

}