// terminalkeyboardcons.cpp
// 
// Copyright (c) 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "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:
// Accenture - Initial contribution
//
#include "terminalkeyboardcons.h"
#include <fshell/common.mmh>
#include <e32debug.h>
#include <fshell/memoryaccess.h>

const TInt KTkbdMessageId = 0xD6;
// These are the defaults unless overridden by --console-size
const TInt KWidth = 80;
const TInt KHeight = 24;

class CMessageWatcher : public CActive
	{
public:
	CMessageWatcher(CTerminalKeyboardCons& aConsole)
		: CActive(CActive::EPriorityStandard), iConsole(aConsole)
		{
		CActiveScheduler::Add(this);
		iConsole.iDriver.RequestMessage(iStatus);
		SetActive();
		}

	void DoCancel()
		{
		iConsole.iDriver.CancelMessage();
		}

	void RunL()
		{
		iConsole.MessageReceived(iStatus.Int());
		if (iStatus.Int() == KErrNone)
			{
			iConsole.iDriver.RequestMessage(iStatus);
			SetActive();
			}
		}

	~CMessageWatcher()
		{
		Cancel();
		}

private:
	CTerminalKeyboardCons& iConsole;
	};


CTerminalKeyboardCons::CTerminalKeyboardCons()
	: iTracker(TSize(KWidth, KHeight), this)
	{
	}

CTerminalKeyboardCons::~CTerminalKeyboardCons()
	{
	delete iIdleUpdateTimer;
	CleanupUnderlyingConsole();
	delete iWatcher;
	iDriver.Close();
	iTextBuffer.Close();
	iMungedTextBuffer.Close();
	}

TInt CTerminalKeyboardCons::Create(const TDesC& aTitle, TSize aSize)
	{
	TRAPD(err, ConstructL(aTitle, aSize));
	HandleConsoleCreationError(_L("TerminalKeyboard"), err);
	return err;
	}

void CTerminalKeyboardCons::ConstructL(const TDesC& aTitle, const TSize& aSize)
	{
	if (aTitle == _L("debug")) SetDebug(ETrue);
	if (aSize.iWidth > 10 && aSize.iHeight > 10)
		{
		// Override size now we know it, checking that it's sane-ish - be sure to do this before anything that uses the console size!
		new (&iTracker) TCursorTracker(aSize, this);
		}

	iTextBuffer.CreateMaxL(ScreenSize().iWidth * ScreenSize().iHeight);
#ifdef SHOW_TEXTSHELL_BORDERS
	iMungedTextBuffer.CreateL((ScreenSize().iWidth + 2) * (ScreenSize().iHeight + 2));
#endif

	iIdleUpdateTimer = CPeriodic::NewL(CActive::EPriorityLow); // Lower priority than the message watcher

	TInt err = User::LoadLogicalDevice(KTcLddDriverName);
	if (err && err != KErrAlreadyExists)
		{
		Message(EError, _L("Couldn't load LDD %S: %d"), &KTcLddDriverName, err);
		User::Leave(err);
		}

	// Annoying driver only accepts connections from processes with nokia vid - like that will stop us
	TUint originalVid = RProcess().VendorId();
	RMemoryAccess memAccess;
	User::LeaveIfError(memAccess.Open());
	TProcessProperties props;
	props.iVid = 0x101FB657;
	RProcess me;
	User::LeaveIfError(me.Open(RProcess().Id()));
	memAccess.SetProcessProperties(me, props);

	err = iDriver.Open();

	props.iVid = originalVid;
	memAccess.SetProcessProperties(me, props);
	me.Close();
	memAccess.Close();

	if (err)
		{
		Message(EError, _L("Couldn't open RTcDriver: %d"), err);
		User::Leave(err);
		}

	err = iDriver.Subscribe(KTkbdMessageId);
	if (err)
		{
		Message(EError, _L("Couldn't subscribe: %d"), err);
		User::Leave(err);
		}

	iWatcher = new(ELeave) CMessageWatcher(*this);
	CleanupUnderlyingConsole();

	ClearScreen();
	}

	
TInt CTerminalKeyboardCons::Extension_(TUint aExtensionId, TAny*& a0, TAny* a1)
	{
	/*if (aExtensionId == ConsoleMode::KSetConsoleModeExtension)
		{
		ConsoleMode::TMode mode = (ConsoleMode::TMode)(TInt)a1;
		iInputController->SetMode(mode);
		iOutputController->SetMode(mode);
		return KErrNone;
		}
	else*/
	/*else if (aExtensionId == ConsoleAttributes::KSetConsoleAttributesExtension)
		{
		ConsoleAttributes::TAttributes* attributes = (ConsoleAttributes::TAttributes*)a1;
		return iOutputController->SetAttributes(attributes->iAttributes, attributes->iForegroundColor, attributes->iBackgroundColor);
		}*/
	
	TInt ret = MIosrvConsoleHelper_Extension(aExtensionId, a0, a1);
	if (ret == KErrExtensionNotSupported) ret = CConsoleBase::Extension_(aExtensionId, a0, a1);
	return ret;
	}

void CTerminalKeyboardCons::MessageReceived(TInt aError)
	{
	Message(EDebug, _L("MessageReceived err=%d"), aError);
	TInt err = aError;
	if (err == KErrNone)
		{
		TPtrC8 data;
		err = iDriver.GetMessageData(data);
		if (!err && data.Length() < 1) err = KErrCorrupt;
		if (!err && !iGotKey)
			{
			TUint16 rawkey = data[0];
			Message(EDebug, _L("CTerminalKeyboardCons got key %d"), (TInt)rawkey);

			// Terminal keyboard doesn't support control keys or cursor keys so we use our own two-stage sticky modifier (like unix meta key I think?)
			if (iBacktickModifierDown)
				{
				// Terminal keyboard sends 2,4,6,8 for cursors, so we translate backtick-2 (ie backtick-leftarrow) as meaning left arrow
				if (rawkey == '2') rawkey = (TUint16)EKeyUpArrow;
				else if (rawkey == '4') rawkey = (TUint16)EKeyLeftArrow;
				else if (rawkey == '6') rawkey = (TUint16)EKeyRightArrow;
				else if (rawkey == '8') rawkey = (TUint16)EKeyDownArrow;
				else if (rawkey >= 'a' && rawkey <= 'z')
					{
					// backtick-c means CTRL-C
					rawkey = rawkey - 'a'+1;
					}
				else if (rawkey == ' ') rawkey = '`'; // backtick-space is how you do a backtick
				else if (rawkey == '`') rawkey = (TUint16)EKeyEscape; // backtick-backtick is 'escape'
				else if (rawkey == '1') rawkey = (TUint16)EKeyTab; // backtick-1 is 'tab'
				iBacktickModifierDown = EFalse;
				Message(EDebug, _L("Backtick escape converted to %d"), (TInt)rawkey);
				}
			else if (rawkey == '`')
				{
				iBacktickModifierDown = ETrue;
				return;
				}

			iKeyCode = (TKeyCode)rawkey; // Close enough for now!
			iGotKey = ETrue;
			}
		}
	if (iClientStatus)
		{
		User::RequestComplete(iClientStatus, err);
		if (err == KErrNone) iGotKey = EFalse;
		}
	}

void CTerminalKeyboardCons::Read(TRequestStatus& aStatus)
	{
	/*if (iClientStatus)
		{
		TRequestStatus* stat = &aStatus;
		User::RequestComplete(stat, KErrInUse);
		}
	else*/
		{
		aStatus = KRequestPending;
		iClientStatus = &aStatus;
		if (iGotKey)
			{
			iGotKey = EFalse;
			User::RequestComplete(iClientStatus, KErrNone);
			}
		}
	}

void CTerminalKeyboardCons::ReadCancel()
	{
	if (iClientStatus)
		{
		User::RequestComplete(iClientStatus, KErrCancel);
		}
	}

void CTerminalKeyboardCons::Write(const TDesC& aDes)
	{
	for (TInt i = 0; i < aDes.Length(); i++)
		{
		TInt textBufPos = CursorPos().iY * ScreenSize().iWidth + CursorPos().iX;
		TChar ch(aDes[i]);
		iTracker.WriteChar(ch);
		if (ch.IsPrint()) iTextBuffer[textBufPos] = aDes[i];
		}

	Update();
	}
	
TPoint CTerminalKeyboardCons::CursorPos() const
	{
	return iTracker.CursorPos();
	}

void CTerminalKeyboardCons::SetCursorPosAbs(const TPoint& aPoint)
	{
	iTracker.SetCursorPosAbs(aPoint);
	}

void CTerminalKeyboardCons::SetCursorPosRel(const TPoint& aPoint)
	{
	iTracker.SetCursorPosRel(aPoint);
	}

void CTerminalKeyboardCons::SetCursorHeight(TInt /*aPercentage*/)
	{
	//iOutputController->SetCursorHeight(aPercentage);
	}

void CTerminalKeyboardCons::SetTitle(const TDesC& /*aDes*/)
	{
	//iOutputController->SetTitle(aDes);
	}

void CTerminalKeyboardCons::ClearScreen()
	{
	SetCursorPosAbs(TPoint(0,0));
	iTextBuffer.Fill(' ');
	Update();
	}

void CTerminalKeyboardCons::ClearToEndOfLine()
	{
	iTextBuffer.MidTPtr(CursorPos().iY * ScreenSize().iWidth + CursorPos().iX, ScreenSize().iWidth - CursorPos().iX).Fill(' ');
	Update();
	}

TSize CTerminalKeyboardCons::ScreenSize() const
	{
	return iTracker.ConsoleSize();
	}

TKeyCode CTerminalKeyboardCons::KeyCode() const
	{
	return iKeyCode;
	}

TUint CTerminalKeyboardCons::KeyModifiers() const
	{
	return iKeyModifiers;
	}

// All these magic vals are as per the DOS 437 codepage http://en.wikipedia.org/wiki/CP437 and not Windows-1252 like the ws_win.cpp source incorrectly states
// See also http://en.wikipedia.org/wiki/Box_drawing_characters
enum
	{
	EBoxHorizontalBar = 0xCD,
	EBoxVerticalBar = 0xBA,
	EBoxTopLeft = 0xC9,
	EBoxTopRight = 0xBB,
	EBoxBottomLeft = 0xC8,
	EBoxBottomRight = 0xBC,
	};

void CTerminalKeyboardCons::Update()
	{
	// Delay updates to the screen, to improve performance
	static const TInt KDelay = 100000; // 0.1s
	if (!iIdleUpdateTimer->IsActive())
		{
		// Don't reset timer if we're already running - otherwise constant typing will never show up until you stop pressing keys
		iIdleUpdateTimer->Start(KDelay, KDelay, TCallBack(&UpdateCallback, this));
		}
	}

TInt CTerminalKeyboardCons::UpdateCallback(TAny* aSelf)
	{
	static_cast<CTerminalKeyboardCons*>(aSelf)->DoUpdate();
	return 0;
	}

void CTerminalKeyboardCons::DoUpdate()
	{
	iIdleUpdateTimer->Cancel(); // Stop any further updates

#ifdef SHOW_TEXTSHELL_BORDERS
	// Update munged buffer
	const TInt contentWidth = ScreenSize().iWidth;
	const TInt width = contentWidth + 2;
	iMungedTextBuffer.SetLength(width);
	iMungedTextBuffer.Fill(TChar(EBoxHorizontalBar));
	iMungedTextBuffer[0] = EBoxTopLeft;
	iMungedTextBuffer[width-1] = EBoxTopRight;

	for (TInt i = 0; i < ScreenSize().iHeight; i++)
		{
		TPtrC line(iTextBuffer.Mid(i*contentWidth, contentWidth));
		iMungedTextBuffer.AppendFormat(_L("%c%S%c"), EBoxVerticalBar, &line, EBoxVerticalBar);
		}
	
	iMungedTextBuffer.Append(EBoxBottomLeft);
	iMungedTextBuffer.SetLength(iMungedTextBuffer.Length() + contentWidth);
	iMungedTextBuffer.RightTPtr(contentWidth).Fill(EBoxHorizontalBar);
	iMungedTextBuffer.Append(EBoxBottomRight);
	
	// And send the munged buffer
	Transmit(iMungedTextBuffer, width, ScreenSize().iHeight + 2);
#else
	// Just send it straight
	Transmit(iTextBuffer, ScreenSize().iWidth, ScreenSize().iHeight);
#endif
	}

void CTerminalKeyboardCons::Transmit(const TDesC& aBuf, TInt aWidth, TInt aHeight)
	{
	// This is how terminal keyboard does it - pretty horrible really

	static const TInt KMaxLen = 200; // This is what terminal keyboard uses - technically you could go as far as a total of 256
	TInt numLinesPerPrint = KMaxLen / aWidth;

	TBuf<256> line;
	TInt startLine = 0;
	while (startLine < aHeight)
		{
		if (startLine == 0)
			{
			// First line has extra info
			line.Format(_L("#$STIConsole#$%02d%02X%02X"), startLine, aWidth, aHeight);
			}
		else
			{
			line.Format(_L("#$STIConsole#$%02d"), startLine);
			}

		for (TInt i = 0; i < numLinesPerPrint; i++)
			{
			TPtrC theContents(aBuf.Mid((startLine+i)*aWidth, aWidth));
			//RDebug::Printf("line len=%d theContents len=%d", line.Length(), theContents.Length());
			line.Append(theContents);
			}

		RDebug::Print(line);
		startLine += numLinesPerPrint;
		}
	}

void CTerminalKeyboardCons::ConsoleScrolled(TInt aNumberOfLines)
	{
	TInt numChars = Abs(aNumberOfLines) * ScreenSize().iWidth;
	if (aNumberOfLines > 0)
		{
		iTextBuffer.Delete(0, numChars);
		iTextBuffer.AppendFill(' ', numChars);
		}
	else if (aNumberOfLines < 0)
		{
		iTextBuffer.SetLength(iTextBuffer.Length() - numChars);
		while (numChars--) iTextBuffer.Insert(0, _L(" "));
		}
	}

extern "C" EXPORT_C TAny* NewConsole()
	{
	return new CTerminalKeyboardCons;
	}