/*
* Copyright (c) 1997-1999 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "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:
*
*/



#include "resentry.h"
#include "resdict.h"
#include "rescomp.h"

//TResComponent

TInt TResComponent::Size(TInt aDictionaryBits)
	{
	if (iType == EResTypePlain)
		{
		if (iLength == 0)
			return 0;
		TInt bits = iLength * 8;
		bits++;			// data flag
		if (iLength == 1)
			bits ++;	// first bit zero if 1 byte of data
		else 
			{
			bits++;		// first bit 1 if >1 byte of data
			if (iLength == 2)
				{
				bits ++;	// second bit zero if 2 bytes of data
				}
			else
				{
				bits ++;		// second bit 1 if >2 bytes of data
				if (iLength < 11)
					{
					// write 4 bits of data + 1 zero bit flag
					bits += 4;
					}
				else
					{
					// write 8 bits of data + 1 '1' bit flag
					bits += 9;
					}
				}
			}

//		console->Printf(_L("Type Plain: %d\n"), bits);
		return bits;
		}
	if (iType == EResTypeToken)
		{
		return 1+aDictionaryBits;
//		console->Printf(_L("Type Token: %d\n"), iToken);
//		return 8;		// dictionary entries are stored in 6 bits
		}
	return 0;
	}


void TResComponent::WriteBitStreamL(TBitWriter& aWriter, TInt aDictionaryBits)
	{
	if (iType == EResTypePlain)
		{
		if (iLength == 0)
			return;
// Debugging code
/*
		RDebug::Print(_L("Data Length: %d"), iLength);
		TBuf<100> b;
		for (TInt xx=0; xx<iLength; xx++)
			{
			b.AppendFormat(_L("%02x "), iData[xx]);
			}
		RDebug::Print(b);
*/
//
		// Write 'data' flag
		aWriter.WriteL(1, 1);
		if (iLength == 1)
			{
			aWriter.WriteL(0, 1); // first bit zero if 1 byte of data
			}
		else 
			{
			aWriter.WriteL(1, 1);		// first bit 1 if >1 byte of data
			if (iLength == 2)
				{
				aWriter.WriteL(0, 1); // second bit zero if 2 bytes of data
				}
			else
				{
				aWriter.WriteL(1, 1); // second bit 1 if >2 bytes of data
				if (iLength < 11)
					{
					aWriter.WriteL(0, 1);
					aWriter.WriteL(iLength-3, 3);
					// write 4 bits of data + 1 zero bit flag
					}
				else
					{
					aWriter.WriteL(1, 1);
					aWriter.WriteL(iLength, 8);
					// write 8 bits of data + 1 '1' bit flag
					if (iLength > 255)
						{
						User::Panic(_L("Entry too long"),0);
						}
					}
				}
			}
		// Now write data to output
		for (TInt ii=0; ii<iLength; ii++)
			{
			aWriter.WriteL(iData[ii], 8);
			}
		}
	if (iType == EResTypeToken)
		{
		// Write 'token' flag
		aWriter.WriteL(0, 1);

		// Write token
		aWriter.WriteL(iToken, aDictionaryBits);
//		RDebug::Print(_L("Token [%d] "), iToken);
		}
	}



// CResEntry
CResEntry::CResEntry(CDictArray* aDict)
:iDict(aDict)
	{
	iComponent = new(ELeave)CArrayFixFlat<TResComponent>(4);
	}

CResEntry::~CResEntry()
	{
	delete iComponent;
	}


void CResEntry::AddPlainDataL(TUint8* aData, TInt aLength)
	{
	TResComponent comp;
	comp.iType = EResTypePlain;
	comp.iData = aData;
	comp.iLength = aLength;
	iComponent->AppendL(comp);
	}

void CResEntry::InsertTokenL(TInt aPosition, TInt aToken)
	{
	TResComponent comp;
	comp.iType = EResTypeToken;
	comp.iToken = aToken;
	comp.iLength=0;
	iComponent->InsertL(aPosition,comp);
	(*iDict)[aToken].iUses++;
	}

void CResEntry::SplitPlainDataWithZeroSpacedL(TInt aComponent, TInt aZeroSpacedStart, TInt aLength)
	{
	TResComponent comp = (*iComponent)[aComponent];

	TResComponent newComp1;
	newComp1.iType = EResTypePlain;
	newComp1.iData = comp.iData;
	newComp1.iLength = aZeroSpacedStart;

	TResComponent newComp2;
	newComp2.iType = EResTypePlain;
	newComp2.iData = comp.iData + aZeroSpacedStart + aLength;
	newComp2.iLength = comp.iLength-(aZeroSpacedStart+aLength);

	TResComponent newComp3;
	newComp3.iType = EResTypeZeroSpaced;
	newComp3.iData = comp.iData + aZeroSpacedStart;
	newComp3.iLength = aLength;


	iComponent->Delete(aComponent);
	TInt componentPos = aComponent;
    if (newComp1.iLength != 0)
		{
		iComponent->InsertL(componentPos, newComp1);
		componentPos++;
		}

	iComponent->InsertL(componentPos, newComp3);
	componentPos++;

	if (newComp2.iLength != 0)
		{
		iComponent->InsertL(componentPos, newComp2);
		}
	}


void CResEntry::SplitPlainDataWithTokenL(TInt aComponent, TInt aToken, TInt aPosition)
	{
	TResComponent comp = (*iComponent)[aComponent];
	TDesC8& dEntry = (*iDict)[aToken].Data();
	TInt dictLength = dEntry.Length();

	TResComponent newComp1;
	newComp1.iType = EResTypePlain;
	newComp1.iData = comp.iData;
	newComp1.iLength = aPosition;

	TResComponent newComp2;
	newComp2.iType = EResTypePlain;
	newComp2.iData = comp.iData + aPosition + dictLength;
	newComp2.iLength = comp.iLength - dictLength - aPosition;

	iComponent->Delete(aComponent);
	TInt componentPos = aComponent;
    if (newComp1.iLength != 0)
		{
		iComponent->InsertL(componentPos, newComp1);
		componentPos++;
		}
	InsertTokenL(componentPos, aToken);
	componentPos++;

	if (newComp2.iLength != 0)
		{
		iComponent->InsertL(componentPos, newComp2);
		}

	}


TInt CResEntry::Size(TInt aDictionaryBits)
	{
	TInt size = 0;
	TInt count = iComponent->Count();
	for (TInt ii=0; ii<count; ii++)
		{
		size += iComponent->At(ii).Size(aDictionaryBits);
		}
	return size;
	}

void CResEntry::WriteBitStreamL(TBitWriter& aWriter, TInt aDictionaryBits)
	{
	TInt count = iComponent->Count();
	for (TInt ii=0; ii<count; ii++)
		{
		iComponent->At(ii).WriteBitStreamL(aWriter, aDictionaryBits);
		}
	}



TBool CResEntry::DoMatchDictL(TResComponent& aComp, TInt aOffset, TInt aDictIndex)
	{
	TInt dCount = iDict->Count();
	TInt cSize = aComp.iLength;
	for (TInt ii=0; ii<dCount; ii++)
		{
		if (ii != aDictIndex)
			{
			TDesC8& dEntry = (*iDict)[ii].Data();
			if (dEntry.Length() <= cSize)
				{
				TPtrC8 data(aComp.iData, cSize);
				TInt pos = data.Find(dEntry);
				if (pos != KErrNotFound)
					{
//					console->Printf(_L("Found %d Offset: %d\n"),ii, pos);
					SplitPlainDataWithTokenL(aOffset, ii, pos);
					return ETrue;
				}
			}
			}
		}
	return EFalse;
	}


void CResEntry::MatchDictL(TInt aDictIndex)
	{
	// Match plain text components against dictionary
	TInt count = iComponent->Count();
	for (TInt ii=0; ii<count; ii++)
		{
		TResComponent comp = (*iComponent)[ii];
		if (comp.iType == EResTypePlain)
			{
			if (DoMatchDictL(comp, ii, aDictIndex))
				{
				count = iComponent->Count();
				ii--;
				}
			}
		}
	}


/*
void CResEntry::MatchZeroSpacedL()
	{
	// Find zero spaced data
	TInt count = iComponent->Count();
	for (TInt ii=0; ii<count; ii++)
		{
		TResComponent comp = (*iComponent)[ii];
		if (comp.iType == EResTypePlain)
			{
			if (DoMatchZeroSpacedL(comp, ii))
				{
				count = iComponent->Count();
				ii--;
				}
			}
		}
	}


TBool CResEntry::DoMatchZeroSpacedL(TResComponent& aComp, TInt aOffset)
	{
	// Analyse data and see if there is a string of zero spaced data
	// Data, followed by zero
	TInt length = aComp.iLength;
	TInt pos = 0;
	TInt dataSize = 0;
	for (TInt ii=0; ii<length-1; ii++)
		{
		if (aComp.iData[ii+1] == 0)
			{
			// Found zero spaced data
			if (dataSize == 0)
				{
				// Start of zero spaced data
				pos = ii;
				dataSize = 2;
				}
			else
				{
				dataSize += 2;
				}
			ii++;
			}
		else
			{
			// End of zero spaced data
			if (dataSize > 2)
				{
				SplitPlainDataWithZeroSpacedL(aOffset, pos, dataSize);
				return ETrue;
				}
			dataSize = 0;
			}
		}
	return EFalse;
	}
*/


void CResEntry::MatchSelfL(TInt aRes,CResComp* aResComp)
	{
	// Find duplicates within resource
	TInt count = iComponent->Count();
	for (TInt ii=0; ii<count; ii++)
		{
		TResComponent comp = (*iComponent)[ii];
		if (comp.iType == EResTypePlain)
			{
			if (DoMatchSelfL(comp, ii, aRes, aResComp))
				{
				count = iComponent->Count();
				ii--;
				}
			}
		}
	}




/*
TBool CResEntry::MatchPreviousComponent(TInt aCompIndex, TDesC8& aMatch)
	{
	TInt size = aMatch.Size();
	for (TInt ii=0; ii<aCompIndex; ii++)
		{
		TResComponent comp = (*iComponent)[ii];
		if (comp.iType == EResTypePlain)
			{
			console->Printf(_L("Matching: %d (Length: %d)\n"), aCompIndex, size);
			if (comp.iLength <= size)
				{
				 TPtrC8 buf(comp.iData, comp.iLength);
				 TInt found = buf.Find(aMatch);
				 if (found != KErrNotFound)
					 {
					 console->Printf(_L("Found\n"));
					 return ii;
					 }
				}
			}
		}

	return KErrNotFound;
	}
*/

TBool CResEntry::DoMatchSelfL(TResComponent& aComp, TInt aOffset, TInt aRes, CResComp* aResComp)
	{
	TInt cSize = aComp.iLength;
	TInt matchSize = cSize/2;
	if (matchSize > KMaxDictEntry)
		matchSize = KMaxDictEntry;

	while (matchSize > 1)
		{
		TInt pos=matchSize;
		TInt positions = (cSize-(matchSize*2))+1;
		while (positions)
			{
			TPtr8 match(aComp.iData + pos, matchSize,matchSize);
			TPtr8 left(aComp.iData, pos, pos);
			TInt found = left.Find(match);
			if (found != KErrNotFound)
				{
				TInt token = iDict->AddEntryL(match);
				// Remove both matches and replace with token
				SplitPlainDataWithTokenL(aOffset, token, pos);
				SplitPlainDataWithTokenL(aOffset, token, found);
				return ETrue;
				}
			else
				{
				// Find in all other resources
				TInt find = aResComp->FindInResources(match, aRes);
				if (find != KErrNotFound)
					{
					TInt token = iDict->AddEntryL(match);
					SplitPlainDataWithTokenL(aOffset, token, pos);
					return ETrue;
					}

				}
			positions--;
			pos++;
			}
		matchSize--;
		}
	return EFalse;
	}


	TResType iType;
	TUint8* iData;
	TInt iLength;
	TInt iToken;


void CResEntry::CheckForLongDataStringsL()
	{
	TInt components = iComponent->Count();
	for (TInt ii=0; ii<components; ii++)
		{
		TResComponent comp = (*iComponent)[ii];
		if (comp.iLength > 255)
			{
			TInt length = comp.iLength;
			RDebug::Print(_L("Component Too Long!"));
			TResComponent comp1;
			comp1.iType = comp.iType;
			comp1.iData = comp.iData;
			comp1.iLength = 255;
			comp1.iToken = comp.iToken;

			TResComponent comp2;
			comp2.iType = comp.iType;
			comp2.iData = comp.iData + 255;
			comp2.iLength = length - 255;
			comp2.iToken = comp.iToken;

			iComponent->Delete(ii);
			iComponent->InsertL(ii, comp1);
			iComponent->InsertL(ii+1, comp2);

			components = iComponent->Count();
			}
		}
	}