/*

* Copyright (c) 2002-2004 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 "CppWriter.h"

#include "layoutcompilererr.h"

#include "CodeGenConsts.h"

#include "UsefulDefinitions.h"

#include <cdlcompilertoolkit/cdltkutil.h>

#include <fstream>

#include <algorithm>

#include <iostream> // !!! for debug output only

using namespace CdlCompilerToolkit;

string whiteSpace = " \t\r\n";

const string KTextOutputOrder[] = {"C", "l", "r", "B", "W", "J", "Font"};

const string KTextOutputOrderMirrored[] = {"C", "r", "l", "B", "W", "J", "Font"};

const int KTextOutputOrderSize = ARRAY_LEN(KTextOutputOrder);

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

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

const int KWindowOutputOrderSize = ARRAY_LEN(KWindowOutputOrder);

// class TValuesCppWriter

void TValuesCppWriter::WriteCpp(ostream& aCpp)

	{

	for (TValues::const_iterator it = iValues.begin(); it != iValues.end(); ++it)

		{

		if (it != iValues.begin())

			aCpp << ", ";

		aCpp << TValues::CppValue(*it);

		}

	}

// class TLayoutLineCppWriter

void TLayoutLineCppWriter::WriteCpp(ostream& aCpp)

	{

	// write line structure

	WriteLineClassName(aCpp);

	aCpp << Name() << " = { ";

	WriteCppData(aCpp);

	aCpp << " };" << endl << endl;

	}

void TLayoutLineCppWriter::WriteCppData(ostream& aCpp)

	{

	if (iLine.iNeedsIndex)

		WriteVarCppData(aCpp);

	else

		WriteFixedCppData(aCpp);

	}

int TLayoutLineCppWriter::WriteParamList(ostream& aLag, const vector<string>& aParams)

	{

	int written = 0;

	if (aParams.size() > 0)

		{

		written = 2*aParams.size();

		aLag << "(";

		for (vector<string>::const_iterator pParam = aParams.begin(); pParam != aParams.end(); ++pParam)

			{

			if (pParam != aParams.begin())

				aLag << ", ";

			aLag << *pParam;

			written += pParam->size();

			}

		aLag << ")";

		}

	return written;

	}

int TLayoutLineCppWriter::ValCount()

	{

	int count = 0;

	for (TLayoutLine::const_iterator pVal = iLine.begin(); pVal != iLine.end(); ++pVal)

		{

		if (TLayoutTable::IsValueColumn(pVal->first))

			count += pVal->second.size();

		}

	return count;

	}

// class TWindowLineCppWriter

string TWindowLineCppWriter::Name()

	{

	if (iLine.iIsUnique)

		return CdlTkUtil::ToCpp(iLine.Name());

	else

		return CdlTkUtil::ToCpp(iLine.TableName());

	}

void TWindowLineCppWriter::WriteLineClassName(ostream& aCpp)

	{

	if (iLine.iNeedsIndex)

		{

		aCpp << "const SVarWindowLine<" << ValCount() << "> ";

		}

	else

		{

		aCpp << "const SFixedWindowLine ";

		}

	}

void TWindowLineCppWriter::WriteVarCppData(ostream& aCpp)

	{

	aCpp << " { "; // suppress the first offset

	int offset = 0;

	for (int i=0; i<KWindowOutputOrderSize-1; i++) // Last offset is not used

		{

		offset += iLine[KWindowOutputOrder[i]].size();

		if ( i != 0 ) 

			aCpp << ", ";

		aCpp << offset;

		}

	aCpp << " }, { ";

	WriteFixedCppData(aCpp);

	aCpp << " }";

	}

void TWindowLineCppWriter::WriteFixedCppData(ostream& aCpp)

	{

	for (int i=0; i<KWindowOutputOrderSize; i++)

		{

		if (i>0)

			aCpp << ", ";

		TValuesCppWriter writer(iLine[KWindowOutputOrder[i]]);

		writer.WriteCpp(aCpp);

		}

	}

void TWindowLineCppWriter::FillParamLists(vector<string>& aDef, vector<string>& aCtor)

	{

	if (iLine.iNeedsP)

		{

		aDef.push_back(KParamParentRect);

		aCtor.push_back(KParamParentRect);

		}

	if (iLine.iNeedsIndex)

		{

		aCtor.push_back(CdlTkUtil::IntToString(iLine.iIsMirroredHorizontally));

		for (int i=0; i<KWindowOutputOrderSize; i++)

			{

			// need to worry about parameter mirroring here. The problem is that 

			// the macro needs to have a fixed parameter ordering, but the parameters

			// might vary between variants, therefore the order of mirrored parameters 

			// may vary, e.g. (l, t) becomes (t, r) etc. Solution is to swap l and r if the line is mirrored

			// just for the macro definition (not for the ctor). 

			string name = KWindowOutputOrder[i];

			string nameMirrored = KWindowOutputOrderMirrored[i];

			const TValues& defValues = iLine[iLine.iIsMirroredHorizontally ? nameMirrored : name];

			if (defValues.iNeedsIndex)

				{

				string param = CdlTkUtil::ToCpp(defValues.ParamName());

				if (find(aDef.begin(), aDef.end(), param) == aDef.end()) // param Only written once to Macro

					{

					aDef.push_back(param);

					}

				}

			const TValues& ctorValues = iLine[name];

			if (ctorValues.iNeedsIndex)

				{

				string param = CdlTkUtil::ToCpp(ctorValues.ParamName());

				aCtor.push_back(param);

				}

			else

				{

				aCtor.push_back("0");

				}

			}

		}

	}

void TWindowLineCppWriter::WriteMacro(ostream& aLag)

	{

	vector<string> def_params;

	vector<string> ctor_params;

	ctor_params.push_back(CdlTkUtil::IntToString(iLine.iGlobalIndex));

	FillParamLists(def_params, ctor_params);

	aLag << "#define AKN_LAYOUT_WINDOW_" << Name();

	WriteParamList(aLag, def_params);

	aLag << "\t" << KTypeWindowLineLayout;		

	WriteParamList(aLag, ctor_params);

	aLag << endl;

	}

// class TTextLineCppWriter

string TTextLineCppWriter::Name()

	{

	return CdlTkUtil::ToCpp(iLine.TableName());

	}

void TTextLineCppWriter::FillParamLists(vector<string>& aDef, vector<string>& aCtor)

	{

	iBaseLineVariation = false;

	if (iLine.iNeedsP)

		{

		aDef.push_back(KParamParentRect);

		aCtor.push_back(KParamParentRect);

		}

	if (iLine.iNeedsIndex)

		{

		aCtor.push_back(CdlTkUtil::IntToString(iLine.iIsMirroredHorizontally));

		for (int i=0; i<KTextOutputOrderSize; i++)

			{

			// need to worry about parameter mirroring here. The problem is that 

			// the macro needs to have a fixed parameter ordering, but the parameters

			// might vary between variants, therefore the order of mirrored parameters 

			// may vary, e.g. (l, t) becomes (t, r) etc. Solution is to swap l and r if the line is mirrored

			// just for the macro definition (not for the ctor). 

			string name = KTextOutputOrder[i];

			string nameMirrored = KTextOutputOrderMirrored[i];

			const TValues& defValues = iLine[iLine.iIsMirroredHorizontally ? nameMirrored : name];

			if (defValues.iNeedsIndex)

				{

				string param = CdlTkUtil::ToCpp(defValues.ParamName());

				if (find(aDef.begin(), aDef.end(), param) == aDef.end()) // uniqueness check

					{

					aDef.push_back(param);

					}

				// record whether some of the variation comes from the Baseline column

				if ( defValues.iName == "B")

					iBaseLineVariation = true;	

				}

			const TValues& ctorValues = iLine[name];

			if (ctorValues.iNeedsIndex)

				{

				string param = CdlTkUtil::ToCpp(ctorValues.ParamName());

				aCtor.push_back(param);

				}

			else

				{

				aCtor.push_back("0");

				}

			}

		}

	}

void TTextLineCppWriter::WriteMacro(ostream& aLag)

	{

	vector<string> def_params;

	vector<string> ctor_params;

	ctor_params.push_back(CdlTkUtil::IntToString(iLine.iGlobalIndex));

	FillParamLists(def_params, ctor_params);

	aLag << "#define AKN_LAYOUT_TEXT_" << Name();

	WriteParamList(aLag, def_params);

	aLag << "\t" << KTypeTextLineLayout;

	WriteParamList(aLag, ctor_params);

	aLag << endl;

// Also write out a multiline_text if there are more than one Baselines supplied.  Number of lines is always user-supplied

	vector<string> multiline_def_params;

	vector<string> multiline_ctor_params;

	if ( iBaseLineVariation )

		{

		multiline_ctor_params.push_back(CdlTkUtil::IntToString(iLine.iGlobalIndex));

		if (iLine.iNeedsP)

			{

			multiline_def_params.push_back(KParamParentRect);

			multiline_ctor_params.push_back(KParamParentRect);

			}

		if (iLine.iNeedsIndex) // this condition has already been tested when setting iBaseLineVariation, but check again here for completeness

			{

			multiline_ctor_params.push_back(CdlTkUtil::IntToString(iLine.iIsMirroredHorizontally));

			}

			for (int i=0; i<KTextOutputOrderSize; i++)

				{

				// need to worry about parameter mirroring here. The problem is that 

				// the macro needs to have a fixed parameter ordering, but the parameters

				// might vary between variants, therefore the order of mirrored parameters 

				// may vary, e.g. (l, t) becomes (t, r) etc. Solution is to swap l and r if the line is mirrored

				// just for the macro definition (not for the ctor). 

				string name = KTextOutputOrder[i];

				string nameMirrored = KTextOutputOrderMirrored[i];

				const TValues& defValues = iLine[iLine.iIsMirroredHorizontally ? nameMirrored : name];

				if (defValues.iNeedsIndex) 

					{

					if (defValues.iName != "B") 

						{

						string param = CdlTkUtil::ToCpp(defValues.ParamName());

						if (find(multiline_def_params.begin(), multiline_def_params.end(), param) == multiline_def_params.end())

							{

							multiline_def_params.push_back(param);

							}

// A variable parameter that is tied to the baseline is NOT suppressed in the Multiline

// You have to supply the parameter in the macro as a zero

						}

					}

				const TValues& ctorValues = iLine[name];

				if (ctorValues.iNeedsIndex)

					{

					if (defValues.iName != "B") 

						{

						string param = CdlTkUtil::ToCpp(ctorValues.ParamName());

						multiline_ctor_params.push_back(param);

// A variable parameter that is tied to the baseline is NOT suppressed in the Multiline

// You have to supply the parameter in the macro as a zero

						}

					else

						{

						multiline_ctor_params.push_back("0");

						}

					}

				else

					{

					multiline_ctor_params.push_back("0");

					}

				} // end of for loop

		// The final param for the multiline macro is user input for the layout utilities (pass-through data)

		multiline_def_params.push_back(KParamNameNumberOfLinesShown);

		multiline_ctor_params.push_back(KParamNameNumberOfLinesShown);

		aLag << "#define AKN_LAYOUT_MULTILINE_TEXT_" << Name();

		WriteParamList(aLag, multiline_def_params);

		aLag << "\t" + KTypeMultiLineTextLayout;

		WriteParamList(aLag, multiline_ctor_params);

		aLag << endl;

		} // end of if on baseline_variation

	}

void TTextLineCppWriter::WriteLineClassName(ostream& aCpp)

	{

	if (iLine.iNeedsIndex)

		{

		aCpp << "const SVarTextLine<" << ValCount()  << "> ";

		}

	else

		{

		aCpp << "const SFixedTextLine ";

		}

	}

void TTextLineCppWriter::WriteVarCppData(ostream& aCpp)

	{

	aCpp << " { ";  // ! Do not write out the first 0

	int offset = 0;

	for (int i=0; i<KTextOutputOrderSize-1; i++) // last offset IS used because font id is written out

		{

		offset += iLine[KTextOutputOrder[i]].size();

		if ( i != 0 )

			aCpp << ", "; 

		aCpp << offset;

		}

	aCpp << " }, { ";

	WriteFixedCppData(aCpp);

	aCpp << " }";

	}

void TTextLineCppWriter::WriteFixedCppData(ostream& aCpp)

	{

	for (int i=0; i<KTextOutputOrderSize; i++)

		{

		if ( i > 0 )

			aCpp << ", ";

		TValuesCppWriter writer(iLine[KTextOutputOrder[i]]);

		writer.WriteCpp(aCpp);

		}

	}

void TTextLineCppWriter::WriteMultiLineTextParamList(ostream& aLag, const vector<string>& aParams)

	{

	if (aParams.size() > 0)

		{

		aLag << "(";

		for (vector<string>::const_iterator pParam = aParams.begin(); pParam != aParams.end(); ++pParam)

			{

			if (pParam != aParams.begin())

				aLag << ", ";

			aLag << *pParam;

			}

		aLag << ", " << KParamNameNumberOfLinesShown;

		aLag << ")";

		}

	}

// class TLayoutTableCppWriter

void TLayoutTableCppWriter::WriteCppLineData(ostream& aCpp)

	{

	for (TLayoutTable::iterator it = iTable.begin(); it != iTable.end(); ++it)

		{

		TLayoutLineCppWriter* writer = CreateLayoutLineCppWriter(**it, iTable);

		writer->WriteCpp(aCpp);

		delete writer;

		}

	}

void TLayoutTableCppWriter::WriteCppTableData(ostream& aCpp)

	{

	}

void TLayoutTableCppWriter::WriteLag(ostream& aLag)

	{

	aLag << endl;

	int count=0;

	for (TLayoutTable::TLayoutSubTables::iterator it = iTable.iSubTables.begin(); it != iTable.iSubTables.end(); ++it)

		{

		WriteLagSubTable(**it, count++, aLag);

		}

	}

void TLayoutTableCppWriter::WriteLagSubTable(const TLayoutTable::TLayoutSubTable& aSubTable, int aCount, ostream& aLag)

	{

	// normal version

	string macro = "#define AKN_LAYOUT_TABLE_";

	macro = macro + CdlTkUtil::ToCpp(iTable.Name());

	if (aSubTable.size() != iTable.size())

		{

		macro = macro + "_SUB_TABLE_" + CdlTkUtil::IntToString(aCount);

		aLag << "// Sub table for " << iTable.Name() << ". Valid line indices are ";

		for (TLayoutTable::TLayoutSubTable::const_iterator pNum = aSubTable.begin(); pNum != aSubTable.end(); ++pNum)

			{

			if (pNum != aSubTable.begin())

				aLag << ", ";

			aLag << CdlTkUtil::IntToString(*pNum);

			}

		aLag << endl;

		}

	aLag << macro;

	int lineSet = 0;

	for (TLayoutTable::TLayoutSubTable::const_iterator pNum = aSubTable.begin(); pNum != aSubTable.end(); ++pNum)

		{

		if (*pNum < 32)

			lineSet |= (1 << *pNum);

		}

	vector<string> def_params;

	def_params.push_back(KParamLineIndex);

	vector<string> ctor_params;

	ctor_params.push_back(CdlTkUtil::IntToString(iTable.iFirstLineGlobalIndex));

	ctor_params.push_back(KParamLineIndex);

	ctor_params.push_back(CdlTkUtil::IntToHexString(lineSet));

	TLayoutLineCppWriter* writer = CreateLayoutLineCppWriter(*iTable[aSubTable[0]], iTable);

	writer->FillParamLists(def_params, ctor_params);

	int paramSize = writer->WriteParamList(aLag, def_params);

	// some maths to make bigger tabulation

	int numTabs = 6-(((paramSize+macro.size())/4)%6);

	for (int i=0; i<numTabs; i++)

		aLag << "\t";

	if (iTable.iType == TLayoutTable::EWindowTable)

		aLag << KTypeWindowLineLayout;

	else

		aLag << KTypeTextLineLayout;

	writer->WriteParamList(aLag, ctor_params);

	aLag << endl;

	delete writer;

	}

TLayoutLineCppWriter* TLayoutTableCppWriter::CreateLayoutLineCppWriter(TLayoutLine& aLine, TLayoutTable& aTable)

	{

	if (aTable.iType == TLayoutTable::EWindowTable)

		return new TWindowLineCppWriter(aLine);

	else

		return new TTextLineCppWriter(aLine);

	}

// class TLayoutCppWriter

void TLayoutCppWriter::WriteCppLineData(ostream& aCpp)

	{

	for (TLayout::iterator it = iLayout.begin(); it != iLayout.end(); ++it)

		{