// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "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:
// @file f32test\concur\cfafsdly.cpp
//


#include "cfafsdly.h"
#include "cfafsdlyif.h"
#include "cfafshmem.h"

IMPORT_C TUint32 DebugRegister();

const TInt KMajorVersionNumber=1;
const TInt KMinorVersionNumber=0;

class TTestDebug
/// Class containing debugging functions.
    {
public:
    static void Printf(TRefByValue<const TDesC> aFmt, ...)
        {
        if (DebugRegister() & KDLYTRC)
            {
            VA_LIST list;
            VA_START(list, aFmt);
            TBuf<256>buf;
            buf.FormatList(aFmt, list);
            RDebug::Print(_L("%S"), &buf);
            }
        }
	static void After(TInt usec)
		{
		RTimer timer;
		timer.CreateLocal();
		TRequestStatus stat;
		timer.After(stat, usec);
		User::WaitForRequest(stat);
		timer.Close();
		}
private:
    };

TTestFile::TTestFile()
/// Initialise a file (clear the size).
	{
	iSize = 0;
	}

void TTestFile::Entry(TEntry& aEntry) const
/// Set up a standard entry item for the file.  Note that it strips off any
/// path from the name of the file.
/// @param aEntry Item to receive data about the file.
	{
	TInt i = iName.LocateReverse('\\');
	if (i == KErrNotFound)
		i = 0;
	else
		++i;
	aEntry.iName     = iName.Mid(i);
	aEntry.iAtt      = KEntryAttNormal;
	aEntry.iSize     = iSize;
	aEntry.iModified = iTime;
	}


TTestDir::TTestDir()
	{
	}

TTestFile* TTestDir::Create(const TDesC& aName)
/// Create a new file, if there is any space left.
/// @param aName Name of the file to be created.
/// @return Pointer to the file structure if it there is space, NULL if not.
	{
	TInt i;
	for (i = 0; i < KMaxFiles; i++)
		{
		if (iFile[i].iName.Length() == 0)
			{
			iFile[i].iName = aName;
			iFile[i].iSize = 0;
			return &iFile[i];
			}
		}
	return NULL;
	}

const TTestFile* TTestDir::Find(const TDesC& aName) const
/// Find a file by name.
/// @param aName Name of file to find (no wildcards).
/// @return Pointer to the file structure if it is found, NULL if not.
	{
	TInt i;
	for (i = 0; i < KMaxFiles; i++)
		{
		if (aName == iFile[i].iName)
			{
			return &iFile[i];
			}
		}
	return NULL;
	}

TTestFile* TTestDir::Find(const TDesC& aName)
/// Find a file by name.
/// @param aName Name of file to find (no wildcards).
/// @return Pointer to the file structure if it is found, NULL if not.
	{
	TInt i;
	for (i = 0; i < KMaxFiles; i++)
		{
		if (aName == iFile[i].iName)
			{
			return &iFile[i];
			}
		}
	return NULL;
	}

void TTestDir::Delete(const TDesC& aName)
/// Delete a file by name (no wildcards) by setting its name to zero length.
/// No error is returned if it doesn't exist.
/// @param aName Name of file to delete (no wildcards).
	{
	TInt i;
	for (i = 0; i < KMaxFiles; i++)
		{
		if (aName == iFile[i].iName)
			{
			iFile[i].iName.SetLength(0);
			iFile[i].iSize = 0;
			}
		}
	}

TTestFile* TTestDir::Entry(TInt aIndex)
/// Return a pointer to the specified file by number, or NULL if the index
/// is out of range.
	{
	return (aIndex >= 0 && aIndex < KMaxFiles ? &iFile[aIndex] : NULL);
	}

CTestFileSystem::CTestFileSystem()
///
/// Constructor
///
	{
	__DECLARE_NAME(_S("CTestFileSystem"));
	TTestDebug::Printf(_L("CTestFileSystem::CTestFileSystem()\n"));
	}

CTestFileSystem::~CTestFileSystem()
///
/// Destructor
///
	{
	TTestDebug::Printf(_L("CTestFileSystem::~CTestFileSystem()\n"));
	}

TInt CTestFileSystem::Install()
///
/// Install the file system
///
	{
	TTestDebug::Printf(_L("CTestFileSystem::Install()\n"));
	iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KF32BuildVersionNumber);
	TPtrC name=_L("DelayFS");
	return(SetName(&name));
	}

CMountCB* CTestFileSystem::NewMountL() const
///
/// Create a new mount control block
///
	{
	TTestDebug::Printf(_L("CTestFileSystem::NewMountL()\n"));
	return (new(ELeave) CTestMountCB);
	}

CFileCB* CTestFileSystem::NewFileL() const
///
/// Create a new file
///
	{
	TTestDebug::Printf(_L("CTestFileSystem::NewFileL()\n"));
	return (new(ELeave) CTestFileCB);
	}

CDirCB* CTestFileSystem::NewDirL() const
///
/// create a new directory lister
///
	{
	TTestDebug::Printf(_L("CTestFileSystem::NewDirL()\n"));
	return (new(ELeave) CTestDirCB);
	}

CFormatCB* CTestFileSystem::NewFormatL() const
///
/// Create a new media formatter
///
	{
	TTestDebug::Printf(_L("CTestFileSystem::NewFormatL()\n"));
	return (new(ELeave) CTestFormatCB);
	}

TInt CTestFileSystem::DefaultPath(TDes& aPath) const
///
/// Return the intial default path
///
	{
	TTestDebug::Printf(_L("CTestFileSystem::DefaultPath(%S)\n"), aPath.Ptr());
	aPath=_L("C:\\");
	return (KErrNone);
	}

void CTestFileSystem::DriveInfo(TDriveInfo& anInfo,TInt aDriveNumber) const
///
/// Return drive info - iDriveAtt already set
///
	{
	TTestDebug::Printf(_L("CTestFileSystem::DriveInfo(%d)\n"), aDriveNumber);
	anInfo.iMediaAtt = KMediaAttFormattable;
	anInfo.iType     = EMediaHardDisk;
//	anInfo.iDriveAtt = KDriveAttRemote | KDriveAttRemovable;
	anInfo.iDriveAtt = KDriveAttRemote;
	}

TBusLocalDrive& CTestFileSystem::DriveNumberToLocalDrive(TInt aDriveNumber)
///
/// Return the local drive associated with aDriveNumber
///
	{
	TTestDebug::Printf(_L("CTestFileSystem::DriveNumberToLocalDrive()\n"));
	return(GetLocalDrive(aDriveNumber));
	}

/**
Reports whether the specified interface is supported - if it is,
the supplied interface object is modified to it

@param aInterfaceId     The interface of interest
@param aInterface       The interface object
@return                 KErrNone if the interface is supported, otherwise KErrNotFound 

@see CFileSystem::GetInterface()
*/
TInt CTestFileSystem::GetInterface(TInt aInterfaceId, TAny*& aInterface,TAny* aInput)
    {
    switch(aInterfaceId)
        {
        case CFileSystem::EProxyDriveSupport: // The Filesystem supports proxy drives
			return KErrNone;

        default:
            return(CFileSystem::GetInterface(aInterfaceId, aInterface, aInput));
        }
    }

CFileSystem* CTestFileSystem::NewL()
///
/// Create a new filesystem and return the pointer to its structure.
///
	{
	CFileSystem* testFSys = new(ELeave) CTestFileSystem;
	return testFSys;
	}


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

static void cvtbuff(TBuf<64>& aOut, const TDesC8& aIn)
/// Copy an 8-bit buffer to a generic one.
/// @param aOut Generic text buffer.
/// @param aIn  8-bit buffer to be copied.
    {
    TInt i;
    TInt n = aIn.Length();
    if (n > 64)
        n = 64;
    aOut.SetLength(n);
    for (i = 0; i < n; i++)
        aOut[i] = TText(aIn[i]);
    }

CTestFileCB::CTestFileCB() : CFileCB(), iFile(NULL), iData(NULL)
	{
	TTestDebug::Printf(_L("CTestFileCB::CTestFileCB()\n"));
	};

CTestFileCB::~CTestFileCB()
	{
	CTestFileCB* file = (CTestFileCB*)this;
	if (file->iFile)
		TTestDebug::Printf(_L("CTestFileCB::~CTestFileCB(%S)\n"), &file->iFile->iName);
	else
		TTestDebug::Printf(_L("CTestFileCB::~CTestFileCB()\n"));
	};

void CTestFileCB::RenameL(const TDesC& aNewName)
/// Rename a file (not supported).
	{
	TTestDebug::Printf(_L("CTestFileCB::RenameL(%S)\n"), aNewName.Ptr());
	}

void CTestFileCB::ReadL(TInt aPos,TInt& aLength,const TAny* aDes,const RMessagePtr2& aMessage)
/// Read from a file.  This introduces a fixed delay of 1 second (by default;
/// 10mS if KDLYFAST bit is set in the debug register), gets the data from the
/// file area and optionally traces it.
	{
	// set up lengths
	TInt max = (aPos > iSize ? 0 : iSize - aPos);
	TInt len = (aLength > max ? max : aLength);
	// set up return data
	THMem  dataBuffer(aDes, aMessage);
	dataBuffer.Write(iData+aPos, len, 0);
	aLength = len;
	/// now output traces
	TTestDebug::Printf(_L("CTestFileCB::ReadL(%4d, %4d, %.8X)\n"), aPos, aLength, aDes);
	TPtr8    pbuf(iData+aPos, len, max);
	TBuf<64> buf;
	cvtbuff(buf, pbuf);
	TTestDebug::After(DebugRegister() & KDLYFAST ? 10000 : 1000000);
	TTestDebug::Printf(_L("CTestFileCB::ReadL(%4d, %4d, %.8X=%.32S) exit\n"), aPos, aLength, aDes, &buf);
	}

void CTestFileCB::WriteL(TInt aPos,TInt& aLength,const TAny* aDes,const RMessagePtr2& aMessage)
/// Write to a file.  This introduces a fixed delay of 1 second (by default;
/// 10mS if KDLYFAST bit is set in the debug register), puts the data into the
/// file area if there is room and optionally traces it.
	{
	// Set the modified attribute (so Flush() makes its way through)
	iAtt |= KEntryAttModified;
	// set up maximum length
	TInt max = (aPos > KMaxFileLen ? 0 : KMaxFileLen - aPos);
	TInt len = (aLength > max ? max : aLength);
	TInt pos = aPos + len;
	// copy the data
	THMem  dataBuffer(aDes, aMessage);
	dataBuffer.Read(iData+aPos, len, 0);
	if (pos > iSize)
		iSize = pos;
	iFile->iSize = iSize;
	aLength = len;
	// trace it
	TPtr8    pbuf(iData+aPos, len, max);
	TBuf<64> buf;
	cvtbuff(buf, pbuf);
	TTestDebug::Printf(_L("CTestFileCB::WriteL(%4d, %4d, %.8X=%.32S)\n"), aPos, aLength, aDes, &buf);
	TTestDebug::After(DebugRegister() & KDLYFAST ? 10000 : 1000000);
	TTestDebug::Printf(_L("CTestFileCB::WriteL(%4d, %4d, %.8X) exit\n"), aPos, aLength, aDes);
	}

TInt CTestFileCB::Address(TInt& aPos) const
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestFileCB::Address(%d)\n"), aPos);
	return 0;
	}

void CTestFileCB::SetSizeL(TInt aSize)
/// Does nothing
	{
	TTestDebug::Printf(_L("CTestFileCB::SetSizeL(%d)\n"), aSize);
	}

void CTestFileCB::SetEntryL(const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask)
/// Does nothing
	{
	TTestDebug::Printf(_L("CTestFileCB::SetEntryL(%.8X, %.8X, %.8X)\n"), aTime.Int64(), aSetAttMask, aClearAttMask);
	}

void CTestFileCB::FlushDataL()
/// Flushes the file (well, actually does nothing other than introduce a fixed delay 
//	of 2.5 seconds (by default; 10mS if KDLYFAST bit is set in the debug register).
	{
	TTestDebug::Printf(_L("CTestFileCB::FlushDataL()\n"));
	if(iAtt & KEntryAttModified)
		{
		iAtt &= ~KEntryAttModified;
		TTestDebug::After(3500000);
		}
	}

void CTestFileCB::FlushAllL()
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestFileCB::FlushAllL()\n"));
	}

void CTestFileCB::CheckPos(TInt aPos)
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestFileCB::CheckPos(%d)\n"), aPos);
	}

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

CTestMountCB::CTestMountCB() : CMountCB()
	{
	TTestDebug::Printf(_L("CTestMountCB::CTestMountCB()\n"));
	iSize = KMaxFileLen;
	SetVolumeName(HBufC::NewL(0));
	};

CTestMountCB::~CTestMountCB()
	{
	TTestDebug::Printf(_L("CTestMountCB::~CTestMountCB()\n"));
	};

void CTestMountCB::MountL(TBool aForceMount)
/// Does nothing.
	{
	if (aForceMount)
		TTestDebug::Printf(_L("CTestMountCB::MountL(forced)\n"));
	else
		TTestDebug::Printf(_L("CTestMountCB::MountL()\n"));
	}

TInt CTestMountCB::ReMount()
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestMountCB::ReMount()\n"));
	return KErrNone;
	}

void CTestMountCB::Dismounted()
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestMountCB::Dismounted()\n"));
	}

void CTestMountCB::VolumeL(TVolumeInfo& aVolume) const
/// Gets data about the volume -- the name is fixed and the size and free
/// space remaining are constant.
	{
	TTestDebug::Printf(_L("CTestMountCB::VolumeL()\n"));
	aVolume.iName = _L("DelayTest");
	aVolume.iSize = KMaxFileLen;
	aVolume.iFree = KMaxFileLen;
	}

void CTestMountCB::SetVolumeL(TDes& aName)
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestMountCB::SetVolumeL(%S)\n"), &aName);
	}

void CTestMountCB::MkDirL(const TDesC& aName)
	{
	TTestDebug::Printf(_L("CTestMountCB::MkDirL(%S)\n"), &aName);
	User::Leave(KErrNotSupported);
	}

void CTestMountCB::RmDirL(const TDesC& aName)
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestMountCB::RmDirL(%S)\n"), &aName);
	}

void CTestMountCB::DeleteL(const TDesC& aName)
	{
	TTestDebug::Printf(_L("CTestMountCB::DeleteL(%S)\n"), &aName);
	iDir.Delete(aName);
	}

void CTestMountCB::RenameL(const TDesC& anOldName,const TDesC& anNewName)
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestMountCB::RenameL(%S, %S)\n"), &anOldName, &anNewName);
	}

void CTestMountCB::ReplaceL(const TDesC& /*anOldName*/,const TDesC& /*anNewName*/)
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestMountCB::ReplaceL()\n"));
	}

void CTestMountCB::EntryL(const TDesC& aName, TEntry& aEntry) const
/// Gets the data associated with the specified file.
	{
	const TTestFile* e = iDir.Find(aName);
	if (e)
		{
		e->Entry(aEntry);
		}
	else
		{
		aEntry.iName = _L("");
		aEntry.iAtt  = 0;
		aEntry.iSize = 0;
		aEntry.iType = TUidType();
		TTestDebug::Printf(_L("CTestMountCB::EntryL(%S) leave KErrNotFound\n"), &aName);
		User::Leave(KErrNone);
		}
	TTestDebug::Printf(_L("CTestMountCB::EntryL(%S, %S)\n"), &aName, &aEntry.iName);
	}

void CTestMountCB::SetEntryL(const TDesC& aName, const TTime& aTime, TUint aSetAttMask, TUint aClearAttMask)
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestMountCB::SetEntryL(%S, %.8X, %.8X, %.8X)\n"),
					   &aName, aTime.Int64(), aSetAttMask, aClearAttMask);
	}

void CTestMountCB::FileOpenL(const TDesC& aName, TUint aMode, TFileOpen aOpen, CFileCB* aFile)
/// Opens a file in the specified mode (the mode is ignored after this,
/// both read and write will work with any open file).  If a file is opened
/// for writing then it will be overwritten without comment.  The timestamp
/// of the file will be set when it is opened for writing.
/// @param aName Name of the file.
/// @param aMode Read, write etc.
/// @param aOpen ???
/// @param aFile Pointer to the already allocated file descriptor area.
	{
	TTestDebug::Printf(_L("CTestMountCB::FileOpenL(%S, %.8X, %.8X, %.8X)\n"),
				  &aName, aMode, aOpen, aFile);
	CTestFileCB* file = (CTestFileCB*)aFile;
	if (aMode & EFileWrite)
		{
		TTestDebug::Printf(_L("Open for writing\n"));
		file->iFile = iDir.Find(aName);
		if (!file->iFile)
			file->iFile = iDir.Create(aName);
		if (file->iFile)
			{
			TTime now;
			now.HomeTime();
			file->iFile->iTime = now.DateTime();
			file->iData = file->iFile->iData;
			}
		else
			User::Leave(KErrDiskFull);
		}
	else
		{
		TTestDebug::Printf(_L("Open for reading\n"));
		file->iFile = iDir.Find(aName);
		if (file->iFile)
			{
			file->iData = file->iFile->iData;
			aFile->SetSize(file->iFile->iSize);
			}
		else
			User::Leave(KErrNotFound);
		}
	}

void CTestMountCB::DirOpenL(const TDesC& aName, CDirCB* aDir)
/// Opens the directory for reading etc.
/// @param aName Name to look for.
/// @param aDir  Pointer to already allocated directory descriptor area.
	{
	CTestDirCB& dir = *(CTestDirCB*)aDir;
	dir.iName  = aName;
	dir.iDir   = &iDir;
	dir.iIndex = 0;
	TTestDebug::Printf(_L("CTestMountCB::DirOpenL(%S)\n"), &aName);
	}

void CTestMountCB::RawReadL(TInt64 /*aPos*/,TInt /*aLength*/,const TAny* /*aDes*/,
					   TInt /*anOffset*/,const RMessagePtr2& /*aMessage*/) const
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestMountCB::RawReadL()\n"));
	}

void CTestMountCB::RawWriteL(TInt64 /*aPos*/,TInt /*aLength*/,const TAny* /*aDes*/,
						TInt /*anOffset*/,const RMessagePtr2& /*aMessage*/)
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestMountCB::RawWriteL()\n"));
	}

void CTestMountCB::ReadUidL(const TDesC& /*aName*/,TEntry& /*anEntry*/) const
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestMountCB::ReadUidL()\n"));
	}

void CTestMountCB::GetShortNameL(const TDesC& /*aLongName*/,TDes& /*aShortName*/)
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestMountCB::GetShortNameL()\n"));
	}

void CTestMountCB::GetLongNameL(const TDesC& /*aShortName*/,TDes& /*aLongName*/)
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestMountCB::GetLongNameL()\n"));
	}

void CTestMountCB::IsFileInRom(const TDesC& /*aFileName*/,TUint8*& /*aFileStart*/)
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestMountCB::IsFileInRom()\n"));
	}

void CTestMountCB::ReadSectionL(const TDesC& /*aName*/,TInt /*aPos*/,TAny* /*aTrg*/,
						   TInt /*aLength*/,const RMessagePtr2& /*aMessage*/)
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestMountCB::ReadSectionL()\n"));
	}


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

CTestDirCB::CTestDirCB() : CDirCB()
	{
	TTestDebug::Printf(_L("CTestDirCB::CTestDirCB()\n"));
	};

CTestDirCB::~CTestDirCB()
	{
	TTestDebug::Printf(_L("CTestDirCB::~CTestDirCB()\n"));
	};

void CTestDirCB::ReadL(TEntry& aEntry)
/// Read a directory entry.  It looks for the next entry which has
/// a name starting with the name specified when opening the directory
/// (this may be a pathname, for instance).
{
	TTestFile* e = NULL;
	TInt len = iName.Length();
	while ((e = iDir->Entry(iIndex))!=0 &&
		   (e->iName.Length() <= len || e->iName.Left(len) != iName))
		{
		iIndex++;
		}
	if (e)
		{
		e->Entry(aEntry);
		iIndex++;
		}
	else
		{
		aEntry.iName = _L("");
		aEntry.iAtt  = 0;
		aEntry.iSize = 0;
		aEntry.iType = TUidType();
		TTestDebug::Printf(_L("CTestDirCB::ReadL() leave KErrNotFound"));
		User::Leave(KErrNone);
		}
	TTestDebug::Printf(_L("CTestDirCB::ReadL(%S)\n"), &aEntry.iName);
}


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

CTestFormatCB::CTestFormatCB() : CFormatCB()
	{
	TTestDebug::Printf(_L("CTestFormatCB::CTestFormatCB()\n"));
	};

CTestFormatCB::~CTestFormatCB()
	{
	TTestDebug::Printf(_L("CTestFormatCB::~CTestFormatCB()\n"));
	};

void CTestFormatCB::DoFormatStepL()
/// Does nothing.
	{
	TTestDebug::Printf(_L("CTestFormatCB::DoFormatStepL()\n"));
	}

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

extern "C" {

EXPORT_C CFileSystem* CreateFileSystem()
///
/// Create a new file system.
///
	{
	TTestDebug::Printf(_L("CreateFileSystem()\n"));
	return(CTestFileSystem::NewL());
	}
}