////////////////////////////////////////////////////////////////////////////////
//
//  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 UnitTest.Tests
{
	import UnitTest.ExtendedClasses.TestSuiteExtended;
	import UnitTest.ExtendedClasses.VellumTestCase;
	import UnitTest.Fixtures.TestConfig;

	import flash.events.*;
	import flash.ui.KeyLocation;

	import flashx.textLayout.edit.EditManager;
	import flashx.textLayout.elements.TextFlow;
	import flashx.undo.UndoManager;

	public class EventOverrideTest extends VellumTestCase
	{
		public function EventOverrideTest(methodName:String, testID:String, testConfig:TestConfig, testCaseXML:XML=null)
		{
			super(methodName, testID, testConfig, testCaseXML);

			if ( TestData.eventOverride )
   			{
   				TestID = TestID + ":" + TestData.eventOverride;
   			}

   			// Note: These must correspond to a Watson product area (case-sensitive)
   			metaData.productArea = "Editing";
		}

		public static function suiteFromXML(testListXML:XML, testConfig:TestConfig, ts:TestSuiteExtended):void
 		{
 			var testCaseClass:Class = EventOverrideTest;
 			VellumTestCase.suiteFromXML(testCaseClass, testListXML, testConfig, ts);
 		}

   		public override function setUp():void
   		{
   			/*if ( TestData.eventOverride )
   			{
   				TextFlow.defaultConfiguration.manageEventListeners = false;
   			}*/

   			super.setUp();

   			if ( TestData.overrideEditManager == "true" )
   			{
	   			var testManager:EditManager = new TestEditManager(new UndoManager());
	   			SelManager.textFlow.interactionManager = testManager;
	   			SelManager = testManager;
	   			SelManager.selectRange(0,0);
	   		}
   		}

   		public override function tearDown():void
   		{
   			/*if ( TestData.eventOverride )
   			{
	   			TextFlow.defaultConfiguration.manageEventListeners = true;
	   			// Make sure we leave without a broken TextFlow
				loadTestFile("empty.xml");
   			}*/

   			if ( TestData.overrideEditManager == "true" )
   			{
	   			var newManager:EditManager = new EditManager(new UndoManager());
	   			SelManager.textFlow.interactionManager = newManager;
	   			SelManager = newManager;
	   		}
   		}

   		// Returns the string from begIdx through and including endIdx
   		private function getText( begIdx:int, endIdx:int ): String
   		{
   			var outString:String = "";

   			for ( var x:int = begIdx; x < endIdx; x++ )
   			{
   				outString += SelManager.textFlow.getCharAtPosition(x);
   			}

   			return outString;
   		}

   		// Returns the text contents of the entire textflow
   		private function getAllText(): String
   		{
   			var begIdx:int = SelManager.textFlow.parentRelativeStart;
   			var endIdx:int = SelManager.textFlow.parentRelativeEnd-1;
   			var outString:String = "";

   			for ( var x:int = begIdx; x < endIdx; x++ )
   			{
   				outString += SelManager.textFlow.getCharAtPosition(x);
   			}

   			return outString;
   		}

/******* Framework for event override tests (Not using derived editmanager ***********************/
/** Removing for expected ARB-related updates - probably to be removed permanently
 *
   		private function eventFromText( textID:String, addListener:Boolean, removeListener:Boolean = false ):Event
   		{
			var outEvent:Event;

			switch ( textID )
			{
				case "MOUSE_DOWN":
					if ( removeListener )
					{
						SelManager.textFlow.removeEventListener( MouseEvent.MOUSE_DOWN, eventHandler );
					}
					else if (addListener)
					{
						SelManager.textFlow.addEventListener( MouseEvent.MOUSE_DOWN, eventHandler, false, 0, true );
						return null;
					}
					else
					{
						outEvent = new MouseEvent( MouseEvent.MOUSE_DOWN, true, false, 0, 0 );
						return outEvent;
					}
					break;
				case "MOUSE_OVER":
					if ( removeListener )
					{
						SelManager.textFlow.removeEventListener( MouseEvent.MOUSE_OVER, eventHandler );
					}
					else if (addListener)
					{
						SelManager.textFlow.addEventListener( MouseEvent.MOUSE_OVER, eventHandler, false, 0, true );
						return null;
					}
					else
					{
						outEvent = new MouseEvent( MouseEvent.MOUSE_OVER, true, false, 0, 0 );
						return outEvent;
					}
					break;
				case "MOUSE_OUT":
					if ( removeListener )
					{
						SelManager.textFlow.removeEventListener( MouseEvent.MOUSE_OUT, eventHandler );
					}
					else if (addListener)
					{
						SelManager.textFlow.addEventListener( MouseEvent.MOUSE_OUT, eventHandler, false, 0, true );
						return null;
					}
					else
					{
						outEvent = new MouseEvent( MouseEvent.MOUSE_OUT, true, false, 0, 0 );
						return outEvent;
					}
					break;
				case "MOUSE_WHEEL":
					if ( removeListener )
					{
						SelManager.textFlow.removeEventListener( MouseEvent.MOUSE_WHEEL, eventHandler );
					}
					else if (addListener)
					{
						SelManager.textFlow.addEventListener( MouseEvent.MOUSE_WHEEL, eventHandler, false, 0, true );
						return null;
					}
					else
					{
						outEvent = new MouseEvent( MouseEvent.MOUSE_WHEEL, true, false, 0, 0 );
						return outEvent;
					}
					break;
				case "DOUBLE_CLICK":
					if ( removeListener )
					{
						SelManager.textFlow.removeEventListener( MouseEvent.DOUBLE_CLICK, eventHandler );
					}
					else if (addListener)
					{
						SelManager.textFlow.addEventListener( MouseEvent.DOUBLE_CLICK, eventHandler, false, 0, true );
						return null;
					}
					else
					{
						outEvent = new MouseEvent( MouseEvent.DOUBLE_CLICK, true, false, 0, 0 );
						return outEvent;
					}
					break;
				case "KEY_DOWN":
					if ( removeListener )
					{
						SelManager.textFlow.removeEventListener( KeyboardEvent.KEY_DOWN, eventHandler );
					}
					else if (addListener)
					{
						SelManager.textFlow.addEventListener( KeyboardEvent.KEY_DOWN, eventHandler, false, 0, true );
						return null;
					}
					else
					{
						outEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN, true, false,
											 8, 8, KeyLocation.STANDARD, true, false, false);
						return outEvent;
					}
					break;
				case "FOCUS_IN":
					if ( removeListener )
					{
						SelManager.textFlow.removeEventListener( FocusEvent.FOCUS_IN, eventHandler );
					}
					else if (addListener)
					{
						SelManager.textFlow.addEventListener( FocusEvent.FOCUS_IN, eventHandler, false, 0, true );
						return null;
					}
					else
					{
						outEvent = new FocusEvent( FocusEvent.FOCUS_IN );
						return outEvent;
					}
					break;
				case "FOCUS_OUT":
					if ( removeListener )
					{
						SelManager.textFlow.removeEventListener( FocusEvent.FOCUS_OUT, eventHandler );
					}
					else
					if (addListener)
					{
						SelManager.textFlow.addEventListener( FocusEvent.FOCUS_OUT, eventHandler, false, 0, true );
						return null;
					}
					else
					{
						outEvent = new FocusEvent( FocusEvent.FOCUS_OUT );
						return outEvent;
					}
					break;
				case "TEXT_INPUT":
					if ( removeListener )
					{
						SelManager.textFlow.removeEventListener( TextEvent.TEXT_INPUT, eventHandler );
					}
					else if (addListener)
					{
						SelManager.textFlow.addEventListener( TextEvent.TEXT_INPUT, eventHandler, false, 0, true );
						return null;
					}
					else
					{
						outEvent = new TextEvent( TextEvent.TEXT_INPUT, false, true, "WONTSEEME" );
						return outEvent;
					}
					break;
				case "ACTIVATE":
					if ( removeListener )
					{
						SelManager.textFlow.removeEventListener( Event.ACTIVATE, eventHandler );
					}
					else if (addListener)
					{
						SelManager.textFlow.addEventListener( Event.ACTIVATE, eventHandler, false, 0, true );
						return null;
					}
					else
					{
						outEvent = new Event( Event.ACTIVATE );
						return outEvent;
					}
					break;
				case "DEACTIVATE":
					if ( removeListener )
					{
						SelManager.textFlow.removeEventListener( Event.DEACTIVATE, eventHandler );
					}
					else if (addListener)
					{
						SelManager.textFlow.addEventListener( Event.DEACTIVATE, eventHandler, false, 0, true );
						return null;
					}
					else
					{
						outEvent = new Event( Event.DEACTIVATE );
						return outEvent;
					}
					break;
				case "MENU_SELECT":
					if ( removeListener )
					{
						SelManager.textFlow.removeEventListener( ContextMenuEvent.MENU_SELECT, eventHandler );
					}
					else if (addListener)
					{
						SelManager.textFlow.addEventListener( ContextMenuEvent.MENU_SELECT, eventHandler, false, 0, true );
						return null;
					}
					else
					{
						outEvent = new ContextMenuEvent( ContextMenuEvent.MENU_SELECT );
						return outEvent;
					}
					break;
				case "SELECT_ALL":
					if ( removeListener )
					{
						SelManager.textFlow.removeEventListener( Event.SELECT_ALL, eventHandler );
					}
					else if (addListener)
					{
						SelManager.textFlow.addEventListener( Event.SELECT_ALL, eventHandler, false, 0, true );
						return null;
					}
					else
					{
						outEvent = new Event( Event.SELECT_ALL );
						return outEvent;
					}
					break;
				case "COPY":
					if ( removeListener )
					{
						SelManager.textFlow.removeEventListener( Event.COPY, eventHandler );
					}
					else if (addListener)
					{
						SelManager.textFlow.addEventListener( Event.COPY, eventHandler, false, 0, true );
						return null;
					}
					else
					{
						outEvent = new Event( Event.COPY );
						return outEvent;
					}
					break;
				case "CUT":
					if ( removeListener )
					{
						SelManager.textFlow.removeEventListener( Event.CUT, eventHandler );
					}
					else if (addListener)
					{
						SelManager.textFlow.addEventListener( Event.CUT, eventHandler, false, 0, true );
						return null;
					}
					else
					{
						outEvent = new Event( Event.CUT );
						return outEvent;
					}
					break;
				case "PASTE":
					if ( removeListener )
					{
						SelManager.textFlow.removeEventListener( Event.PASTE, eventHandler );
					}
					else if (addListener)
					{
						SelManager.textFlow.addEventListener( Event.PASTE, eventHandler, false, 0, true );
						return null;
					}
					else
					{
						outEvent = new Event( Event.PASTE );
						return outEvent;
					}
					break;
			}

			return null;
   		}

   		// Generic event handler
   		// How can this be made more even specific?
   		private function eventHandler( event:Event ):void
   		{
   			SelManager.insertText("EVENT");
   		}

   		// Generic test case for all event overrides
   		public function testEventOverride():void
   		{
   			SelManager.insertText("StillHere");
   			SelManager.selectRange(9,9);

   			// Add event listener
   			eventFromText( TestData.eventOverride, true );

   			var newEvent:Event = eventFromText( TestData.eventOverride, false );
   			assertTrue( "Test Case Failure: Unable to find event specified in XML",
   						newEvent != null );
   			SelManager.textFlow.dispatchEvent(newEvent);

   			SelManager.flushPendingOperations();
   			assertTrue( TestData.eventOverride + " event was not executed after override",
						getAllText() == "StillHereEVENT" );
			assertTrue( TestData.eventOverride + " event shouldn't change selection",
						SelManager.activePosition == 14 && SelManager.anchorPosition == 14 );

			// Remove event listener
			eventFromText( TestData.eventOverride, false, true );
   		}
*/
/************** TESTS USING DERIVED EDITMANAGER **************************************************/

   		public function keyDownDerivedTest():void
   		{
   			SelManager.insertText("StillHere");
   			SelManager.selectRange(9,9);

   			// Send a Ctrl-Backspace
   			var kEvent:KeyboardEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN,
				true, false, 8, 8, KeyLocation.STANDARD, true, false, false);
			TestFrame.container["dispatchEvent"](kEvent);

			SelManager.flushPendingOperations();

			assertTrue( "Keyboard event executed normally when overridden",
						getText(0,9) == "StillHere" );

			assertTrue( "Keyboard event override was not executed",
						getAllText() == "StillHereKEYDOWN" );
   		}

   		public function mouseDownDerivedTest():void
   		{
   			var kEvent:MouseEvent = new MouseEvent( MouseEvent.MOUSE_DOWN, true, false, 0, 0 );
			TestFrame.container["dispatchEvent"](kEvent);

			SelManager.flushPendingOperations();

			assertTrue( "Mouse Down event override was not executed",
						getAllText() == "MOUSEDOWN" );
   		}

   		public function mouseMoveDerivedTest():void
   		{
   			(SelManager as TestEditManager).mouseMoved = false;
   			var kEvent:MouseEvent = new MouseEvent( MouseEvent.MOUSE_DOWN, true, false, 0, 0 );
			TestFrame.container["dispatchEvent"](kEvent);
   			var mEvent:MouseEvent = new MouseEvent( MouseEvent.MOUSE_MOVE, true, false,
   											 20, 20 );
			TestFrame.container["dispatchEvent"](mEvent);

			SelManager.flushPendingOperations();

			assertTrue( "Mouse Move event override was not executed",
						getAllText() == "MOUSEDOWNMOUSEMOVE" );
   		}

   		public function textEventDerivedTest():void
   		{
   			// Send 'a' string
   			var kEvent:TextEvent = new TextEvent( TextEvent.TEXT_INPUT, false, false, "a" );
			TestFrame.container["dispatchEvent"](kEvent);

			SelManager.flushPendingOperations();

			assertTrue( "Text Event override was not executed",
						getAllText() == "TEXTEVENT" );
   		}

   		public function focusInDerivedTest():void
   		{
   			var kEvent:FocusEvent = new FocusEvent( FocusEvent.FOCUS_IN );
			TestFrame.container["dispatchEvent"](kEvent);

			SelManager.flushPendingOperations();

			assertTrue( "Focus In override was not executed",
						getAllText() == "FOCUSIN" );
   		}

   		public function focusOutDerivedTest():void
   		{
   			var kEvent:FocusEvent = new FocusEvent( FocusEvent.FOCUS_OUT );
			TestFrame.container["dispatchEvent"](kEvent);

			SelManager.flushPendingOperations();

			assertTrue( "Focus Out override was not executed",
						getAllText() == "FOCUSOUT" );
   		}

   		public function activateDerivedTest():void
   		{
   			var kEvent:Event = new Event( Event.ACTIVATE );
			TestFrame.container["dispatchEvent"](kEvent);

			SelManager.flushPendingOperations();

			assertTrue( "Activate override was not executed",
						getAllText() == "ACTIVATE" );
   		}

   		public function deactivateDerivedTest():void
   		{
   			var kEvent:Event = new Event( Event.DEACTIVATE );
			TestFrame.container["dispatchEvent"](kEvent);

			SelManager.flushPendingOperations();

			assertTrue( "Deactivate override was not executed",
						getAllText() == "DEACTIVATE" );
   		}

   		public function deleteNextDerivedTest():void
   		{
   			(SelManager as TestEditManager).useDefaultKeyDown = true;

   			var kEvent:KeyboardEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN, true, false, 127, 46 );
			TestFrame.container["dispatchEvent"](kEvent);

			SelManager.flushPendingOperations();

			assertTrue( "Delete Next override was not executed by pressing 'Delete'",
						getAllText() == "DELETENEXT" );

			(SelManager as TestEditManager).useDefaultKeyDown = false;
   		}

   		public function deletePreviousDerivedTest():void
   		{
   			(SelManager as TestEditManager).useDefaultKeyDown = true;

   			var kEvent:KeyboardEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN, true, false, 8, 8 );
			TestFrame.container["dispatchEvent"](kEvent);

			SelManager.flushPendingOperations();

			assertTrue( "Delete Previous override was not executed by pressing 'Backspace'",
						getAllText() == "DELETEPREVIOUS" );

			(SelManager as TestEditManager).useDefaultKeyDown = false;
   		}

   		public function deleteNextWordDerivedTest():void
   		{
   			(SelManager as TestEditManager).useDefaultKeyDown = true;

   			var kEvent:KeyboardEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN, true, false, 127, 46, 0, true );
			TestFrame.container["dispatchEvent"](kEvent);

			SelManager.flushPendingOperations();

			assertTrue( "Delete Next override was not executed by pressing 'Ctrl-Delete'",
						getAllText() == "DELETENEXTWORD" );

			(SelManager as TestEditManager).useDefaultKeyDown = false;
   		}

   		public function deletePreviousWordDerivedTest():void
   		{
   			(SelManager as TestEditManager).useDefaultKeyDown = true;

   			var kEvent:KeyboardEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN, true, false, 8, 8, 0, true );
			TestFrame.container["dispatchEvent"](kEvent);

			SelManager.flushPendingOperations();

			assertTrue( "Delete Previous override was not executed by pressing 'Ctrl-Backspace'",
						getAllText() == "DELETEPREVIOUSWORD" );

			(SelManager as TestEditManager).useDefaultKeyDown = false;
   		}
	}
}

/********Editmanager for overriding events - Internal Helper Class**********************************/

import flashx.textLayout.edit.EditManager;
import flashx.undo.IUndoManager;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.events.TextEvent;
import flash.events.FocusEvent;
import flash.events.Event;
import flashx.textLayout.edit.SelectionState;

internal class TestEditManager extends EditManager
{
	public var mouseMoved:Boolean;
	public var useDefaultKeyDown:Boolean;

	public function TestEditManager(undo:IUndoManager = null)
	{
		super(undo);

		useDefaultKeyDown = false;

		// Don't react to this event and ruin a different test
		mouseMoved = true;
	}

	public override function keyDownHandler(event:KeyboardEvent):void
	{
		if ( useDefaultKeyDown == true )
			super.keyDownHandler(event);
		else
			insertText("KEYDOWN");
	}

	public override function mouseDownHandler(event:MouseEvent):void
	{ insertText("MOUSEDOWN"); }

	public override function mouseMoveHandler(event:MouseEvent):void
	{
		// Don't react to this event more than once
		if ( !mouseMoved)
		{
			insertText("MOUSEMOVE");
			mouseMoved = true;
		}
	}

	public override function textInputHandler(event:TextEvent):void
	{ insertText("TEXTEVENT"); }

	public override function focusInHandler(event:FocusEvent):void
	{ insertText("FOCUSIN"); }

	public override function focusOutHandler(event:FocusEvent):void
	{ insertText("FOCUSOUT"); }

	public override function activateHandler(event:Event):void
	{ insertText("ACTIVATE"); }

	public override function deactivateHandler(event:Event):void
	{ insertText("DEACTIVATE"); }

	/***** EDITMANAGER OVERRIDES *****/

	public override function deleteNextCharacter(operationState:SelectionState=null):void
	{ insertText("DELETENEXT"); }

	public override function deletePreviousCharacter(operationState:SelectionState=null):void
	{ insertText("DELETEPREVIOUS"); }

	public override function deleteNextWord(operationState:SelectionState=null):void
	{ insertText("DELETENEXTWORD"); }

	public override function deletePreviousWord(operationState:SelectionState=null):void
	{ insertText("DELETEPREVIOUSWORD"); }

}