// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// YShifting, Wserv gradual reduction of YOffset test code
// 
//

/**
 @file
 @test
 @internalComponent - Internal Symbian test code 
*/

#include "PARSEINIDATA.H"
#include "tptroffset.h"
#include <e32cmn.h>
#include <hal.h>

//#define FAILLOG 1			// Uncomment this code to get detailed log

//CTPointerOffsetBuffer
CTPointerOffsetBuffer::CTPointerOffsetBuffer(RWsSession *aWs, CTPointerOffsetTest *aTest, CTPointerOffsetClient* aClient) 
	: CTEvent(aWs), iTest(aTest), iClient(aClient)
	{
	}

CTPointerOffsetBuffer::~CTPointerOffsetBuffer()
	{
	}

void CTPointerOffsetBuffer::ConstructL()
	{
	CTEventBase::Construct();
	iEventBuffer.SetLengthL(EEventBufferSize);
	}

void CTPointerOffsetBuffer::AddExpectedEvent(TWsEvent &aEvent)
	{
	iEventBuffer.Add(&aEvent);
	}

TInt CTPointerOffsetBuffer::EventsRemaining()
	{
	return iEventBuffer.Count();
	}


// Main function which gets the event, checks with the event in buffer
// Then calls function NextSetOfEventsL for running other tests of a particualar test case
void CTPointerOffsetBuffer::doRunL()
	{
	// Get the event from wserv
	TWsEvent wsEvent;
	iWs->GetEvent(wsEvent);

	TWsEvent expectedEvent;
	TInt wsType=wsEvent.Type();
	
	// if this is called accidentally
	TInt count=iEventBuffer.Count();
	if (count==0 && wsType==EEventFocusGained)
		{
		goto End;
		}

	iEventBuffer.Remove(&expectedEvent);
	iEventCount++;
	
#if defined(FAILLOG)	
	TLogMessageText logText;
	_LIT(KEventCountCheck, "Checking event number = %d");
	logText.Format(KEventCountCheck, iEventCount);
	iTest->LOG_MESSAGE(logText);
	_LIT(KEventType, "Actual Event type from Wserv = %d Expected Event Type = %d ");
	logText.Format(KEventType, wsEvent.Type(), expectedEvent.Type());
	iTest->LOG_MESSAGE(logText);
#endif
	
	TestL(wsEvent.Type() == expectedEvent.Type());
	
#if defined(FAILLOG)
	_LIT(KEventHandle, "Actual Window Handle from Wserv = %d Expected Window Handle = %d ");
	logText.Format(KEventHandle, wsEvent.Handle(), expectedEvent.Handle());
	iTest->LOG_MESSAGE(logText);
#endif    
	TestL(wsEvent.Handle() == expectedEvent.Handle());
	
	TAdvancedPointerEvent *expectedPointerEvent = expectedEvent.Pointer();
    TAdvancedPointerEvent *actualPointerEvent = wsEvent.Pointer();
    
    if (wsType == EEventPointer)
    	{
#if defined(FAILLOG)
		_LIT(KPointerType, "Actual PointerType from Wserv = %d Expected PointerType = %d ");
		logText.Format(KPointerType, actualPointerEvent->iType, expectedPointerEvent->iType);
		iTest->LOG_MESSAGE(logText);
#endif
		TestL(actualPointerEvent->iType == expectedPointerEvent->iType);
		
#if defined(FAILLOG)
		_LIT(KPointerPosition, "Actual PointerPosition from Wserv = (%d, %d) Expected PointerPosition = (%d, %d) ");
		logText.Format(KPointerPosition, actualPointerEvent->iPosition.iX, actualPointerEvent->iPosition.iY, expectedPointerEvent->iPosition.iX, expectedPointerEvent->iPosition.iY);
		iTest->LOG_MESSAGE(logText);
#endif
		TestL(actualPointerEvent->iPosition == expectedPointerEvent->iPosition);
		
#if defined(FAILLOG)
		_LIT(KPointerNumber, "Actual PointerNumber from Wserv = %d Expected PointerNumber = %d ");
		logText.Format(KPointerNumber, actualPointerEvent->PointerNumber(), expectedPointerEvent->PointerNumber());
		iTest->LOG_MESSAGE(logText);
#endif		
		TestL(actualPointerEvent->PointerNumber() == expectedPointerEvent->PointerNumber());
    	}
	
End:
	// Call NextSetOfEvents() when all the events have been checked
	if (iEventBuffer.Count()==0)	
		{
		iTest->NextSetOfEventsL();		// Cannot Leave
		}
	}

void CTPointerOffsetBuffer::TestL(TInt aTest)
	{
	if (!aTest)
		{
		iTest->Failed();
		User::Leave(ETestFailed);
		}
	}

//CTPointerOffsetClient
CTPointerOffsetClient::CTPointerOffsetClient(CTPointerOffsetTest *aTest) 
	: iTest(aTest)
	{
	}

CTPointerOffsetClient::~CTPointerOffsetClient()
	{
	delete iWin;
	}

void CTPointerOffsetClient::ConstructL()
	{
	CTClient::ConstructL();
	
	// Create a group window and assign it iGroup
	iGroup = new(ELeave) CTWindowGroup(this);
	iGroup->ConstructL();
	
	iWinSize = iScreen->SizeInPixels();
	iWinPos = TPoint();
	
	// Create window for this client so that events can come to this client
	iWin=new(ELeave) CTBlankWindow();
	iWin->ConstructL(*iGroup);
	iWin->SetExt(iWinPos, iWinSize);
	iWin->SetColor(KRgbRed);
	iWin->BaseWin()->EnableAdvancedPointers();
	iWin->Activate();
	iWs.Flush();
	}

void CTPointerOffsetClient::AddExpectedPointerEvent(TPointerEvent::TType aType, TPoint aPos, TUint8 aPointerNumber, TUint aHandle)
	{
	TWsEvent ptrEvent;
	ptrEvent.SetType(EEventPointer);
	ptrEvent.Pointer()->iParentPosition = aPos;
	ptrEvent.Pointer()->iType = aType;
	ptrEvent.Pointer()->iPosition = aPos;
	ptrEvent.SetPointerNumber(aPointerNumber);
	if (!aHandle)
		ptrEvent.SetHandle((TUint)iWin);
	else
		ptrEvent.SetHandle(aHandle);

	static_cast<CTPointerOffsetBuffer*>(iEventHandler)->AddExpectedEvent(ptrEvent);
	}

void CTPointerOffsetClient::AddExpectedWsEvent(TEventCode aType, TInt /*aPointerNumber*/, TUint aHandle)
	{
	TWsEvent ptrEvent;
	ptrEvent.SetType(aType);
	if (!aHandle)
		ptrEvent.SetHandle((TUint)iGroup);
	else
		ptrEvent.SetHandle(aHandle);
	static_cast<CTPointerOffsetBuffer*>(iEventHandler)->AddExpectedEvent(ptrEvent);
	}

// Create and store CTPointerOffsetBuffer in iEventHandler
void CTPointerOffsetClient::ConstructEventHandlerL()
	{
	CTPointerOffsetBuffer* eventBufferAndHandler = new(ELeave) CTPointerOffsetBuffer(&iWs, iTest, this);
	eventBufferAndHandler->ConstructL();
	iEventHandler = eventBufferAndHandler;
	}

//CTPointerOffsetTest
CTPointerOffsetTest::CTPointerOffsetTest(CTestStep* aStep)
	: CTWsGraphicsBase(aStep)
	{
	}

CTPointerOffsetTest::~CTPointerOffsetTest()
	{
	delete iPointerOffsetClient;
	}

void CTPointerOffsetTest::ConstructL()
	{
	// If YOffsetValues are not defined in wsini file then just return without doing anything
    _LIT(KWsIniFile, "z:\\system\\data\\wsini.ini");
    CIniData* iniData = CIniData::NewL(KWsIniFile, ' ');
    _LIT( KWsiniYShiftingTop, "YSHIFTINGTOP");
    if (iniData->FindVar(KWsiniYShiftingTop, iYOffsetTop) == EFalse)
    	goto FAIL;
    _LIT( KWsiniYShiftingBottom, "YSHIFTINGBOTTOM");
    if (iniData->FindVar(KWsiniYShiftingBottom, iYOffsetBottom) == EFalse)
    	goto FAIL;
    _LIT( KWsiniYShiftingMax, "YSHIFTINGMAX");
    if (iniData->FindVar(KWsiniYShiftingMax, iYOffsetMax) == EFalse)
    	goto FAIL;
    delete iniData;
    
    if (!iYOffsetTop || !iYOffsetBottom || !iYOffsetMax)
    	{
FAIL:	
		delete iniData;
		TLogMessageText logText1;
		_LIT(KWrongHALConfig, "Y Offset values are incorrect. \n");
		logText1.Append(KWrongHALConfig);
		LOG_MESSAGE(logText1);
		TEST(EFalse);
		User::Leave(KErrArgument);
    	}
    iPhysicalScreenSize = TheClient->iScreen->SizeInPixels();
    
    // If we fail to get the maxpointernumber then just test with single pointer
	TInt ret = HAL::Get(HALData::EPointerMaxPointers, iMaxPointerNumbers);
	if (ret != KErrNone || iMaxPointerNumbers < 2 || iMaxPointerNumbers > 8)
		{
		iMaxPointerNumbers = 1;
		}
	}

// Common function for all tests
// Important point to remember is that this function should not leave when running tests
void CTPointerOffsetTest::NextSetOfEventsL()
	{
	// For each test case calls its respective tests
	switch (iTest->iState)
		{
	case 0:
		TestYOffsetValues();
		break;
	case 1:
		TestYOffsetValues();	
		break;
	default:
		AutoPanic(EAutoPanicWrongTest);
		}
	}

void CTPointerOffsetTest::SimulatePointerEvent(TRawEvent::TType aType, TInt aX, TInt aY, TUint8 aPointerNumber)
	{
	TRawEvent rawEvent;
	rawEvent.Set(aType, aX, aY, 0, aPointerNumber);
	UserSvr::AddEvent(rawEvent);
	}

void CTPointerOffsetTest::AddExpectedPointerEvent(TPointerEvent::TType aType, TInt aX, TInt aY, TUint8 aPointerNumber, TUint aHandle)
	{
	iPointerOffsetClient->AddExpectedPointerEvent(aType, TPoint(aX, aY), aPointerNumber, aHandle);
	}

void CTPointerOffsetTest::AddExpectedWsEvent(TEventCode aType, TInt aPointerNumber, TUint aHandle)
	{
	iPointerOffsetClient->AddExpectedWsEvent(aType, aPointerNumber, aHandle);
	}

// If any of the Tests fails, bring the wserv in a consistent state for other test to run, 
// stop ActiveScheduler and display some logs where the fail occured.
void CTPointerOffsetTest::Failed()
	{
	// Display the test case number, subtest case number and number of events left in the buffer which can be used to
	// find out which event actually caused the failure when any test fails
	TLogMessageText logText1;
	_LIT(KEventsAdded, "Test case number %d Sub test case number %d Events remaining in the buffer %d \n");
	logText1.AppendFormat(KEventsAdded, iTest->iState, iEventSet, iPointerOffsetClient->EventBuffer()->EventsRemaining());
	LOG_MESSAGE(logText1);
	RDebug::Printf("Test case number %d Sub test case number %d Events remaining in the buffer %d \n", iTest->iState, iEventSet, iPointerOffsetClient->EventBuffer()->EventsRemaining());

	CActiveScheduler::Stop();
	iFailed=ETrue;
	}

// Get YValue after applying YOffset using iYOffsetTop, iYOffsetBottom and iYOffsetMax variables.
// Depending upon the Y poistion of input, yOffset is gradually reduced from top of the screen to 
// bottom of the screen.
TInt CTPointerOffsetTest::GetShiftedYValue(TInt aY)
	{
	if (!iYOffsetTop || !iYOffsetMax || !iYOffsetBottom)
		return aY;
	
	TInt offset = 0;
	TInt returnValue = aY;
	TInt displayHeight = TheClient->iScreen->SizeInPixels().iHeight;
	if (aY >= iYOffsetMax)
		{
		// Gradual reduction of Yoffset depending upon the aY value
		offset = iYOffsetTop + iYOffsetBottom - (iYOffsetTop * aY / displayHeight );
		if ( offset > iYOffsetMax )
			{
			offset = iYOffsetMax;
			}
		returnValue -= offset; 
		if (returnValue > (displayHeight-1))
			{
			returnValue = displayHeight-1; 
			}
		}
	else
		{
		returnValue = 0;
		}
	
	return returnValue;
	}

// Common function for all test cases
void CTPointerOffsetTest::RunTestsL()
	{
	// Create CTPointerOffsetClient for each test case and call NextSetOfEventsL()
	iPointerOffsetClient = new(ELeave) CTPointerOffsetClient(this);
	iPointerOffsetClient->SetScreenNumber(iTest->iScreenNumber);
	iPointerOffsetClient->ConstructL();
	
	iEventSet=0;

	TRAPD(err, NextSetOfEventsL());
	if (err != KErrNone)
		{
		iFailed = ETrue;
		}

	// Start nested activescheduler if it is not failed
	if (!iFailed)
		{
		CActiveScheduler::Start();
		}

	TInt eventsRem = iPointerOffsetClient->EventBuffer()->EventsRemaining();
	if (eventsRem > 0)
		{
		iFailed=ETrue;
		}
	
	delete iPointerOffsetClient;
	iPointerOffsetClient = NULL;
	}

// This function is called by TestExecute Framework, through which all the testcases are run
void CTPointerOffsetTest::RunTestCaseL(TInt /*aCurTestCase*/)
	{
	_LIT(KTest0, "PointerOffset tests");
	_LIT(KTest1, "PointerOffset tests for other pointer");
	
	switch(iTest->iState)
		{
	case 0:
		iTest->LogSubTest(KTest0);
		iPointerNumber = 0;
		RunTestsL();
		break;
	case 1:
		if (iMaxPointerNumbers == 1)
			{
			TestComplete();
			}
		else
			{
			iTest->LogSubTest(KTest1);
			iPointerNumber = iMaxPointerNumbers-1;
			RunTestsL();
			}
		break;
	case 2:
		// Keep this code in last case statement for main test completion 
		TestComplete();
		break;
	default:
		AutoPanic(EAutoPanicWrongTest);
		}

	// 
	if (iFailed)
		{
		TEST(EFalse);
		iFailed=EFalse;
		}
	++iTest->iState;
	}


void CTPointerOffsetTest::TestYOffsetValues()
	{
	TLogMessageText logText;
	_LIT(KSet, "Offset tests number : %d of 5");
	logText.AppendFormat(KSet, iEventSet);
	LOG_MESSAGE(logText);
	
	TPoint simulatedPos(iPhysicalScreenSize.iWidth/2, iPhysicalScreenSize.iHeight/2);
	TPoint expectedPos(simulatedPos);
	switch(iEventSet++)
		{
		case 0:
			// Test any point which has Y value less than YOffsetMax, where Y position would be 0
			simulatedPos.iY = iYOffsetMax - 1;
			SimulatePointerEvent(TRawEvent::EButton1Down, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
			SimulatePointerEvent(TRawEvent::EButton1Up, simulatedPos.iX, simulatedPos.iY, iPointerNumber);

			expectedPos.iY = 0;
			AddExpectedWsEvent(EEventFocusGained);
			AddExpectedPointerEvent(TPointerEvent::EButton1Down, expectedPos.iX, expectedPos.iY, iPointerNumber);
			AddExpectedPointerEvent(TPointerEvent::EButton1Up, expectedPos.iX, expectedPos.iY, iPointerNumber);
			break;
		case 1:
			// Test any point which has Y value just over YOffsetMax
			simulatedPos.iY = iYOffsetMax + 1;
			SimulatePointerEvent(TRawEvent::EButton1Down, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
			SimulatePointerEvent(TRawEvent::EButton1Up, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
			
			expectedPos.iY = GetShiftedYValue(simulatedPos.iY); 
			AddExpectedPointerEvent(TPointerEvent::EButton1Down, expectedPos.iX, expectedPos.iY, iPointerNumber);
			AddExpectedPointerEvent(TPointerEvent::EButton1Up, expectedPos.iX, expectedPos.iY, iPointerNumber);
			break;
		case 2:
			// Test any point which has Y value middle of the screen
			SimulatePointerEvent(TRawEvent::EButton1Down, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
			SimulatePointerEvent(TRawEvent::EButton1Up, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
			
			expectedPos.iY = GetShiftedYValue(simulatedPos.iY); 
			AddExpectedPointerEvent(TPointerEvent::EButton1Down, expectedPos.iX, expectedPos.iY, iPointerNumber);
			AddExpectedPointerEvent(TPointerEvent::EButton1Up, expectedPos.iX, expectedPos.iY, iPointerNumber);
			break;
		case 3:
			// Test any point which has Y value less than bottommost of the screen
			simulatedPos.iY = iPhysicalScreenSize.iHeight - 10;
			SimulatePointerEvent(TRawEvent::EButton1Down, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
			SimulatePointerEvent(TRawEvent::EButton1Up, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
			
			expectedPos.iY = GetShiftedYValue(simulatedPos.iY); 
			AddExpectedPointerEvent(TPointerEvent::EButton1Down, expectedPos.iX, expectedPos.iY, iPointerNumber);
			AddExpectedPointerEvent(TPointerEvent::EButton1Up, expectedPos.iX, expectedPos.iY, iPointerNumber);
			break;
		case 4:
			// Test any point which has Y value at bottom of the screen
			// As pixels are zero counted and so it cannot be >= iPhysicalScreenSize.iHeight 
			simulatedPos.iY = iPhysicalScreenSize.iHeight-1;
			SimulatePointerEvent(TRawEvent::EButton1Down, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
			SimulatePointerEvent(TRawEvent::EButton1Up, simulatedPos.iX, simulatedPos.iY, iPointerNumber);
			
			expectedPos.iY = GetShiftedYValue(simulatedPos.iY); 
			AddExpectedPointerEvent(TPointerEvent::EButton1Down, expectedPos.iX, expectedPos.iY, iPointerNumber);
			AddExpectedPointerEvent(TPointerEvent::EButton1Up, expectedPos.iX, expectedPos.iY, iPointerNumber);
			break;
		default:
			CActiveScheduler::Stop();
		}
	}
// Macro which is used for construction of CTPointerOffsetTestStep object
// and also used to call CreateTestL() which creates CTPointerOffsetTest and CTestBase objects
__WS_CONSTRUCT_STEP__(PointerOffsetTest)