/*

* Copyright (c) 2007 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 "MLEqCompData.h"

#include "MLEqCompDataParse.h"

#include "MLEqCompData2DHuiML.h"

#include "MLAttributes.h"

#include "FormulaTree.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 KEqCompDataKeywordParamLeft = "l";

const string KEqCompDataKeywordParamTop = "t";

const string KEqCompDataKeywordParamRight = "r";

const string KEqCompDataKeywordParamBottom = "b";

const string KEqCompDataKeywordParamWidth = "w";

const string KEqCompDataKeywordParamHeight = "h";

const string KEqCompDataPaneOutputOrder[] = 

	{

	KEqCompDataKeywordParamLeft,

	KEqCompDataKeywordParamTop,

	KEqCompDataKeywordParamRight,

	KEqCompDataKeywordParamBottom,

	KEqCompDataKeywordParamWidth,

	KEqCompDataKeywordParamHeight

	};

const int KEqCompDataPaneOutputOrderSize = ARRAY_LEN(KEqCompDataPaneOutputOrder);

const string KEqCompDataKeywordParamType = "Type";

const string KEqCompDataKeywordParamFont = "Font";

const string KEqCompDataKeywordParamNumCols = "NumCols";

const string KEqCompDataKeywordParamNumRows = "NumRows";

const string KEqCompDataKeywordScreenContents = "Screen Contents";

const string KEqCompDataKeywordUnderscore = "_";

const string KEqCompDataKeywordLineNameSuffixGraphic = "g";

const string KEqCompDataKeywordLineNameSuffixText = "t";

const string KEqCompDataSearchCollectionNumeric = "0123456789";

const string KEqCompDataBadValue = "Bad Value";

const string KEqCompDataLayoutEmpty = "ELayoutEmpty";

const string KEqCompDataUnknown = "unknown";

const string KEqCompDataCellNameLeft("l");

const string KEqCompDataCellNameRight("r");

const string KEqCompDataCellNameJustification("J");

const string KAttributeNameStyle1 = "style_1";

const string KAttributeNameStyle1Plain = "plain";

const string KAttributeNameStyle1Bold = "bold";

const string KAttributeNameNumberOfColumns = "Number_of_columns";

const string KAttributeNameNumberOfRows = "Number_of_rows";

const string KAttributeNameNumberOfRowsColsAuto = "AUTO";

//

// struct TMLEqCompDataFormula

//

TMLEqCompDataFormula::TMLEqCompDataFormula()

	:

	iFormulaString(),

	iZoomId(0),

	iFormulaTree(NULL)

	{

	}

TMLEqCompDataFormula::TMLEqCompDataFormula(const TMLEqCompDataFormula& aOther)

	:

	iFormulaString(aOther.iFormulaString),

	iZoomId(aOther.iZoomId),

	iFormulaTree(aOther.iFormulaTree)

	{

	}

const TMLEqCompDataFormula& TMLEqCompDataFormula::operator=(const TMLEqCompDataFormula& aOther)

	{

	if(this == &aOther)

		return aOther;

	iFormulaString = aOther.iFormulaString;

	iZoomId = aOther.iZoomId;

	if(iFormulaTree)

		{

		delete iFormulaTree;

		iFormulaTree = 0;

		}

	iFormulaTree = aOther.iFormulaTree;

	return *this;

	}

TMLEqCompDataFormula::TMLEqCompDataFormula(string aFormulaString)

	:

	iFormulaString(aFormulaString),

	iZoomId(0),

	iFormulaTree(NULL)

	{

	}

TMLEqCompDataFormula::~TMLEqCompDataFormula()

	{

	delete iFormulaTree;

	iFormulaTree = 0;

	}

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

	{

	return (iFormulaString == aOther.iFormulaString && iZoomId == aOther.iZoomId);

	}

void TMLEqCompDataFormula::Compile()

	{

	if(!iFormulaTree)

		{

		iFormulaTree = FormulaTreeNode::Parse(iFormulaString);

		}

	else

		{

		throw GeneralErr(string("TMLEqCompDataFormula::Compile - formula already parsed."));

		}

	}

//

// TMLEqCompDataValuesOptionSet

//

void TMLEqCompDataValuesOptionSet::Compile()

	{

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

		{

		pFormula->Compile();

		}

	}

//

// TMLEqCompDataValues

//

TMLEqCompDataValues::TMLEqCompDataValues()

	: 

	iLine(NULL), 

	iName(KEqCompDataBadValue)

	{

	}

TMLEqCompDataValues::TMLEqCompDataValues(TMLEqCompDataLine* aLine)

	: 

	iLine(aLine), 

	iName(aLine->iName)

	{

	}

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

	{

	typedef const vector<TMLEqCompDataFormula> TBase;

	bool eq =

		iName == aOther.iName &&

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

	return eq;

	}

TMLEqCompDataValues::~TMLEqCompDataValues()

	{

	}

bool TMLEqCompDataValues::Merge(TMLEqCompDataLine* aLine, string aName, TMLEqCompDataValues& 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)

		{

		TMLEqCompDataZoomLevels& otherZoomLevels = pOtherVal->second;

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

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

		if(aMirrorMerge)

			{

			if(iName == KEqCompDataCellNameJustification)

				{

				// reverse the justification

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

					{

					TMLEqCompDataCalcs& calcs = pCalcs->second;

					for(TMLEqCompDataCalcs::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));

string TMLEqCompDataValues::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 TMLEqCompDataValues::Compile(int aOptionSetId)

	{

	TMLEqCompDataValuesOptionSet& set = iOptionSets[aOptionSetId];

	set.Compile();

	}

string TMLEqCompDataValues::CppValue(const string& aValue)

	{

	if (aValue.size())

		return aValue;

	else

		return KEqCompDataLayoutEmpty;

	}

//

// TMLEqCompDataParentInfoSelector

//

TMLEqCompDataParentInfoSelector::TMLEqCompDataParentInfoSelector()

	{

	}

TMLEqCompDataParentInfoSelector::TMLEqCompDataParentInfoSelector(int aParentId, int aParentVariety)

	:

	iParentId(aParentId),

	iParentVariety(aParentVariety)

	{

	}

//

//  TMLEqCompDataParentInfo

//

TMLEqCompDataParentInfo::TMLEqCompDataParentInfo()

	:

	iLine(0)

	{

	}

TMLEqCompDataParentInfo::TMLEqCompDataParentInfo(TMLEqCompDataLine* aLine)

	:

	iLine(aLine)

	{

	}

TMLEqCompDataParentInfo::~TMLEqCompDataParentInfo()

	{

	}

void TMLEqCompDataParentInfo::Merge(const TMLEqCompDataParentInfo& aOther)

	{

/*

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

		{

		int varietyIndex = pOtherVariety->first;

		const TMLEqCompDataParentInfoSelector& selector = pOtherVariety->second;

		insert(make_pair(varietyIndex, selector));

		}

*/

	}

//

//  TMLEqCompDataLine

//

TMLEqCompDataLine::TMLEqCompDataLine()

:	iId(0),

	iName(KEqCompDataUnknown),

	iType(EUnknownComponent),

	iDrawingOrder(-1),

	iParentTable(0),

	iParentInfo(0),

	iIsUnique(true),

	iGlobalIndex(0),

	iIsMirroredHorizontally(false),

//	iAttributeInfo(0),

	iNumCols(1),

	iNumRows(1)

	{	

	}

TMLEqCompDataLine::TMLEqCompDataLine(const TMLEqCompDataLine& 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 TMLEqCompDataParentInfo(*(aOther.iParentInfo)); // we don't want to take ownership, so make our own copy

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

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

*/

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

		{

		TMLEqCompDataValues& val = pVal->second;

		val.iLine = this;

		}

	iParentTable = 0; // will be set during compile

	}

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

	{

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

	}

TMLEqCompDataLine::~TMLEqCompDataLine()

	{

/*

	delete iParentInfo;

	delete iAttributeInfo;

*/

	}

bool TMLEqCompDataLine::lessthan(TMLEqCompDataLine* aLeft, TMLEqCompDataLine* 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 TMLEqCompDataLine::ValuesEqual(const TMLEqCompDataLine& 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 TMLEqCompDataLine::Name() const

	{

	return iName;

	}

bool TMLEqCompDataLine::Merge(TMLEqCompDataLine& 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 TMLEqCompDataParentInfo();

			}

		if(aOtherLine.iParentInfo)

			{

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

			}

		if(!iAttributeInfo)

			{

			// must be screen...

			iAttributeInfo = new TMLEqCompDataAttributeInfo();

			}

		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 (TMLEqCompDataLine::iterator pOtherValues=aOtherLine.begin(); pOtherValues!=aOtherLine.end(); ++pOtherValues)

			{

			string index = pOtherValues->first;

			if(mirrorMerge)

				{

				// flip left and right

				if(index == KEqCompDataCellNameLeft)

					index = KEqCompDataCellNameRight;

				else if(index == KEqCompDataCellNameRight)

					index = KEqCompDataCellNameLeft;

				}

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

			}

		}

	return compatible;

	*/

	return false;

	}

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

	{

/*

	TMLAttributeZoomLevels* found = 0;

	TMLEqCompData& 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)

		{

		TMLEqCompDataAttributeInfoSelector& 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;

*/

	return NULL;

	}

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

	{

	TMLAttributeZoomLevels* found = NULL;

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

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

		{

		const TMLEqCompDataParentInfoSelector& 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* TMLEqCompDataLine::FindAttributeZoomLevels(string aAttribSetName, int aAttribId)

	{

	TMLEqCompData& 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)