// sql.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 <fshell/common.mmh>

#include <fshell/ioutils.h>
using namespace IoUtils;

class TResponseLex
	{
public:
	TResponseLex(const TDesC& aResponse);
	
	TInt GetIntColon(TInt& aValue);
	TInt GetStringColon(TPtrC& aValue);
	TInt GetIntEof(TInt& aValue);
	TPtrC Remainder();
private:
	TPtrC iRemainder;
	};

class CCmdSqlCli : public CClientBase
	{
public:
/*	
	static const TDesC* PowerConsumptionToString(TPositionQuality::TPowerConsumption aPower);
	static void CapabilitiesToString(TPositionModuleInfo::TCapabilities aCap, TDes &aDes);
*/	
	void PrintTime(const TTime& aTime, TBool aNewline);	
	static CCommandBase* NewLC();
	~CCmdSqlCli();
private:
	enum TLineProcessingBehaviour
		{
		EIgnoreLines,
		EProcessLines,
		};
	
	CCmdSqlCli();
	
	void ProcessLineL(const TDesC& aLine);
	TBool MatchLineStart(const TDesC& aPrefix, TPtrC& aRemainder);
	void ProcessErrorL(const TDesC& aDes);
	void ProcessFailureL(const TDesC& aDes);
	void UnrecognizedLineL(const TDesC& aDes);
	void ProcessAsyncIdL(const TDesC& aDes);
	void ProcessTimeoutL(const TDesC& aDes);
	void ProcessResultL(const TDesC& aDes);
	
	void ProcessLogL(const TDesC& aDes);


private: // From CCommandBase.
	virtual const TDesC& Name() const;
	virtual void OptionsL(RCommandOptionList& aOptions);
	// From CClientBase.
	virtual void HandleServerResponseL(RPointerArray<HBufC> aLines);		
	};

///////////////////////////////////////////////////////////////////////////////

_LIT(KPersistentConsoleName, "fshell_sqlsrv");
_LIT(KSrvExeName, "fshell_sqlsrv");
_LIT(KNewLine, "\r\n");
_LIT(KPrompt, "ok\r\n");
_LIT(KErrorPrefix, "error:");
_LIT(KFailurePrefix, "failure:");
_LIT(KAsyncIdPrefix, "id:");
_LIT(KTimeoutPrefix, "timedout:");
_LIT(KResultPrefix, "result:");
_LIT(KLogPrefix, "log:");
_LIT(KColon, ":");


CCommandBase* CCmdSqlCli::NewLC()
	{
	CCmdSqlCli* self = new (ELeave)CCmdSqlCli();
	CleanupStack::PushL(self);
	self->BaseConstructL();
	return self;
	}

CCmdSqlCli::CCmdSqlCli()
	: CClientBase(0, KSrvExeName, KPersistentConsoleName, KPrompt)
	{
	//iActiveWait = new (ELeave) CActiveSchedulerWait;	
	}


CCmdSqlCli::~CCmdSqlCli()
	{
	}

//////////////////////////////////////////////////////


//////////////////////////////////////////////////////

const TDesC& CCmdSqlCli::Name() const
	{
	_LIT(KName, "sql");
	return KName;
	}

void CCmdSqlCli::OptionsL(RCommandOptionList& aOptions)
	{
	_LIT(KVerbose, "verbose");
	aOptions.AppendBoolL(iVerbose, KVerbose);
	}

void CCmdSqlCli::HandleServerResponseL(RPointerArray<HBufC> aLines)
	{
	const TInt numLines = aLines.Count();
	for (TInt i = 0; i < numLines; ++i)
		{
		ProcessLineL(*aLines[i]);
		}
	}

TBool CCmdSqlCli::MatchLineStart(const TDesC& aPrefix, TPtrC& aRemainder)
	{
	if (aRemainder.Left(aPrefix.Length()).Compare(aPrefix)==0)
		{
		aRemainder.Set(aRemainder.Mid(aPrefix.Length()));
		return ETrue;
		}
	return EFalse;
	}

void CCmdSqlCli::UnrecognizedLineL(const TDesC& aDes)
	{
	if (!iVerbose)
		{
		Write(aDes);
		Write(KNewLine);
		}
	}

void CCmdSqlCli::ProcessLogL(const TDesC& aDes)
	{
	TResponseLex lex(aDes);
	TInt id;
	TInt err = lex.GetIntColon(id);
	if (err != KErrNone)
		{
		UnrecognizedLineL(aDes);
		}
	}

void CCmdSqlCli::ProcessLineL(const TDesC& aLine)
	{
	TPtrC remainder(aLine);
	if (MatchLineStart(KErrorPrefix, remainder))
		{
		ProcessErrorL(remainder);
		}
	else if (MatchLineStart(KFailurePrefix, remainder))
		{
		ProcessFailureL(remainder);
		}
	else if (MatchLineStart(KAsyncIdPrefix, remainder))
		{
		ProcessAsyncIdL(remainder);
		}
	else if (MatchLineStart(KTimeoutPrefix, remainder))
		{
		ProcessTimeoutL(remainder);
		}
	else if (MatchLineStart(KResultPrefix, remainder))
		{
		ProcessResultL(remainder);
		}
	else if (MatchLineStart(KLogPrefix, remainder))
		{
		ProcessLogL(remainder);
		}
	else
		{
		UnrecognizedLineL(aLine);
		}
	}

void CCmdSqlCli::ProcessErrorL(const TDesC& aDes)
	{
	TResponseLex lex(aDes);
	TInt commandId;
	TInt errorFromServer;
	TInt err = lex.GetIntColon(errorFromServer);
	if (err == KErrNone)
		{
		err = lex.GetIntColon(commandId);
		}
		
	if (err == KErrNone)
		{
		TPtrC remander = lex.Remainder();
		LeaveIfErr(errorFromServer, remander);
		}
	else
		{
		UnrecognizedLineL(aDes);
		}
	}

void CCmdSqlCli::ProcessFailureL(const TDesC&)
	{
	LeaveIfErr(KErrGeneral, _L("Failed"));
	}
	
void CCmdSqlCli::ProcessAsyncIdL(const TDesC& aDes)
	{
	TResponseLex lex(aDes);
	TInt id;
	TInt err = lex.GetIntEof(id);
	if (err != KErrNone)
		{
		UnrecognizedLineL(aDes);
		}
	}

void CCmdSqlCli::ProcessTimeoutL(const TDesC& aDes)
	{
	TResponseLex lex(aDes);
	TInt id;
	TInt err = lex.GetIntEof(id);
	if (err == KErrNone)
		{
		LeaveIfErr(KErrTimedOut, _L("Command %d timed-out"), id);
		}
	else
		{
		UnrecognizedLineL(aDes);
		}
	}
	
void CCmdSqlCli::ProcessResultL(const TDesC& aDes)
	{
	TResponseLex lex(aDes);
	TInt id;
	TInt err = lex.GetIntColon(id);
	if (err == KErrNone)
		{
		if (id == 0)
			{
			TPtrC name;
			err = lex.GetStringColon(name);
			if (err == KErrNone)
				{
				Write(lex.Remainder());
				Write(KNewLine);
				}
			}
		}
	if (err != KErrNone)
		{
		UnrecognizedLineL(aDes);
		}
	}



EXE_BOILER_PLATE(CCmdSqlCli)

#define CASE_MODELIT(x) case x: { _LIT(KName, #x); pString = &KName; break; }

void CCmdSqlCli::PrintTime(const TTime& aTime, TBool aNewline)
	{	
	TTime NullTime = Time::NullTTime();
	if (aTime == NullTime) 
		{
		Printf(_L("(NullTime)"));
		}
	else
		{
		_LIT8(KDateTimeFormat, "%d-%02d-%02d %02d:%02d:%02d");
		TDateTime dt = aTime.DateTime();
		Printf(KDateTimeFormat, dt.Year(), dt.Month()+1, dt.Day()+1, dt.Hour(), dt.Minute(), dt.Second());
		}
	
	if (aNewline) Printf(_L("\r\n"));
	}


///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
TResponseLex::TResponseLex(const TDesC& aResponse)
	: iRemainder(aResponse)
	{
	}

TInt TResponseLex::GetIntColon(TInt& aValue)
	{
	TInt pos = iRemainder.Find(KColon);
	if (pos == KErrNotFound)
		{
		return pos;
		}
	TPtrC intStr(iRemainder.Left(pos));
	TLex lex(intStr);
	TInt err = lex.Val(aValue);
	if (err!=KErrNone) return err;
	if (lex.Remainder().Length()) return KErrArgument;
	iRemainder.Set(iRemainder.Mid(pos+1));
	return KErrNone;
	}

TInt TResponseLex::GetStringColon(TPtrC& aValue)
	{
	TInt pos = iRemainder.Find(KColon);
	if (pos == KErrNotFound)
		{
		return pos;
		}
	aValue.Set(iRemainder.Left(pos));
	iRemainder.Set(iRemainder.Mid(pos+1));
	return KErrNone;
	}
	
TInt TResponseLex::GetIntEof(TInt& aValue)
	{
	TLex lex(iRemainder);
	TInt err = lex.Val(aValue);
	if (err==KErrNone)
		{
		if (lex.Remainder().Length()) err = KErrArgument;
		}
	if (err==KErrNone)
		{
		iRemainder.Set(lex.Remainder());
		}
	return err;
	}

TPtrC TResponseLex::Remainder()
	{
	return iRemainder;
	}