/*

* 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: 

*    

*

*/

#include "MLCompData.h"

#include "MLCompDataParse.h"

#include "MLCompData2Cdl.h"

#include "MLAttributes.h"

#include "LayoutCompilerErr.h"

#include "CodeGenConsts.h"

#include "UsefulDefinitions.h"

#include <AknDef.hrh>

#include <set>

#include <sstream>

#include <iostream>

#include <algorithm>

//

// const data

//

const string KCompDataPaneOutputOrder[] = {"C", "l", "t", "r", "b", "W", "H"};

const string KCompDataPaneOutputOrderMirrored[] = {"C", "r", "t", "l", "b", "W", "H"};

const int KCompDataPaneOutputOrderSize = ARRAY_LEN(KCompDataPaneOutputOrder);

const string KCompDataGraphicOutputOrder[] = {"NumCols", "NumRows", "C", "l", "t", "r", "b", "W", "H"};

const string KCompDataGraphicOutputOrderMirrored[] = {"NumCols", "NumRows", "C", "r", "t", "l", "b", "W", "H"};

const int KCompDataGraphicOutputOrderSize = ARRAY_LEN(KCompDataGraphicOutputOrder);

const string KCompDataTextOutputOrder[] = {"NumCols", "NumRows", "C", "l", "t", "r", "b", "W", "H", "J", "Font"};

const string KCompDataTextOutputOrderMirrored[] = {"NumCols", "NumRows", "C", "r", "t", "l", "b", "W", "H", "J", "Font"};

const int KCompDataTextOutputOrderSize = ARRAY_LEN(KCompDataTextOutputOrder);

const string KCompDataKeywordParamHeight = "H";

const string KCompDataKeywordParamType = "Type";

const string KCompDataKeywordParamFont = "Font";

const string KCompDataKeywordParamNumCols = "NumCols";

const string KCompDataKeywordParamNumRows = "NumRows";

const string KCompDataKeywordScreenContents = "Screen Contents";

const string KCompDataKeywordUnderscore = "_";

const string KCompDataKeywordLineNameSuffixGraphic = "g";

const string KCompDataKeywordLineNameSuffixText = "t";

const string KCompDataSearchCollectionNumeric = "0123456789";

const string KCompDataBadValue = "Bad Value";

const string KCompDataLayoutEmpty = "ELayoutEmpty";

const string KCompDataUnknown = "unknown";

const string KCompDataCellNameLeft("l");

const string KCompDataCellNameRight("r");

const string KCompDataCellNameJustification("J");

const string KAttributeNameStyle1 = "style_1";

const string KAttributeNameStyle2 = "style_2";

const string KAttributeNameStyle3 = "style_3";

const string KAttributeNameStyle1Plain = "plain";

const string KAttributeNameStyle1Bold = "bold";

const string KAttributeNameStyle3Outline = "outline";

const string KAttributeNameNumberOfColumns = "Number_of_columns";

const string KAttributeNameNumberOfRows = "Number_of_rows";

const string KAttributeNameNumberOfRowsColsAuto = "AUTO";

//

// TMLCompDataValues

//

TMLCompDataValues::TMLCompDataValues()

	: 

	iLine(NULL), 

	iName(KCompDataBadValue)

	{

	}

TMLCompDataValues::TMLCompDataValues(TMLCompDataLine* aLine)

	: 

	iLine(aLine), 

	iName(aLine->iName)

	{

	}

bool TMLCompDataValues::operator==(const TMLCompDataValues& aOther) const

	{

	typedef const map<int, TMLCompDataZoomLevels> TBase;

	bool eq =

		iName == aOther.iName &&

		(*static_cast<TBase*>(this) == aOther);

	return eq;

	}

TMLCompDataValues::~TMLCompDataValues()

	{

	}

bool TMLCompDataValues::Merge(TMLCompDataLine* aLine, string aName, TMLCompDataValues& aOtherValues, bool aMirrorMerge)

	{

	iLine = aLine;

	iName = aName; // we may be swapping l and r

	// create missing values in this line if needed

	for (iterator pOtherVal=aOtherValues.begin(); pOtherVal!=aOtherValues.end(); ++pOtherVal)

		{

		TMLCompDataZoomLevels& otherZoomLevels = pOtherVal->second;

		TMLCompDataZoomLevels& thisZoomLevels = (*this)[pOtherVal->first];

		thisZoomLevels = otherZoomLevels; // we want exactly the correct number of calcs from the other cell

		if(aMirrorMerge)

			{

			if(iName == KCompDataCellNameJustification)

				{

				// reverse the justification

				for(TMLCompDataZoomLevels::iterator pCalcs = thisZoomLevels.begin(); pCalcs != thisZoomLevels.end(); ++pCalcs)

					{

					TMLCompDataCalcs& calcs = pCalcs->second;

					for(TMLCompDataCalcs::iterator pVal = calcs.begin(); pVal != calcs.end(); ++pVal)

						pVal->second = MirrorJustificationValue(pVal->second);

					}

				}

			}

		}

	return true;

	}

const string KParamLimitNames[] = { "NumCols", "NumRows" };

const string KHorizNames[] = { "l", "r", "W" };

const string KVertNames[] = { "t", "b", "H", "Font" };

const set<string> KParamLimitNamesSet(KParamLimitNames, ARRAY_END(KParamLimitNames));

const set<string> KHorizNamesSet(KHorizNames, ARRAY_END(KHorizNames));

const set<string> KVertNamesSet(KVertNames, ARRAY_END(KVertNames));

TMLCompDataValues::TCompDataCellType TMLCompDataValues::Type(string aName)

	{

	TMLCompDataValues::TCompDataCellType type;

	if(KParamLimitNamesSet.find(aName) != KParamLimitNamesSet.end())

		{

		type = TMLCompDataValues::ECellTypeParamLimit;	

		}

	else if(KHorizNamesSet.find(aName) != KHorizNamesSet.end())

		{

		type = TMLCompDataValues::ECellTypeCol;

		}

	else if(KVertNamesSet.find(aName) != KVertNamesSet.end())

		{

		type = TMLCompDataValues::ECellTypeRow;

		}

	else

		{

		type = TMLCompDataValues::ECellTypeDefault;

		}

	return type;

	}

string TMLCompDataValues::MirrorJustificationValue(const string& aValue)

	{

	int val = CdlTkUtil::ParseInt(aValue);

	if(val == ELayoutAlignLeft)

		val = ELayoutAlignRight;

	else if(val == ELayoutAlignRight)

		val = ELayoutAlignLeft;

	return CdlTkUtil::IntToString(val);

	}

void TMLCompDataValues::Compile(const string& aCellName)

	{

	// ensure that missing varieties are filled with null values

	// we assume that each variety is present in all zoom levels that are defined

	if(iLine) // screen contents isn't contained in a line

		{

		int thisSize = size();

		int numVarieties = iLine->MaxVariety() + 1; // get zero based index

		int maximum = max(numVarieties, thisSize);

		unsigned int maxMulti;

		switch(TMLCompDataValues::Type(aCellName))

			{

			case ECellTypeCol:

				maxMulti = iLine->NumCols();

				break;

			case ECellTypeRow:

				maxMulti = iLine->NumRows();

				break;

			default:

				maxMulti = 1;

				break;

			}

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

			{

			// operator[] fills in missing values

			TMLCompDataZoomLevels& zoomLevels = (*this)[ii];

			for(TMLCompDataZoomLevels::iterator pCalcs = zoomLevels.begin(); pCalcs != zoomLevels.end(); ++pCalcs)

				{

				TMLCompDataCalcs& calcs = pCalcs->second;

				if(ii < numVarieties)

					{

					if(calcs.size() > maxMulti)

                        {

                        // Handle the case where data from a merged instance has too many calcs

                        TMLCompDataCalcs::iterator start = calcs.find(maxMulti);

                        TMLCompDataCalcs::iterator end = calcs.end();

                        calcs.erase(start, end);

                        }

					}

				else

					{

					// get rid of varieties from instances that we have merged onto

					calcs.clear();			

					}

				}

			}

		}

	}

string TMLCompDataValues::CppValue(const string& aValue)

	{

	if (aValue.size())

		return aValue;

	else

		return KCompDataLayoutEmpty;

	}

//

// TMLCompDataParentInfoSelector

//

TMLCompDataParentInfoSelector::TMLCompDataParentInfoSelector()

	{

	}

TMLCompDataParentInfoSelector::TMLCompDataParentInfoSelector(int aParentId, int aParentVariety)

	:

	iParentId(aParentId),

	iParentVariety(aParentVariety)

	{

	}

//

//  TMLCompDataParentInfo

//

TMLCompDataParentInfo::TMLCompDataParentInfo()

	:

	iLine(0)

	{

	}

TMLCompDataParentInfo::TMLCompDataParentInfo(TMLCompDataLine* aLine)

	:

	iLine(aLine)

	{

	}

TMLCompDataParentInfo::~TMLCompDataParentInfo()

	{

	}

void TMLCompDataParentInfo::Merge(const TMLCompDataParentInfo& aOther)

	{

	for (const_iterator pOtherVariety = aOther.begin(); pOtherVariety != aOther.end(); ++pOtherVariety)

		{

		int varietyIndex = pOtherVariety->first;

		const TMLCompDataParentInfoSelector& selector = pOtherVariety->second;

		insert(make_pair(varietyIndex, selector));

		}

	}

//

//  TMLCompDataLine

//

TMLCompDataLine::TMLCompDataLine()

:	iId(0),

	iName(KCompDataUnknown), 

	iType(EUnknownComponent),

	iDrawingOrder(-1),

	iMaxVariety(0),

	iParentTable(0),

	iParentInfo(0),

	iAttributeInfo(0),

	iIsUnique(true),

	iGlobalIndex(0),

	iIsMirroredHorizontally(false),

	iNeedsOptions(false),

	iNeedsCols(false),

	iNeedsRows(false),

	iNumCols(1),

	iNumRows(1)

	{	

	}

TMLCompDataLine::TMLCompDataLine(const TMLCompDataLine& aOther)

	{

	if(this == &aOther)

		return;

	*this = aOther; // this will take a copy of the owning pointer

	if(aOther.iParentInfo) // if it wasn't zero

		iParentInfo = new TMLCompDataParentInfo(*(aOther.iParentInfo)); // we don't want to take ownership, so make our own copy

	if(aOther.iAttributeInfo) // if it wasn't zero

		iAttributeInfo = new TMLCompDataAttributeInfo(*(aOther.iAttributeInfo)); // we don't want to take ownership, so make our own copy

	for (iterator pVal = begin(); pVal != end(); ++pVal)

		{

		TMLCompDataValues& val = pVal->second;

		val.iLine = this;

		}

	iParentTable = 0; // will be set during compile

	}

bool TMLCompDataLine::operator==(const TMLCompDataLine& aOther) const

	{

	return (Name() == aOther.Name()) && ValuesEqual(aOther);

	}

TMLCompDataLine::~TMLCompDataLine()

	{

	delete iParentInfo;

	delete iAttributeInfo;

	}

bool TMLCompDataLine::lessthan(TMLCompDataLine* aLeft, TMLCompDataLine* aRight)

	{

	string pureNameLeft = aLeft->NameDiscountingSuffix();

	string pureNameRight = aRight->NameDiscountingSuffix();

	if(pureNameLeft != pureNameRight)

		{

		return (aLeft->iName) < (aRight->iName);

		}

	else

		{

		int left = CdlTkUtil::ParseInt(aLeft->NameSuffix());

		int right = CdlTkUtil::ParseInt(aRight->NameSuffix());

		return left < right;

		}

	}

bool TMLCompDataLine::ValuesEqual(const TMLCompDataLine& aOther) const

	{

	bool eq = true;

	const_iterator pVal, pOther;

	for (pVal = begin(), pOther = aOther.begin(); 

		 eq && pVal != end() && pOther != aOther.end(); 

		 ++pVal, ++pOther)

		{

		eq = (*pVal == *pOther);

		}

	eq = eq && pVal == end() && pOther == aOther.end();

	return eq;

	}

string TMLCompDataLine::Name() const

	{

	return iName;

	}

bool TMLCompDataLine::Merge(TMLCompDataLine& aOtherLine)

	{

	bool compatible = 

		(iId == aOtherLine.iId) ||

		(iName == aOtherLine.iName) ||

		(iType == aOtherLine.iType);

	if(compatible)

		{

		iDrawingOrder = aOtherLine.iDrawingOrder;

		iMaxVariety = aOtherLine.iMaxVariety;

		iIsMirroredHorizontally |= aOtherLine.iIsMirroredHorizontally; // in the case of an elaf layout merging onto an abrw layout, the chirality will be preserved

		iNeedsOptions |= aOtherLine.iNeedsOptions;

		if(!iParentInfo)

			{

			// must be screen...

			iParentInfo = new TMLCompDataParentInfo();

			}

		if(aOtherLine.iParentInfo)

			{

			iParentInfo->Merge(*(aOtherLine.iParentInfo));

			}

		if(!iAttributeInfo)

			{

			// must be screen...

			iAttributeInfo = new TMLCompDataAttributeInfo();

			}

		if(aOtherLine.iAttributeInfo)

			{

			iAttributeInfo->Merge(*(aOtherLine.iAttributeInfo));

			}

		// for the API, we need to know if there are any multi-value components in either orientation

		iNeedsCols = iNeedsCols || aOtherLine.iNeedsCols;

		iNeedsRows = iNeedsRows || aOtherLine.iNeedsRows;

		// however, we want exactly the correct number of calcs from the other cell

		iNumCols = aOtherLine.iNumCols;

		iNumRows = aOtherLine.iNumRows;

		// if this line has no values, then we must do a mirror merge

		bool mirrorMerge = empty() && iIsMirroredHorizontally;

		// create missing values in this line if needed

		for (TMLCompDataLine::iterator pOtherValues=aOtherLine.begin(); pOtherValues!=aOtherLine.end(); ++pOtherValues)

			{

			string index = pOtherValues->first;

			if(mirrorMerge)

				{

				// flip left and right

				if(index == KCompDataCellNameLeft)

					index = KCompDataCellNameRight;

				else if(index == KCompDataCellNameRight)

					index = KCompDataCellNameLeft;

				}

			(*this)[index].Merge(this, index, pOtherValues->second, mirrorMerge);

			}

		}

	return compatible;

	}

TMLAttributeZoomLevels* TMLCompDataLine::GetAttributeZoomLevels(string aAttribName, int aVariety)

	{

	TMLAttributeZoomLevels* found = 0;

	TMLCompData& data = *(iParentTable->iTables);

	TMLAttributes& attributes = *(data.iAttributes);

	int attribId = attributes.iNames[aAttribName];

	if(attribId == 0)

		throw GeneralErr(string("Attribute name not found: ") + aAttribName);

	// find out from attribute info which attribute set we need

	// but if there is none specified, we don't need to search

	if(iAttributeInfo)

		{

		TMLCompDataAttributeInfoSelector& selector = (*iAttributeInfo)[aVariety];

		// go to parent straight away, as parent always stores attribute data for its children

		found = GetParentAttributeZoomLevels(selector.iAttributeSetName, attribId, aVariety);

		}

	return found;

	}

TMLAttributeZoomLevels* TMLCompDataLine::GetParentAttributeZoomLevels(string aAttribSetName, int aAttribId, int aVariety)

	{

	TMLAttributeZoomLevels* found = NULL;

	TMLCompDataParentInfo::iterator pFoundSelector = iParentInfo->find(aVariety);

	if(pFoundSelector != iParentInfo->end())

		{

		const TMLCompDataParentInfoSelector& parentInfoSelector = pFoundSelector->second;

		if(iParentTable && iParentTable->iParentLine)

			{

			found = iParentTable->iParentLine->FindAttributeZoomLevels(aAttribSetName, aAttribId);

			if(!found)

				{

				// recurse to next parent container

				int variety = parentInfoSelector.iParentVariety;

				iParentTable->iParentLine->GetParentAttributeZoomLevels(aAttribSetName, aAttribId, variety);

				}

			}

		}

	return found;

	}

TMLAttributeZoomLevels* TMLCompDataLine::FindAttributeZoomLevels(string aAttribSetName, int aAttribId)

	{

	TMLCompData& data = *(iParentTable->iTables);

	TMLAttributes& attributes = *(data.iAttributes);

	int id = iId;

	TMLAttributes::iterator foundAttributeSetComponent = attributes.find(id);

	if(foundAttributeSetComponent != attributes.end())

		{

		TMLAttributeSetComponent& component = foundAttributeSetComponent->second;

		TMLAttributeSet* pSet = component[aAttribSetName];

		if(pSet)

			{

			TMLAttributeSet& attributeSet = *pSet;

			TMLAttributeSet::iterator foundAttrib = attributeSet.find(aAttribId);

			if(foundAttrib != attributeSet.end())

				{

				return &(foundAttrib->second);

				}

			}

		}

	return NULL;

	}

void TMLCompDataLine::Compile()

	{

	// compile values

	for(iterator pVal = begin(); pVal != end(); ++pVal)

		{

		(pVal->second).Compile(pVal->first);

		}

	CompileParamLimits(TMLCompDataValues::ECellTypeCol, KCompDataKeywordParamNumCols);

	CompileParamLimits(TMLCompDataValues::ECellTypeRow, KCompDataKeywordParamNumRows);

	CompileFontHeights();

	}

void TMLCompDataLine::CompileParamLimits(TMLCompDataValues::TCompDataCellType aParamLimitType, const string& aParamLimitCellName)

	{

	TMLCompDataValues paramLimits(this);

	for(iterator pValues = begin(); pValues != end(); ++pValues)

		{

		string cellName = pValues->first;

		if(TMLCompDataValues::Type(cellName) == aParamLimitType)

			{

			// calculate the param limits for this cell