// cloggerconfig.cpp
// 
// Copyright (c) 2007 - 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/ioutils.h>
#include <fshell/clogger.h>
#include <BADESCA.H>
#include <e32msgqueue.h>

using namespace IoUtils;

class CCmdCloggerConfig : public CCommandBase
	{
public:
	static CCommandBase* NewLC();
	~CCmdCloggerConfig();
private:
	CCmdCloggerConfig();
	void PrintLogL();
	void GetBackupFileNameL(TFileName& aName);
	void SetAllL(TBool aEnabled);
private: // From CCommandBase.
	virtual const TDesC& Name() const;
	virtual void DoRunL();
	virtual void ArgumentsL(RCommandArgumentList& aArguments);
	virtual void OptionsL(RCommandOptionList& aOptions);
private:
	RClogger iClogger;
	RCloggerLogConsumer iLogGetter;
	TUint iGlobalOptions;
	TBool iPersist;
	TBool iReset;
	HBufC* iTagName;
	TUint iEnabledMask;
	TUint iRotateOptions;
	TBool iRotate;
	TBool iFollow;
	TBool iWipe;
	TInt iNumBuffers;
	TInt iBufferSize;
	RBuf iTempBuffer;
	TBool iRdebug;
	TBool iBackup;
	TBool iRestore;
	TBool iDisableAll;
	TBool iEnableAll;
	};


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

CCmdCloggerConfig::~CCmdCloggerConfig()
	{
	iClogger.Close();
	iLogGetter.Close();
	delete iTagName;
	iTempBuffer.Close();
	}

CCmdCloggerConfig::CCmdCloggerConfig()
	{
	}

const TDesC& CCmdCloggerConfig::Name() const
	{
	_LIT(KName, "cloggerconfig");	
	return KName;
	}

#define WRITEIF(opt, flag) if (opt & (RClogger :: flag)) { Write(_L(#flag)); Write(_L(" ")); }

void CCmdCloggerConfig::DoRunL()
	{
	if (iEnableAll && iDisableAll)
		{
		LeaveIfErr(KErrArgument, _L("Can't enable and disable all tags"));
		}

	User::LeaveIfError(iClogger.Connect());

	TBool listSettings = ETrue;
	if (iReset)
		{
		iClogger.ResetSettings();
		listSettings = EFalse;
		}
	
	if (iOptions.IsPresent(&iGlobalOptions))
		{
		iClogger.SetGlobalOptions(iGlobalOptions);
		listSettings = EFalse;
		}
	if (iOptions.IsPresent(&iRotateOptions))
		{
		TInt n;
		iClogger.GetRotateBehaviour(&n);
		iClogger.SetRotateBehaviour(n, iRotateOptions);
		listSettings = EFalse;
		}
	if (iNumBuffers || iBufferSize)
		{
		if (iNumBuffers == 0)
			{
			// Need to read it in as we have to set both at once.  Bad API...
			iClogger.GetRamBufferSize(&iNumBuffers);
			}
		if (iBufferSize == 0)
			{
			// Same reason as above
			iBufferSize = iClogger.GetRamBufferSize(NULL);
			}
		iClogger.SetRamBufferSize(iBufferSize, iNumBuffers);
		listSettings = EFalse;
		}
	if (iPersist || iBackup || iRestore)
		{
		// We don't do anything here, we take action at the end of this function
		listSettings = EFalse;
		}
	if (iRotate)
		{
		TFileName name;
		TInt err = iClogger.Rotate(name);
		Printf(_L("Log rotated to %S\r\n"), &name);
		if (err) PrintError(err, _L("Rotate returned error"));
		listSettings = EFalse;
		}
	else if (iWipe)
		{
		TInt oldLogs;
		TUint rotopt = iClogger.GetRotateBehaviour(&oldLogs);
		iClogger.SetRotateBehaviour(KMaxTInt, RClogger::EDoNothingSpecial); // Change rotate behaviour temporarily
		
		TFileName name;
		TInt err = iClogger.Rotate(name);
		//Printf(_L("Log rotated to %S\r\n"), &name);
		if (err) PrintError(err, _L("Rotate returned error"));
		else
			{
			err = FsL().Delete(name);

			iClogger.SetRotateBehaviour(oldLogs, rotopt); // Restore old behaviour
			LeaveIfErr(err, _L("Couldn't remove wiped log %S"), &name);
			}

		listSettings = EFalse;
		}

	if (iDisableAll)
		{
		SetAllL(EFalse);
		listSettings = EFalse;
		}

	if (iEnableAll)
		{
		SetAllL(ETrue);
		listSettings = EFalse;
		}

	if (iRdebug)
		{
		TUint opts = iClogger.GetGlobalOptions();
		opts |= RClogger::ERedirectRDebugPrintToClogger;
		iClogger.SetGlobalOptions(opts);
		
		PrintLogL();
		}

	if (iFollow)
		{
		PrintLogL(); // Does not return
		}

	if (iArguments.IsPresent(1))
		{
		// Set
		TInt err = iClogger.SetEnabled(*iTagName, iEnabledMask);
		if (err == KErrNotFound)
			{
			PrintError(err, _L("Tag does not exist, couldn't set it. (NOTE: This behaviour will be changed in the future so you can set tags that haven't been created yet!)"));
			User::Leave(KErrNotFound);
			}
		LeaveIfErr(err, _L("Couldn't enable tag."));
		listSettings = EFalse;
		}
	else if (iArguments.IsPresent(0))
		{
		// Get
		TUint32 e = iClogger.IsEnabled(*iTagName);
		Printf(_L("Tag [%S] enabled: 0x%x\r\n"), iTagName, e);
		listSettings = EFalse;
		}
	
	if (listSettings)
		{
		// List global options
		TUint globalOptions = iClogger.GetGlobalOptions();
		Printf(_L("Global options: 0x%x ( "), globalOptions);
		if (!globalOptions)
			{
			Write(_L("None "));
			}
		else
			{
			WRITEIF(globalOptions, EBufferLog);
			WRITEIF(globalOptions, EMirrorToRDebugPrint);
			WRITEIF(globalOptions, EMirrorToBluetooth);
			WRITEIF(globalOptions, EMirrorToMessageQueue);
			WRITEIF(globalOptions, ERedirectRDebugPrintToClogger);
			WRITEIF(globalOptions, EDisableFileWriter);
			}
		Write(_L(")\r\n"));

		// List rotate options
		TInt numLogs = 0;
		TUint rotateBehaviour = iClogger.GetRotateBehaviour(&numLogs);
		Printf(_L("Number of rotated logs to keep: %i\r\n"), numLogs);
		Printf(_L("Rotate behaviour: 0x%x ( "), rotateBehaviour);
		if (!rotateBehaviour)
			{
			Write(_L("EDoNothingSpecial "));
			}
		else
			{
			WRITEIF(rotateBehaviour, ECopyRotatedToExternalMedia);
			WRITEIF(rotateBehaviour, EAutoRotateAtStartup);
			WRITEIF(rotateBehaviour, ECompressRotatedLogs);
			}
		Write(_L(")\r\n"));

		// List buffer size
		TInt numBuffers = 0;
		TInt bufSize = iClogger.GetRamBufferSize(&numBuffers);
		Printf(_L("Number of RAM buffers: %i\r\n"), numBuffers);
		Printf(_L("Size of RAM buffers: %i\r\n"), bufSize);

		// List tags
		CDesC16Array* tags = NULL;
		RBuf8 enabled;
		iClogger.GetTagStatesL(tags, enabled);
		TInt count = enabled.Size() / 4;
		if (count) Printf(_L("\r\n"));
		for (TInt i = 0; i < count; i++)
			{
			TPtrC tag = tags->operator[](i);
			TUint32 e = ((TUint32*)enabled.Ptr())[i];
			Printf(_L("Tag [%S] enabled: 0x%x\r\n"), &tag, e);
			}
		delete tags;
		enabled.Close();
		}

	if (iPersist)
		{
		iClogger.PersistSettings();
		}

	if (iBackup)
		{
		// Args should be: --exec 'cp -ro C:\Private\10202be9\persists\10272efd.cre E:\Private\10202be9\persists\10272efd.cre'
		TFileName args;
		GetBackupFileNameL(args);

		TInt len = args.Length();
		args.Append(args);
		args.Append('\'');
		args[0] = 'C';
		args.Insert(len, _L(" "));
		args.Insert(0, _L("--exec 'cp -ro "));
		
		RChildProcess shell;
		shell.CreateL(_L("fshell.exe"), args, IoSession(), Stdin(), Stdout(), Stderr());
		CleanupClosePushL(shell);
		TRequestStatus stat;
		shell.Run(stat);
		User::WaitForRequest(stat);
		LeaveIfErr(stat.Int(), _L("Failed to copy cenrep file"));
		CleanupStack::PopAndDestroy(&shell);

		const TPtrC name = args.Right(len+1);
		Printf(_L("Settings backed up to '%S, use --restore option to restore.\r\n"), &name);
		}
	else if (iRestore)
		{
		TFileName args;
		GetBackupFileNameL(args);
		TInt len = args.Length();
		//TEntry e;
		//LeaveIfErr(FsL().Entry(args, e), _L("No backup file found"));
		// Args should be: --exec 'cp E:\Private\10202be9\persists\10272efd.cre C:\Private\10202be9\persists\10272efd.cre'
		args.Append(args);
		args.Append('\'');
		args[len] = 'C';
		args.Insert(len, _L(" "));
		args.Insert(0, _L("--exec 'cp -ro "));
		
		RChildProcess shell;
		shell.CreateL(_L("fshell.exe"), args, IoSession(), Stdin(), Stdout(), Stderr());
		CleanupClosePushL(shell);
		TRequestStatus stat;
		shell.Run(stat);
		User::WaitForRequest(stat);
		LeaveIfErr(stat.Int(), _L("Failed to copy cenrep file"));
		CleanupStack::PopAndDestroy(&shell);

		Printf(_L("Settings restored. You must reboot or restart cloggerserver to get the new settings\r\n"));
		}
	}

void CCmdCloggerConfig::ArgumentsL(RCommandArgumentList& aArguments)
	{
	aArguments.AppendStringL(iTagName, _L("tag_name"));
	aArguments.AppendUintL(iEnabledMask, _L("enabled_mask"));
	}

void CCmdCloggerConfig::OptionsL(RCommandOptionList& aOptions)
	{
	aOptions.AppendUintL(iGlobalOptions, _L("set-global"));
	aOptions.AppendBoolL(iPersist, _L("persist"));
	aOptions.AppendBoolL(iReset, _L("reset"));
	aOptions.AppendUintL(iRotateOptions, _L("set-rotate"));
	aOptions.AppendBoolL(iRotate, _L("rotate"));
	aOptions.AppendBoolL(iFollow, _L("follow"));
	aOptions.AppendIntL(iNumBuffers, _L("num-buffers"));
	aOptions.AppendUintL((TUint&)iBufferSize, _L("buffer-size"));
	aOptions.AppendBoolL(iWipe, _L("wipe"));
	aOptions.AppendBoolL(iRdebug, _L("rdebug"));
	aOptions.AppendBoolL(iBackup, _L("backup"));
	aOptions.AppendBoolL(iRestore, _L("restore"));
	aOptions.AppendBoolL(iDisableAll, _L("disable-all"));
	aOptions.AppendBoolL(iEnableAll, _L("enable-all"));
	}


EXE_BOILER_PLATE(CCmdCloggerConfig)

void CCmdCloggerConfig::PrintLogL()
	{
	// Because of how RCloggerLogConsumer API works we can only 'see' things in the clogger ChunkForBufs. This however
	// won't be where the descriptor being logged will be unless buffered logging is enabled. To fix properly,
	// the rdebug chunk would need to be mapped into the client, and also the Server's iSessionTempBuf and 
	// CDebugRouterClient's iTempBuf would need to be moved to an accessible chunk
	TUint opts = iClogger.GetGlobalOptions();
	opts |= RClogger::EBufferLog;
	iClogger.SetGlobalOptions(opts);

	LeaveIfErr(iLogGetter.Connect(), _L("Couldn't connect to RCloggerLogConsumer"));
	iTempBuffer.CreateL(2048);

	TRequestStatus stat;
	TPtrC8 logLine;
	while (ETrue)
		{
		iLogGetter.GetNextLog(stat, logLine);
		User::WaitForRequest(stat);
		LeaveIfErr(stat.Int(), _L("GetNextLog returned error"));
		
		// CCommandBase::Write doesn't take 8-bit descriptor so write in iTempBuffer-sized chunks
		TPtrC8 lineFrag(logLine);
		const TInt buflen = iTempBuffer.MaxLength();
		while (lineFrag.Length())
			{
			TPtrC8 frag = lineFrag.Left(buflen);
			iTempBuffer.Copy(frag);
			//HexDumpL(frag, iTempBuffer);
			TInt err = Stdout().Write(iTempBuffer);
			LeaveIfErr(err, _L("Write of %d bytes (%d total) failed"), iTempBuffer.Length(), logLine.Length());
			lineFrag.Set(lineFrag.Mid(frag.Length()));
			}
		}
	}

void CCmdCloggerConfig::GetBackupFileNameL(TFileName& aName)
	{
	TInt err = KErrNone;
	TInt theDrive = KErrNotFound;
	// Figure out the first external media device
	for (TInt drive = EDriveA; drive <= EDriveZ; drive++)
		{
		TVolumeInfo info;
		err = FsL().Volume(info, drive);
		if (err == KErrNone)
			{
			//LogNote(ELogDisks, _L8("Found drive %c iDrivaAtt=0x%x iType=0x%x"), 'A' + drive, info.iDrive.iDriveAtt, info.iDrive.iType);
			}
		if (err == KErrNone && ((info.iDrive.iDriveAtt & KDriveAttRemovable) || info.iDrive.iType == EMediaHardDisk)) // Added the check for hard disk so we can use _epoc_drive_d in the emulator
			{
			// Found one
			theDrive = drive;
			break;
			}
		}
	LeaveIfErr(theDrive, _L("Couldn't find a removable drive to backup on to"));

	aName = _L("?:\\private\\10202be9\\persists\\10272efd.cre");
	TChar c;
	Fs().DriveToChar(theDrive, c);
	aName[0] = c;
	}

void CCmdCloggerConfig::SetAllL(TBool aEnabled)
	{
	CDesC16Array* tags = NULL;
	RBuf8 states;
	CleanupClosePushL(states);
	iClogger.GetTagStatesL(tags, states);
	CleanupStack::PushL(tags);
	if (aEnabled)
		{
		states.Fill(TChar(0xff));
		}
	else
		{
		states.FillZ();
		}
	iClogger.SetTagStatesL(tags, states);
	CleanupStack::PopAndDestroy(2, &states);
	}