// filebuffer.cpp

// 

// Copyright (c) 2009 - 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 <e32base.h>

#include <e32math.h>

#include <utf.h>

#include <charconv.h>

#include "filebuffer.h"

const TInt KMinBlockSize = 2048; // Not least because an 80x24 console is about 2k

const TInt KMaxBlockSize = 28*1024; // 28 is good compromise, at least up to about 50MB files

const TInt KTargetNumBlocks = 100; // Grow block size linearly to try and keep the number of blocks at around 100

/////DEBUG

//const TInt KMaxBlockSize = 64*1024-1;

//const TInt KTargetNumBlocks = 2;

//////END DEBUG

__ASSERT_COMPILE(KMaxBlockSize <= (TInt)KMaxTUint16);

const TInt KUnicodeLineBreak = 0x2028;

//const TInt KUnicodeParagraphBreak = 0x2029; // We treat this the same as a unicode line break, oh well.

const TUint KFilePermissions = EFileShareReadersOnly | EFileRead;

void ByteSwitch(TUint16* data, TInt aLen);

CFileBuffer* CFileBuffer::NewL(RFs& aFs, CCnvCharacterSetConverter* aCharconv, const TDesC& aName, TBool aAllowNonexistantName)

	{

	CFileBuffer* fb = new (ELeave) CFileBuffer(aFs, aCharconv);

	fb->PushL();

	if (aName.Length())

		{

		fb->ConstructL(aName, aAllowNonexistantName);

		}

	else

		{

		fb->ConstructL();

		}

	CleanupStack::Pop(fb);

	return fb;

	}

CFileBuffer::~CFileBuffer()

	{

	iFile.Close();

	CFileBlock* block = iFirstBlock;

	while (block)

		{

		CFileBlock* next = block->Next();

		delete block;

		block = next;

		}

	iNarrowBuf.Close();

	}

CFileBuffer::CFileBuffer(RFs& aFs, CCnvCharacterSetConverter* aCharconv)

	: iDelimType(EDelimNotYetKnown), iEncoding(EEncodingUnknown), iFs(aFs), iCharconv(aCharconv)

	{

	CActiveScheduler::Add(this);

	}

void CFileBuffer::ConstructL(const TDesC& aName, TBool aAllowNonexistantName)

	{

	TInt err = iFile.Open(iFs, aName, KFilePermissions);

	if ((err == KErrNotFound || err == KErrPathNotFound) && aAllowNonexistantName)

		{

		// Then treat it the same as an new untitled file (except that it has a title)

		ConstructL();

		iFinalName = aName;

		return;

		}

	User::LeaveIfError(err); // view will take care of displaying appropriate message

	CommonConstructL();

	User::LeaveIfError(iFile.FullName(iFinalName));

	TInt size = 0;

	User::LeaveIfError(iFile.Size(size));

	iCacheBufSize = CalculateCacheBufSize(size);

	User::LeaveIfError(iCacheBufSize);

	iNarrowBuf.CreateL(iCacheBufSize);

	// And set up our initial file blocks, all of which start out with size iCacheBufSize (with the exception of the last one)

	CFileBlock* endBlock = NULL;

	TInt blockStart = 0;

	while (blockStart < size)

		{

		TInt blockSize = Min(iCacheBufSize, size - blockStart);

		CFileBlock* block = new(ELeave) CFileBlock(blockStart, blockSize);

		if (endBlock)

			{

			block->InsertAfterBlock(endBlock);

			}

		else

			{

			iFirstBlock = block;

			}

		endBlock = block;

		blockStart += blockSize;

		}

	if (!iFirstBlock)

		{

		// File must be empty, in which case we need to do the same as in ConstructL() and create a placeholder empty block

		iFirstBlock = new(ELeave) CFileBlock(0, 0);

		// Do I need to call this?

		User::LeaveIfError(iFirstBlock->BlockDidLoad(iEncoding, iDelimType, KNullDesC8, iCharconv));

		}

	}

void CFileBuffer::ConstructL() // Overload for no file - ie use new, untitled file

	{

	CommonConstructL();

	iCacheBufSize = KMinBlockSize;

	iNarrowBuf.CreateL(iCacheBufSize);

	iFirstBlock = new(ELeave) CFileBlock(0, 0);

	User::LeaveIfError(iFirstBlock->BlockDidLoad(iEncoding, iDelimType, KNullDesC8, iCharconv));

	}

void CFileBuffer::CommonConstructL()

	{

	// Used to be something here, not any more

	}

TInt CFileBuffer::CalculateCacheBufSize(TInt aFileSize)

	{

	TInt blockSize = aFileSize / KTargetNumBlocks;

	blockSize = blockSize & 0xFFFFFF0; // Round down to nearest 16-byte boundary

	if (blockSize < KMinBlockSize)

		{

		return KMinBlockSize;

		}

	else if (blockSize > KMaxBlockSize)

		{

		return KMaxBlockSize;

		}

	else

		{

		return blockSize;

		}

	}

/*

 This function is responsible for unloading unnecessary CFileBlocks [and calling MSharedCacheClient::InvalidateBuffer

 on any client accessing data from buffers being deleted]. The function decides who is using which blocks based on

 TClientRequest::iRequestedBlock to see what the most-recently requested block was.

 */

//For now the function is kept as simple as possible. For each client it just keeps three read-only buffers: the current buffer,

//the previous buffer, and the next buffer. It also keeps all writable buffers (containing data written by the user) because

//they have to be written to the disk before deleting.

void CFileBuffer::TidyCache()

	{

	for (CFileBlock* block = iFirstBlock; block != NULL; block = block->Next())

		{

		UnloadBlockIfPossible(block);

		}

	}

void CFileBuffer::UnloadBlockIfPossible(CFileBlock* aBlock)

	{

	if (aBlock->IsDirty() || !aBlock->IsLoaded() || aBlock == iCurrentBlock) return;

	// Check if any client is using it

	TBool inUse = EFalse;

	for (TInt i = 0; i < iClientRequests.Count(); i++)

		{

		CFileBlock* clientBlock = iClientRequests[i].iLastRequestedBlock;

		if (!clientBlock) continue;

		else if (clientBlock == aBlock || clientBlock->Prev() == aBlock || clientBlock->Next() == aBlock)

			{

			inUse = ETrue;

			break;

			}

		}

	if (!inUse)

		{

		aBlock->Unload();

		}

	}

CFileBlock* CFileBuffer::FindBlockForDocumentPosition(TInt aDocPosition, TInt* aOffset, TInt* aLineCountToDocPos)

	{

	ASSERT(aDocPosition >= 0);

	TInt blockStart = 0;

	TInt lineCount = 0;

	CFileBlock* block = iFirstBlock;

	while (block)

		{

		if (!block->HasBeenLoaded())

			{

			// Need the block to have been loaded to know the char count (and the line count)

			TInt err = LoadBlock(block);

			if (err) return NULL;

			}

		TInt charCount = block->CharacterCount();

		if (aDocPosition < blockStart + charCount || block->Next() == NULL && aDocPosition == blockStart + charCount)

			{

			// Found it (note that the last block is returned if the document position DocumentSize() is requested)

			TInt offset = aDocPosition - blockStart;

			if (aOffset) *aOffset = offset;

			if (aLineCountToDocPos)

				{

				TInt lineCountToOffset = 0;

				if (offset != 0)

					{

					// We have to load the block if the caller requested line count info and offset is non-zero

					TInt err = LoadBlock(block);

					if (err) return NULL;

					lineCountToOffset = block->CountNewLinesUpToOffset(offset);

					}

				*aLineCountToDocPos = lineCount + lineCountToOffset;

				}

			return block;

			}

		else

			{

			UnloadBlockIfPossible(block);

			}

		blockStart += charCount;

		lineCount += block->NewlineCount();

		block = block->Next();

		}

	//ASSERT(EFalse); // If we get here then we don't have a block for this offset - maybe offset was >= file length?

	return NULL;

	}

TInt CFileBuffer::LoadBlock(CFileBlock* aBlock)

	{

	TInt err = KErrNone;

	if (aBlock->IsLoaded())

		{

		return KErrNone;

		}

	if (!iFile.SubSessionHandle()) return KErrNotReady;

	// Then load it from disk

	iNarrowBuf.Zero();

	TInt blockSize = aBlock->BlockSize();

	if (blockSize > iNarrowBuf.MaxSize())

		{

		err = iNarrowBuf.ReAlloc(blockSize);

		}

	if (!err)

		{

		err = iFile.Read(aBlock->FilePosition(), iNarrowBuf, blockSize);

		if (err)

			{

			aBlock->Unload();

			}

		}

	if (err == KErrNone)

		{

		TEncodingType blockEncoding = iEncoding;

		TDelimiterType blockDelim = iDelimType;

		err = aBlock->BlockDidLoad(blockEncoding, blockDelim, iNarrowBuf, iCharconv);

		if (err)

			{

			// Don't do anything with encodings

			return err;

			}

		if (iEncoding == EEncodingUtf8 && blockEncoding == EEncodingNarrow)

			{

			// Conceivably previous blocks could have been narrow that was also UTF-8 conformant but this block makes it clear the file definitely isn't UTF-8 - therefore allow the change of encoding

			iEncoding = EEncodingNarrow;

			}

		else if (iEncoding == EEncodingUnknown)

			{

			iEncoding = blockEncoding;

			}

		else if (blockEncoding != iEncoding)

			{

			__DEBUGGER();

			err = KErrCorrupt;

			}

		if (iDelimType == EDelimNotYetKnown && blockDelim)

			{

			iDelimType = blockDelim;

			}

		// Inconsistant line ending info is ignored here, as most of it has already been thrown away by CountNewLines

		}

	return err;

	}

TInt CFileBuffer::GetData(MSharedCacheClient& aClient, TInt aDocumentPosition)

	{

	TInt idx = FindClientRequest(aClient);

	if (idx < 0)

		{

		return idx;

		}

	TClientRequest& client = iClientRequests[idx];

	ASSERT(aDocumentPosition >= 0);

	TInt offset;

	TInt lineCount;

	CFileBlock* block = FindBlockForDocumentPosition(aDocumentPosition, &offset, &lineCount);

	client.iRange = TRange(aDocumentPosition, 0); // Length will be filled in once block is loaded (as could change due to TransferDataFromPreviousBlock)

	client.iRangeStartLineNumber = lineCount;

	TInt err = LoadBlock(block);

	if (err) return err;

	const TDesC& text = block->Text();

	client.iDes.Set(text.Mid(offset));

	client.iRange.iLength = text.Length() - offset;

	client.iLastRequestedBlock = block;

	TidyCache();

	return KErrNone;

	}

TInt CFileBuffer::SeekFromOffset(MSharedCacheClient& aClient, TInt aDocumentPosition, TInt aNumLinesFromOffset, TInt aLineLength)

	{

	TInt idx = FindClientRequest(aClient);

	if (idx < 0)

		{

		return idx;

		}

	TClientRequest& client = iClientRequests[idx];

	//ASSERT(client.iClientStatus == NULL); // Client can't make more than 1 request at once

	ASSERT(aDocumentPosition >= 0);

	//ASSERT(aDocumentPosition < DocumentSize());

	ASSERT(aNumLinesFromOffset != 0);

	TInt offset;

	CFileBlock* block = FindBlockForDocumentPosition(aDocumentPosition, &offset);

	TInt& lineDelta = aNumLinesFromOffset;

	TInt& maxLineLength = aLineLength;

	TInt err = KErrNone;

	while (ETrue)

		{

		ASSERT(block);

		err = LoadBlock(block);

		if (err) return err;

		TInt lines = lineDelta;

		TInt bufPos;

		if (lines > 0)

			{

			bufPos = CFileBlock::CountNewLines(block->Text().Mid(offset), lines, maxLineLength);

			if (bufPos == KErrNotFound)

				{

				CFileBlock* nextBlock = block->Next();

				if (!nextBlock)

					{

					// If no more blocks, change the request to be "find the first newline searching backwards from the end of the last block" (phrasing it like this means it'll work even if there aren't any newlines in this block at all)

					lineDelta = -1;

					offset = block->CharacterCount();

					continue;

					}

				offset = 0;

				lineDelta -= lines;

				UnloadBlockIfPossible(block);

				block = nextBlock;

				continue;

				}

			else

				{

				bufPos += offset; // Since the bufPos returned was relative to the Mid we did

				}

			}

		else

			{

			lineDelta--; // Client will want the line *before* the first new line we encounter (the first new line we encounter will be for the line they're actually on)

			lines = lineDelta;

			bufPos = CFileBlock::CountNewLines(block->Text().Left(offset), lines, maxLineLength);

			if (bufPos == KErrNotFound)

				{

				CFileBlock* prevBlock = block->Prev();

				if (!prevBlock)

					{

					// If no more blocks, then the start of the first block is closest

					offset = 0;

					break;

					}

				UnloadBlockIfPossible(block);

				block = prevBlock;

				offset = block->CharacterCount();

				lineDelta += lines; // since lineDelta is negative

				continue;

				}

			}

		ASSERT(bufPos != KErrNotFound); // Must be, to have got here

		offset = bufPos;

		break;

		}

	client.iDes.Set(block->Text().Mid(offset));

	TInt docPos;

	TInt lineCount;

	block->CalculateBlockPositions(docPos, lineCount);

	client.iRange = TRange(docPos + offset, block->CharacterCount() - offset);

	client.iLastRequestedBlock = block;

	ASSERT(client.iRange.iLength == client.iDes.Length());

	client.iRangeStartLineNumber = lineCount + block->CountNewLinesUpToOffset(offset);

	TidyCache();

	return KErrNone;

	}

TBool CFileBuffer::DocumentPositionIsEof(TInt aDocumentPosition) const

	{

	// Like FindBlockForDocumentPosition but doesn't try and load blocks

	TInt blockStart = 0;

	for (CFileBlock* block = iFirstBlock; block != NULL; block = block->Next())

		{

		if (!block->HasBeenLoaded())

			{

			return EFalse;

			}

		TInt charCount = block->CharacterCount();

		TInt endOfBlock = blockStart + charCount;

		if (aDocumentPosition < endOfBlock) return EFalse; // We have more characters than this doc pos so it can't be the end

		else if (charCount == 0 && block->Next() != NULL)

			{

			continue; // we're an empty block followed by another block, so defer the decision to the next block

			}

		else if (aDocumentPosition == endOfBlock)

			{

			// Then this position is the eof if there aren't any more blocks

			return (block->Next() == NULL);

			}

		blockStart += charCount;

		}

	ASSERT(EFalse);

	return EFalse;

	}

void CFileBuffer::InsertTextL(TInt aDocumentPosition, const TDesC& aText)

	{

	TInt offset;

	CFileBlock* block = FindBlockForDocumentPosition(aDocumentPosition, &offset);

	TInt err = LoadBlock(block);

	User::LeaveIfError(err);

	block->InsertTextL(offset, aText);

	iUnsaved = ETrue;

	}

void CFileBuffer::DeleteTextL(TRange aRange)

	{

	while (aRange.iLength > 0)

		{

		TInt offset;

		CFileBlock* block = FindBlockForDocumentPosition(aRange.iLocation, &offset);

		if (!block) return; // We will tolerate it if the range is beyond the document position

		TInt err = LoadBlock(block);

		User::LeaveIfError(err);

		TInt blockCharCount = block->CharacterCount();

		TInt blockLen = Min(blockCharCount - offset, aRange.iLength);

		if (blockLen) // Again, tolerating if the range is completely outside the document length

			{

			block->DeleteText(offset, blockLen);

			// The range location stays the same, since everything will have shuffled up

			aRange.iLength -= blockLen;

			iUnsaved = ETrue;

			}

		else

			{

			break;

			}

		}	

	}

void CFileBuffer::DeleteTempFile(TAny* aSelf)

	{

	CFileBuffer* self = static_cast<CFileBuffer*>(aSelf);

	if (self->iTempName->Length())

		{

		self->iFs.Delete(*self->iTempName);

		}

	delete self->iTempName;

	self->iTempName = NULL;

	}

void CFileBuffer::SetFinalNameToTemporary(TAny* aSelf)

	{

	CFileBuffer* self = static_cast<CFileBuffer*>(aSelf);

	self->iFinalName = *self->iTempName;

	}

void CFileBuffer::SaveL(const TDesC& aName, TBool aReplace)

	{

	// Try opening aName as given - if it suceeds use it, if it fails with alreadyExists use a temp file and rename at the end

	RBuf origRenamed;

	CleanupClosePushL(origRenamed);

	iTempName = new(ELeave) TFileName;

	origRenamed.CreateL(KMaxFileName);

	RFile outFile;

	CleanupStack::PushL(TCleanupItem(&DeleteTempFile, this));

	CleanupClosePushL(outFile);

	TBool needToRename = EFalse;

	TInt err = iFs.MkDirAll(aName); // Avoid path not found errors in the case where the file has not yet been saved

	if (err == KErrAlreadyExists) err = KErrNone;

	User::LeaveIfError(err);

	const TUint fileMode = EFileWrite | EFileShareExclusive | EFileStream;

	err = outFile.Create(iFs, aName, fileMode);

	if ((err == KErrAlreadyExists || err == KErrInUse) && aReplace)

		{

		needToRename = ETrue;

		TParsePtrC parse(aName);

		TPtrC path = parse.DriveAndPath();

		err = outFile.Temp(iFs, path, *iTempName, fileMode);

		}

	User::LeaveIfError(err);