/*

* Copyright (c) 2002-2008 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:  

*

*/

// disable "identifier was truncated to '255' characters in the browser information" warning

#pragma warning (disable:4786)

// disable "decorated name length exceeded, name was truncated" warning	

#pragma warning (disable:4503)

#include "MLCompDataParse.h"

#include "MLCompCdl2InstO.h"

#include "ZoomLevelNames.h"

#include "LayoutCompilerErr.h"

#include "LayoutParse.h"

#include "CppWriter.h"

#include "MLCompData2Cdl.h"

#include "LayCdl2InstO.h" // for common classes

#include "MLAttributesParse.h"

#include "MLAttributes.h"

#include "CodeGenConsts.h"

#include "UsefulDefinitions.h"

#include <akndef.hrh>

#include <fstream>

#include <algorithm>

#include <iostream>

#include <numeric> // accumulate

using namespace std;

using namespace CdlCompilerToolkit;

//

// defines

//

#define AKNLAYOUT_DEFINE_BYTECODE(name,byte) const char name = char(byte);

#include "AknLayoutByteCodes.h"

typedef LayoutProcessArgsErr<MLCompDataCdlInstanceOpt> MLCompDataCdlInstanceOptArgsErr;

//

// constants

//

const string KDefinitionNotDefined("Layout not defined, this API must not be called for this instance");

const string KDefinitionNotSet("Layout definition not found");

extern string KMultiLine;

const string KSpace = " ";

const string KComma = ",";

const string KTheWordBlank("blank");

const string KParentRelativeMarker("Pp");

const string KCellNameJustification("J");

const string KCompDataFileNameSuffix("compData");

const string KAttributesFileNameSuffix("attributes");

// this is the addressable area for each instance, as the lookup table is 16bit

const int KAddressableBytecodedData = 0xFFFF;

/**

*  SCompDataImplFunc

*  This class represents a layout data decompression function local to a layout instance.

*  These functions will call the corresponding DLL wide function for decompression.

*/

struct SCompDataImplFunc

	{

	enum TFuncType

		{ 

		EWindowLine, 

		ETextLine,

		ETableLimits,

		EWindowTable, 

		ETextTable,

		ELineParamLimits,

		ETableParamLimits,

		EGenericComponentType,

		EGenericParamLimits,

		EGenericWindowComponent,

		EGenericTextComponent

		};

	TFuncType iType;

	CCdlTkApiParams iParams;

	string iDefn;

	string iPtrRef;

	SCompDataImplFunc(TFuncType aType, string aDefn, string aPtrRef, CCdlTkApiParams& aParams)

		: 

		iType(aType), 

		iDefn(aDefn), 

		iPtrRef(aPtrRef),

		iParams(aParams)

		{

		}

	SCompDataImplFunc(TFuncType aType, string aDefn, string aPtrRef)

		: 

		iType(aType), 

		iDefn(aDefn), 

		iPtrRef(aPtrRef)

		{

		}

	bool IsSimilar(TFuncType aType, CCdlTkApiParams& aParams)

		{

		if(iType != aType) 

			return false;

		int size = iParams.size();

		if(size != aParams.size())

			return false;

		for(int ii = 0; ii < size; ii++)

			{

			CCdlTkApiParam& thisParam = iParams[ii];

			CCdlTkApiParam& otherParam = aParams[ii];

			if(thisParam.Name() != otherParam.Name())

				return false;

			if(thisParam.Type() != otherParam.Type())

				return false;

			// don't compare the default value, as we're not interested in that for the implementation.

			}

		return true;

		}

	};

/**

*  CAllCompDataFuncs

*  This represents a collection of all the SCompDataImplFunc objects that a layout instance may need

*/

class CAllCompDataFuncs : public vector<SCompDataImplFunc>

	{

public:

	CAllCompDataFuncs();

private:

	void AddFunc(SCompDataImplFunc::TFuncType aType, CCdlTkApiParams& aParams, const string& aReturn, const string& aFuncName, bool aAppendAbbreviation);

	void AddParamsToFunc(CCdlTkApiParams& aParams, string& aDefn, string& aBody);

	void AddParamToFunc(string aFiller, string aParamName, string& aDefn, string& aBody);

	};

/**

*  gTheFuncs

*  This is a collection of all SCompDataImplFunc objects that a layout instance needs, initialised

*  so that there are up to four integer parameters per API type.

*/

CAllCompDataFuncs gTheFuncs;

//

// CAllCompDataFuncs

//

CAllCompDataFuncs::CAllCompDataFuncs()

	{

	// need to generate all combinations of parameters

	vector<string> paramNames;

	paramNames.push_back(KParamOptionIndex);

	paramNames.push_back(KParamColIndex);

	paramNames.push_back(KParamRowIndex);

	// all cominations of option, row, and column are possible, in any order

	typedef vector<int> Seq;

	Seq pattern;

	set< Seq > subPatterns;

	// for each of the available positions, there could be any available value, or it could be empty

	const int numPlaces = paramNames.size();

	for(int jj = 0; jj < numPlaces; jj++)

		pattern.push_back(jj);

	// for each permutation, copy all the possible positions

	// into a separate set, which hence will be filled with the unique permutations

	do

		{

		int numMasks = (1 << numPlaces); // eg for 3 places there are 8 masks

		for(int mask = 0; mask < numMasks; mask++)

			{

			Seq subPattern;

			int bit = 0;

			// count down the bits

			for(int bitCount = mask; bitCount != 0; bitCount >>= 1)

				{

				if(mask & (1 << bit))

					subPattern.push_back(pattern[bit]);

				bit++;

				}

			subPatterns.insert(subPattern);

			}

		}

	while(next_permutation(pattern.begin(), pattern.end()));

	for(set< Seq >::iterator pPattern = subPatterns.begin(); pPattern != subPatterns.end(); ++pPattern)

		{

		CCdlTkApiParams params;

		for(Seq::iterator pParam = pPattern->begin(); pParam != pPattern->end(); ++pParam)

			{

			int& param = (*pParam);

			string name = paramNames[param];

			params.push_back(CCdlTkApiParam(KTypeInt, name));

			}

		AddFunc(SCompDataImplFunc::EWindowLine, params, KTypeWindowComponentLayout, KFuncWindowLine, true);

		AddFunc(SCompDataImplFunc::ETextLine, params, KTypeTextComponentLayout, KFuncTextLine, true);

		params.insert(params.begin(), CCdlTkApiParam(KTypeInt, KParamLineIndex));

		AddFunc(SCompDataImplFunc::EWindowTable, params, KTypeWindowComponentLayout, KFuncWindowTable, true);

		AddFunc(SCompDataImplFunc::ETextTable, params, KTypeTextComponentLayout, KFuncTextTable, true);

		}

	for(int ii = 0; ii < 2; ii++)

		{

		CCdlTkApiParams params;

		if(ii)

			{

			params.push_back(CCdlTkApiParam(KTypeInt, KParamOptionIndex));

			}

		AddFunc(SCompDataImplFunc::ELineParamLimits, params, KTypeLayoutScalableParameterLimits, KFuncParamLimits, true);

		params.insert(params.begin(), CCdlTkApiParam(KTypeInt, KParamLineIndex));

		AddFunc(SCompDataImplFunc::ETableParamLimits, params, KTypeLayoutScalableParameterLimits, KFuncParamLimitsTable, true);

		}

	SCompDataImplFunc limits(

		SCompDataImplFunc::ETableLimits, 

		KTypeLayoutScalableTableLimits + " Limits() { return AknLayoutScalableDecode::TableLimits(KDataLookup); }",

		"&Limits");

	push_back(limits);

	// finally, the generic APIs

	CCdlTkApiParams params;

	params.push_back(CCdlTkApiParam(KTypeInt, KParamComponentId));

	AddFunc(SCompDataImplFunc::EGenericComponentType, params, KTypeLayoutScalableComponentType, KFuncGetComponentTypeById, false);

	// param limits needs the variety index

	params.push_back(CCdlTkApiParam(KTypeInt, KParamOptionIndex));

	AddFunc(SCompDataImplFunc::EGenericParamLimits, params, KTypeLayoutScalableParameterLimits, KFuncGetParamLimitsById, false);

	// and getting the component by id requires all the params

	params.push_back(CCdlTkApiParam(KTypeInt, KParamColIndex));

	params.push_back(CCdlTkApiParam(KTypeInt, KParamRowIndex));

	AddFunc(SCompDataImplFunc::EGenericWindowComponent, params, KTypeWindowComponentLayout, KFuncGetWindowComponentById, false);

	AddFunc(SCompDataImplFunc::EGenericTextComponent, params, KTypeTextComponentLayout, KFuncGetTextComponentById, false);

	}

void CAllCompDataFuncs::AddFunc(SCompDataImplFunc::TFuncType aType, CCdlTkApiParams& aParams, const string& aReturn, const string& aFuncName, bool aAppendAbbreviation)

	{

	// create a function of this form:

	//TAknWindowComponentLayout WindowTable$NUM$PARENT($PARAMS_TYPES_AND_NAMES)

	//	{

	//	return AknLayoutScalableDecode::WindowLine$NUM$PARENT(&KImplData, $PARAM_NAMES);

	//  }

	string funcName = aFuncName;

	if(aAppendAbbreviation)

		for(CCdlTkApiParams::iterator pParam = aParams.begin(); pParam != aParams.end(); ++pParam)

			funcName += pParam->Name().substr(1, 1); // append the first character after the "a"

	string defn = aReturn + " " + funcName + "(";

	string body = string(") { return AknLayoutScalableDecode::") + funcName + "(&KImplData";

	AddParamsToFunc(aParams, defn, body);

	defn += body + "); }";

	string ptrRef = string("&") + funcName;

	SCompDataImplFunc func(aType, defn, ptrRef, aParams);

	push_back(func);

	}

void CAllCompDataFuncs::AddParamsToFunc(CCdlTkApiParams& aParams, string& aDefn, string& aBody)

	{

	string filler = "";

	for(CCdlTkApiParams::iterator pParam = aParams.begin(); pParam != aParams.end(); ++pParam)

		{

		AddParamToFunc(filler, pParam->Name(), aDefn, aBody);

		filler = KComma + KSpace;

		}

	}

void CAllCompDataFuncs::AddParamToFunc(string aFiller, string aParamName, string& aDefn, string& aBody)

	{

	aDefn += aFiller + string(KTypeInt) + KSpace + aParamName;

	aBody += KComma + KSpace + aParamName;

	}

//

// CMLCompDataInstOptImpl

//

class CMLCompDataInstOptImpl

	{

public:

	CMLCompDataInstOptImpl(CCdlTkImplementation* aImpl);

	virtual ~CMLCompDataInstOptImpl();

public:

	CCdlTkImplementation* iImpl;

	int iByteCodeIndex;

	string iComment;

	string iName;

	vector<char> iBytes;

	bool iIsRedirectedToExactCopy;

	};

CMLCompDataInstOptImpl::CMLCompDataInstOptImpl(CCdlTkImplementation* aImpl)

	:

	iImpl(aImpl),

	iIsRedirectedToExactCopy(false)

	{

	}

CMLCompDataInstOptImpl::~CMLCompDataInstOptImpl()

	{

	}

//

// CMLCompDataLineInstOptImpl

//

class CMLCompDataLineInstOptImpl : public CMLCompDataInstOptImpl

	{

public:

	CMLCompDataLineInstOptImpl(TMLCompDataLine* aLine, CCdlTkImplementation* aImpl);

	virtual ~CMLCompDataLineInstOptImpl();

public:

	TMLCompDataLine* iLine;

	};

CMLCompDataLineInstOptImpl::CMLCompDataLineInstOptImpl(TMLCompDataLine* aLine, CCdlTkImplementation* aImpl)

	: 

	CMLCompDataInstOptImpl(aImpl),

	iLine(aLine)

	{

	}

CMLCompDataLineInstOptImpl::~CMLCompDataLineInstOptImpl()

	{

	}

//

// CMLCompDataSubTableInstOptImpl

//

class CMLCompDataSubTableInstOptImpl : public CMLCompDataInstOptImpl

	{

public:

	CMLCompDataSubTableInstOptImpl(

		TMLCompDataTable* aTable,

		TMLCompDataTable::TMLCompDataSubTable* aSubTable, 

		CCdlTkImplementation* aImpl);

	virtual ~CMLCompDataSubTableInstOptImpl();

public:

	TMLCompDataTable* iTable;

	TMLCompDataTable::TMLCompDataSubTable* iSubTable;

	};

CMLCompDataSubTableInstOptImpl::CMLCompDataSubTableInstOptImpl(

	TMLCompDataTable* aTable,

	TMLCompDataTable::TMLCompDataSubTable* aSubTable, 

	CCdlTkImplementation* aImpl)

	:

	iTable(aTable),

	CMLCompDataInstOptImpl(aImpl),

	iSubTable(aSubTable)

	{

	}

CMLCompDataSubTableInstOptImpl::~CMLCompDataSubTableInstOptImpl()

	{

	}

//

// CMLCompDataInstOpt

//

class CMLCompDataInstOpt

	{

public:

	CMLCompDataInstOpt(MLCompDataCdlInstanceOpt& aInstances, TMLCompData* aLayout, const string& aInstName, const string& aZoomName, int aZoomLevel, bool aAllParams, bool aNonCompleteInstance);

	~CMLCompDataInstOpt();

	void Process(const string& aFirstInstanceName);

	void WriteInstance();

	CCdlTkInstance& Inst() const { return *iInstance; }

	string Name() const { return iName; }

	string ZoomName() const { return iZoomName; }

private:

	typedef vector<int> ParamLimitVarieties;

	typedef vector<ParamLimitVarieties> ParamLimits;

	typedef map<int, int> IndexMap;

private:

	void ProcessLines(TMLCompDataTable& aTable);

	void ProcessTables(TMLCompDataTable& aTable);

	void ProcessLine(TMLCompDataLine& aLine);

	void ProcessLineApi(TMLCompDataLine& aLine, CCdlTkImplementation& aImpl);

	void UpdateBaseOffset();

	void UpdateLine(CMLCompDataInstOptImpl& aImpl, int& aByteCodeSizeDelta);

	void UpdateLineImpls();

	void UpdateLineImplDefn(CMLCompDataInstOptImpl& aImpl);

	void UpdateTableInstance(TMLCompDataTable& aTable, TMLCompDataTable::TMLCompDataSubTable& aSub, CMLCompDataInstOptImpl* aImpl);

	void SetNewLineData(CMLCompDataLineInstOptImpl& aImpl);

	void SetNewLineParamData(CMLCompDataLineInstOptImpl& aImpl, IndexMap& aIndexMap, int aTotalMax, int aNumVarieties);

	void OptimizeNewLineData(CMLCompDataLineInstOptImpl& aImpl, IndexMap& aIndexMap, vector<char>& aTempBytes, const vector<string>& aOutputOrder, bool aMirrored, int aTotalMax, int aNumVarieties);

	void OptimizeNewLineCellData(IndexMap& aIndexMap, vector<char>& aTempBytes, TMLCompDataValues& aValues, unsigned int& aNextCell, int aTotalParams, int aNumVarieties, ParamLimitVarieties& aParamLimitVarieties, string cellName, bool aMirrorJustification);

	void EncodeNewLineCellData(IndexMap& aIndexMap, vector<char>& aTempBytes, vector<string>& aValuesToEncode, unsigned int& aNextCell, int aTotalMax, bool aOptimizeVarieties, bool aOptimizeCalcs);

	bool HasApi(const string& aName);

	CCdlTkImplementation& FindImp(const string& aName);

	CMLCompDataInstOptImpl* FindSimilarImpl(const CMLCompDataInstOptImpls& aImpls, const CCdlTkImplementation& aImpl);

	string DefinitionString(int aByteCodeIndex, const string& aApiName);

	bool CheckByteCodeIndexInRange(int aByteCodeIndex);

	void SetGenericFunc(CMLCompDataInstOptImpl& aImpl, SCompDataImplFunc::TFuncType aType);

	void SetLineFunc(CMLCompDataLineInstOptImpl& aImpl);

	void SetSubTableFunc(CMLCompDataSubTableInstOptImpl& aImpl);

	void SetParamLimits(CMLCompDataLineInstOptImpl& aImpl);

	void ValidateRequiredParams(string aApiName, CCdlTkApiParams& aParams, bool aOption, bool aColumn, bool aRow);

	void CountApiParams(CCdlTkImplementation& aApi, int& aParams);

	SCompDataImplFunc& AddImplFunc(SCompDataImplFunc::TFuncType aType);

	SCompDataImplFunc& AddImplFunc(SCompDataImplFunc::TFuncType aType, CCdlTkApiParams& aParams);

	void SetGenericAPI(SCompDataImplFunc::TFuncType aType, const string& aName);

	void SetExtraCpp(const string& aFirstInstanceName);

	void OutputStats();

	void AddTableToInstance(TMLCompDataTable& aTable, TMLCompDataTable::TMLCompDataSubTable& aSub, int aTableNum);

	void UpdateTables(TMLCompDataTable& aTable);

	void AddTableParamLimitsImpl(const string& aApiName, int aByteCodeIndex, SCompDataImplFunc::TFuncType aType, bool aNeedsOptions);

	void UpdateTableParamLimitsImpl(const string& aApiName, int aByteCodeIndex);

	void AddTableLimitsImpl(const string& aApiName, TMLCompDataTable::TMLCompDataSubTable& aSubTable);

	void AddTableLimitsImplDefn(TMLCompDataTable::TMLCompDataSubTable& aSubTable, CCdlTkImplementation& aImpl);

	void AddTableImpl(const string& aApiName, TMLCompDataTable& aTable, TMLCompDataTable::TMLCompDataSubTable& aSub);

	void AddParamLimits(TMLCompDataLine& aLine, bool aNeedsOptions);

	void UpdateParamLimits(const string& apiName);

	void SetDummyTableData(TMLCompDataTable& aTable, TMLCompDataTable::TMLCompDataSubTable& aSubTable, CMLCompDataInstOptImpl& aImpl);

	void UpdateTableData(TMLCompDataTable& aTable, TMLCompDataTable::TMLCompDataSubTable& aSubTable, CMLCompDataInstOptImpl& aImpl);

	void EncodeValue(vector<char>& aBytes, string aValue);

	void EncodeValue(vector<char>& aBytes, int aValue);

	void EncodeParentRelativeValue(vector<char>& aBytes, int aValue);

	void MirrorParamName(string& aParamName);

private:

	MLCompDataCdlInstanceOpt& iInstances;

	TMLCompData* iLayout;

	string iName;

	string iZoomName;

	CCdlTkInterface& iInterface;

	CCdlTkInstance* iInstance; // not owned

	CMLCompDataInstOptImpls iImpls;

	CMLCompDataInstOptImpls iTableImpls;

	typedef vector<SCompDataImplFunc*> CImplFuncs;

	CImplFuncs iFuncs;

	int iZoomLevel;

	bool iAllParams;

	int iBaseOffset; // offset from the start of the main data table to the start of this instance's data

	};

CMLCompDataInstOpt::CMLCompDataInstOpt(MLCompDataCdlInstanceOpt& aInstances, TMLCompData* aLayout, const string& aInstName, const string& aZoomName, int aZoomLevel, bool aAllParams, bool aNonCompleteInstance)

	: 

	iInstances(aInstances), 

	iLayout(aLayout),

	iName(aInstName), 

	iZoomName(aZoomName), 

	iZoomLevel(aZoomLevel),

	iInterface(iInstances.Interface()),

	iAllParams(aAllParams),

	iBaseOffset(0)

	{

	string zoomInstName = aInstName;

	if(aZoomName.length() > 0)

		zoomInstName += "_" + aZoomName;

	iInstance = new CCdlTkInstance(iInterface);

	iInstance->SetName(zoomInstName);

	CCdlTkImplementations& impl = iInstance->Impl();

	for (CCdlTkImplementations::iterator pImpl = impl.begin(); pImpl != impl.end(); ++pImpl)

		{

		const CCdlTkInterface& iface = (*pImpl)->Instance().Interface();

		const CCdlTkApi& api = (*pImpl)->Api();

		if(aLayout->iIsBaseInstance)

			{

			// for a base instance, need to set a default implementation

			// even for missing data

			(*pImpl)->SetDefinition(CdlTkUtil::ShortToHexString(0) + ",\t// " + KDefinitionNotDefined);

			// preliminary implementation of "blank" implementation. cdl engine searches to ensure that

			// all implementations are not NULL. So this will satisfy that test. However, if any of the 

			// methods are called, there will be an access violation, which will cause a panic

			// this will be a successful guide to implementers not to call the API when the wrong layout

			// pack is installed.

			string definition = "(" + iface.NamespaceName() + "::" + api.PointerType() + ")((void*)4), // LAYOUT NOT DEFINED FOR THIS INSTANCE";

			(*pImpl)->SetPointerReference(definition); 

			}

        else if(aNonCompleteInstance)

            {

			// for a base instance, need to set a default implementation

			// even for missing data

			(*pImpl)->SetDefinition(CdlTkUtil::ShortToHexString(0) + ",\t// " + KDefinitionNotDefined);

            // but we need the pointer to be null so that CdlEngine falls through the layer below

			string definition =  "0, // " + iface.NamespaceName() + "::" + api.PointerType();

			(*pImpl)->SetPointerReference(definition); 

            }

        else

			{

			// Initially set definition that will not compile in the resulting code.