/*

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

*

*/

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

#pragma warning (disable:4786)

#include "LayCdl2Inst.h"

#include "LayoutCompilerErr.h"

#include "LayoutParse.h"

#include "CppWriter.h"

#include "Lay2Cdl.h"

#include <fstream>

#include <algorithm>

#include <iostream>

#include "CodeGenConsts.h"

using namespace std;

using namespace CdlCompilerToolkit;

typedef LayoutProcessArgsErr<LayoutAndCdlToCdlInstance> LayoutAndCdlToCdlInstanceArgsErr;

class LayoutAndCdlToCdlInstanceChecker : public MCdlTkApiCheckObserver

	{

private:

	void StartCheck();

	void CheckComplete();

	void ApiInBoth(const CCdlTkApi& aApi);

	void ApiNotInLeft(const CCdlTkApi& aApi);

	void ApiNotInRight(const CCdlTkApi& aApi);

private:

	int iNotInLeft;

	int iNotInRight;

	};

void LayoutAndCdlToCdlInstanceChecker::StartCheck()

	{

	iNotInLeft = 0;

	iNotInRight = 0;

	}

void LayoutAndCdlToCdlInstanceChecker::CheckComplete()

	{

	if (iNotInLeft)

		cout << "Layout is partial implementation of interface" << endl;

	if (iNotInRight)

		throw CdlTkAssert("Layout interface check failed");

	}

void LayoutAndCdlToCdlInstanceChecker::ApiInBoth(const CCdlTkApi& /*aApi*/)

	{

	}

void LayoutAndCdlToCdlInstanceChecker::ApiNotInLeft(const CCdlTkApi& /*aApi*/)

	{

	iNotInLeft++;

	}

void LayoutAndCdlToCdlInstanceChecker::ApiNotInRight(const CCdlTkApi& aApi)

	{

	iNotInRight++;

	cerr << aApi.Name() << " not in interface" << endl;

	}

int LayoutAndCdlToCdlInstance::Process(const vector<string>& args)

	{

	if (args.size() < 5 || args.size()%2 == 0)

		throw LayoutAndCdlToCdlInstanceArgsErr();

	string cdlName = args[2];

	CCdlTkCdlFileParser parser(cdlName);

	auto_ptr<CCdlTkInterface> iface(parser.LoadAndParse(true));

	LayoutAndCdlToCdlInstance process(*iface);

	TLayout* base = NULL;

	for (unsigned int arg = 3; arg < args.size(); arg += 2)

		{

		string layoutName = args[arg];

		string instName = args[arg+1];

		auto_ptr<TLayParseLayout> layoutParse = TLayParseLayout::Parse(layoutName);

		auto_ptr<TLayout> layout(layoutParse.get());

		layoutParse.release();

		if (base)

			{

			auto_ptr<TLayout> newLayout(new TLayout(*base));

			newLayout->Merge(TLayout::KMergeModeVariant, *layout);

			layout = newLayout;

			}

		else

			{

			base = layout.get();

			}

		process.AddLayout(layout, instName);

		}

	process.WriteInstances();

	return 0;

	}

void LayoutAndCdlToCdlInstance::ShowHelp(ostream& stream)

	{

	stream << "LayCdl2Inst <cdlName> (<layoutName> <instanceName>)+ " << endl;

	stream << "  Creates CDL instances containing the layout data." << endl;

	stream << "  All layout instances must conform to the CDL interface." << endl;

	stream << "  If more than one layout is supplied, subsequent ones are treated as" << endl;

	stream << "  variants of the first." << endl;

	}

void LayoutAndCdlToCdlInstance::CheckLayoutAgainstInterface(const TLayout& aLayout, const CCdlTkInterface& aIface)

	{

	auto_ptr<CCdlTkInterface> layIface = LayoutToCdl::LayoutToInterface(aLayout);

	LayoutAndCdlToCdlInstanceChecker checker;

	CCdlTkApiChecker check(*layIface, aIface, checker);

	check.Process();

	}

LayoutAndCdlToCdlInstance::LayoutAndCdlToCdlInstance(CCdlTkInterface& aInterface)

: iInterface(aInterface)

	{

	}

LayoutAndCdlToCdlInstance::~LayoutAndCdlToCdlInstance()

	{

	for (CLayouts::iterator pLayout = iLayouts.begin(); pLayout != iLayouts.end(); ++pLayout)

		delete *pLayout;

	}

void LayoutAndCdlToCdlInstance::AddLayout(auto_ptr<TLayout>& aLayout, const string& aInstName)

	{

	CLayoutToInst* base = NULL;

	if (iLayouts.size())

		base = iLayouts[0];

	auto_ptr<CLayoutToInst> p(new CLayoutToInst(base, iInterface, aLayout, aInstName));

	iLayouts.push_back(p.get());

	p.release();

	}

void LayoutAndCdlToCdlInstance::WriteInstances()

	{

	CLayouts::iterator pLayout = iLayouts.begin();

	CLayouts::iterator end = iLayouts.end();

	if (pLayout!=end)

		(*pLayout)->Process();

	for (; pLayout != end; ++pLayout)

		{

		CCdlTkWriteInstance writer((*pLayout)->Instance());

		writer.Process();

		}

	}

CLayoutToInst::CLayoutToInst(CLayoutToInst* aBase, CCdlTkInterface& aInterface, auto_ptr<TLayout>& aLayout, const string& aInstName)

: iBase(aBase), iInterface(aInterface), iLayout(*aLayout), iInstName(aInstName)

	{

	iLayoutPtr = aLayout.get();

	aLayout.release();

	iInstance = new CCdlTkInstance(iInterface);

	iInstance->SetName(aInstName);

	string extraCpp("#include <aknlayout2datadef.h>\n");

	extraCpp += string("#include \"") + CdlTkUtil::ToLower(aBase ? aBase->FwdDeclName() : FwdDeclName()) + "\"\n";

	iInstance->SetExtraCpp(extraCpp);

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

		{

		AddTableToInstance(**pTab);

		}

	}

CLayoutToInst::~CLayoutToInst()

	{

	delete iInstance;

	delete iLayoutPtr;

	}

string CLayoutToInst::FwdDeclName()

	{

	if (iBase)

		return iBase->FwdDeclName();

	else

		return iInstName + ".FwdDecl.h";

	}

void CLayoutToInst::Process()

	{

	string fileName(FwdDeclName());

	string interfaceNsName = iInterface.NamespaceName();

	ofstream stream;

	CCdlTkFileCleanup tempFile;

	CdlTkUtil::OpenTempOutput(stream, tempFile);

	WriteHeaderGuardStart(fileName, stream);

	stream << "namespace " << CdlTkUtil::ToCpp(iInstance->Name()) << endl;

	stream << "{" << endl;

	CCdlTkApiList& apiList = iInterface.ApiList();

	for (CCdlTkApiList::iterator pApi = apiList.begin(); pApi != apiList.end(); ++pApi)

		{

		if ((*pApi)->IsFunc())

			{

			stream << "extern " << interfaceNsName << "::" << (*pApi)->AsFunc().ApiNameAsTypeName() << " " << (*pApi)->Name() << ";" << endl;

			}

		else

			{

			string typeExt = "Imp";

			if ((*pApi)->ReturnType() == KTypeLayoutTableLimits)

				typeExt = "";

			stream << "extern " << (*pApi)->ReturnType() << typeExt << " const " << (*pApi)->Name() << ";" << endl;

			}

		}

	stream << "}" << endl << endl;

	WriteHeaderGuardEnd(fileName, stream);

	stream.close();

	CdlTkUtil::ExportFile(tempFile, CdlTkUtil::OutputPath() + fileName);

	}

CCdlTkInstance& CLayoutToInst::Instance()

	{

	return *iInstance;

	}

void CLayoutToInst::AddTableToInstance(TLayoutTable& aTable)

	{

	for (TLayoutTable::iterator pLine = aTable.begin(); pLine != aTable.end(); ++pLine)

		{

		TLayoutLine& line = **pLine;

		if (line.iIsMergedIdentical)

			{

			string apiName = LayoutToCdl::LineApiName(line);

			AddFwdRefToInstance(apiName, false);

			string multilineApiName = KFuncMultiline + apiName;

			if (aTable.iType == TLayoutTable::ETextTable &&

				line["B"].size() > 1 &&

				HasApi(multilineApiName))

				{

				AddFwdRefToInstance(multilineApiName, false);

				}

			}

		else

			{

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

				AddWindowLineToInstance(line);

			else

				AddTextLineToInstance(line);

			}

		}

	int tableNum = 0;

	for (TLayoutTable::TLayoutSubTables::const_iterator pSub = aTable.iSubTables.begin(); pSub != aTable.iSubTables.end(); ++pSub)

		{

		TLayoutTable::TLayoutSubTable& sub = **pSub;

		if (sub.iIsMergedIdentical)

			{

			AddFwdRefToInstance(LayoutToCdl::TableApiName(aTable, sub, tableNum)+KFuncLimitsSuffix, false);

			AddFwdRefToInstance(LayoutToCdl::TableApiName(aTable, sub, tableNum), false);

			}

		else

			{

			AddTableLimitsToInstance(aTable, sub, tableNum);

			string tableType = KTypeTextLineLayout;

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

				tableType = KTypeWindowLineLayout;

			AddSubTableToInstance(tableType, aTable, sub, tableNum);

			}

		tableNum++;

		}

	}

void CLayoutToInst::AddWindowLineToInstance(TLayoutLine& aLine)

	{

	string apiName = LayoutToCdl::LineApiName(aLine);

	if (!HasApi(apiName))

		return;

	CCdlTkImplementation& imp = FindImp(apiName);

	SetFuncLine(imp, aLine, KTypeWindowLineLayout, KWindowOutputOrder, KWindowOutputOrderSize, "", "");

	}

const string KMultiLineTextLineExtra = "\

\tline.iB = KB[0];\n\

\tline.iBaselineSkip = KB[1]-KB[0];\n\

\tline.iNumberOfLinesShown = aNumberOfLinesShown;\n";

const string KTextLineExtra = "\

\tline.iBaselineSkip = 0;\n\

\tline.iNumberOfLinesShown = 1;\n";

void CLayoutToInst::AddTextLineToInstance(TLayoutLine& aLine)

	{

	string apiName = LayoutToCdl::LineApiName(aLine);

	if (!HasApi(apiName))

		return;

	CCdlTkImplementation& imp = FindImp(apiName);

	SetFuncLine(imp, aLine, KTypeTextLineLayout, KTextOutputOrder, KTextOutputOrderSize, "", KTextLineExtra);

	if (aLine["B"].size() > 1)

		{

		string preExtra = "\tTInt " + KParamNameB + " = 0;\n";

		if (aLine["B"].ParamName() != KParamNameB)

			preExtra = "";

		string apiName = KFuncMultiline + imp.Name();

		if (HasApi(apiName))

			{

			CCdlTkImplementation& multiLineImp = FindImp(KFuncMultiline + imp.Name());

			SetFuncLine(multiLineImp, aLine, KTypeMultiLineTextLayout, KTextOutputOrder, KTextOutputOrderSize, preExtra, KMultiLineTextLineExtra);

			}

		}

	}

bool CLayoutToInst::HasApi(const string& aName)

	{

	return iInterface.ApiList().Find(aName) != 0;

	}

CCdlTkImplementation& CLayoutToInst::FindImp(const string& aName)

	{

	CCdlTkImplementation* impl = iInstance->Impl().Find(aName);

	if (!impl)

		throw NotFoundErr(aName + " in interface " + iInterface.FileName());

	return *impl;

	}

// subtable function uses the main table of pointers, with a mask to ensure that only correct lines are accessed

// which are indexed by aLineIndex

const string KSubTableImpl = "\

#TYPE #NAME#PARAMLIST\n\

\t{\n\

\tstatic #PTRTYPE const * const KSubTableImpl = (#PTRTYPE const * const)&KCdlImpl.#FIRST_MEMBER;\n\

\tASSERT(0<=" + KParamLineIndex + " && " + KParamLineIndex + "<32 && ((1<<" + KParamLineIndex + ") & #VALID_INDEX));\n\

\t#PTRTYPE KImpl = KSubTableImpl[" + KParamLineIndex + "];\n\

\treturn #EVAL;\n\

\t}";

const string KSubTableFuncEval = "(*KImpl)(#PARAMNAMES)";

const string KSubTableDataEval = "*KImpl";

void CLayoutToInst::AddSubTableToInstance(const string& aType, TLayoutTable& aTable, TLayoutTable::TLayoutSubTable& aSubTable, int aTableNum)

	{

	string apiName = LayoutToCdl::TableApiName(aTable, aSubTable, aTableNum);

	if (!HasApi(apiName))

		return;

	CCdlTkImplementation& imp = FindImp(apiName);

	const CCdlTkFunctionApi& api = imp.Api().AsFunc();

	//const CCdlTkApiParams& params = api.Params();

	TLayoutLine& line = *aTable[aSubTable[0]];

	CCdlTkImplementation& lineImp = FindImp(LayoutToCdl::LineApiName(line));

	const CCdlTkApi& lineApi = lineImp.Api();

	string ptrType;

	if (lineApi.IsFunc())

		ptrType = iInterface.NamespaceName() + "::" + lineApi.PointerType();

	else

		ptrType = lineApi.PointerType();

	int valid = 0;

	for (unsigned int ii=0; ii<aTable.size(); ii++)

		{

		if (find(aSubTable.begin(), aSubTable.end(), ii) != aSubTable.end())

			{

			valid |= 1<<ii;

			}

		}

	string firstMember = LayoutToCdl::LineApiName(*aTable[0]);

	CdlTkUtil::CReplaceSet implSet;

	implSet.Add("#TYPE", aType);

	implSet.Add("#NAME", imp.Name());

	implSet.Add("#PARAMLIST", api.ParamsTypeAndNameList());

	implSet.Add("#PTRTYPE", ptrType);

	implSet.Add("#FIRST_MEMBER", firstMember);

	implSet.Add("#VALID_INDEX", CdlTkUtil::IntToHexString(valid));

	implSet.Add("#EVAL", lineApi.IsFunc() ?

			CdlTkUtil::Replace("#PARAMNAMES", lineApi.AsFunc().ParamNameList(), KSubTableFuncEval) :

			KSubTableDataEval);

	string impl = CdlTkUtil::MultiReplace(implSet, KSubTableImpl);

	imp.SetTemplatePointerReference();

	imp.SetDefinition(impl);

	}

const string KTableLimitsImpl =

KTypeLayoutTableLimits + " #NAME()\n\

\t{\n\

\tconst " + KTypeLayoutTableLimits + " limits = {#FIRST, #LAST};\n\

\treturn limits;\n\

\t}";

void CLayoutToInst::AddTableLimitsToInstance(TLayoutTable& aTable, TLayoutTable::TLayoutSubTable& aSubTable, int aTableNum)

	{

	string apiName = LayoutToCdl::TableApiName(aTable, aSubTable, aTableNum)+KFuncLimitsSuffix;

	if (!HasApi(apiName))

		return;

	CCdlTkImplementation& imp = FindImp(apiName);

	int first = *aSubTable.begin();

	int last = *aSubTable.rbegin();

	CdlTkUtil::CReplaceSet implSet;

	implSet.Add("#NAME", imp.Name());

	implSet.Add("#FIRST", CdlTkUtil::IntToString(first));

	implSet.Add("#LAST", CdlTkUtil::IntToString(last));

	string impl = CdlTkUtil::MultiReplace(implSet, KTableLimitsImpl);

	imp.SetTemplatePointerReference();

	imp.SetDefinition(impl);

	}

// data implementation is a simple const static data declaration

const string KDataImpl = "const #TYPEImp #NAME = {#DATA};";

const string KDataPtr = "(#TYPE*)&#NAME";

void CLayoutToInst::SetDataLine(CCdlTkImplementation& aImp, TLayoutLine& aLine, const string& aType, const string aOutputOrder[], int aOutputOrderSize)

	{

	string data;

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

		{

		if (ii != 0)

			data += ",";

		string value = aLine[aOutputOrder[ii]][0];

		CdlTkUtil::AppendString(data, TValues::CppValue(value));

		}

	CdlTkUtil::CReplaceSet implSet;

	implSet.Add("#TYPE", aType);

	implSet.Add("#NAME", aImp.Name());

	implSet.Add("#DATA", data);

	string impl = CdlTkUtil::MultiReplace(implSet, KDataImpl);

	CdlTkUtil::CReplaceSet ptrSet;

	ptrSet.Add("#TYPE", aType);

	ptrSet.Add("#NAME", aImp.Name());

	string ptr = CdlTkUtil::MultiReplace(ptrSet, KDataPtr);

	aImp.SetPointerReference(ptr);

	aImp.SetDefinition(impl);

	}

// function implementation starts with asserts for parameter ranges and

// tables of values for the parameterised cells.

// The actual structure is initialised for the fixed values and indexed lookups

// on the tables

const string KFunctionImpl = "\

#TYPE #NAME#PARAMTYPEANDNAMELIST\n\

\t{\n\

#PRE_EXTRA\

#ASSERTS\

#TABLES\

\t#TYPEImp line = {#INIT};\n\

#LOOKUPS\

#POST_EXTRA\

#RECT_ADJUST\

\treturn line;\n\

\t}";

const string KFunctionAssert = "\tASSERT(0<=#PARAMNAME && #PARAMNAME<#PARAMLIMIT);\n";

const string KFunctionTable = "\tconst static TInt16 K#TABLENAME[#PARAMLIMIT] = {#VALUES};\n";

const string KFunctionLookup = "\tline.i#TABLENAME = K#TABLENAME[#PARAMNAME];\n";

const string KFunctionRect = "\tline.SetAllParentOffsets(" + KParamParentRect + ");\n";

void CLayoutToInst::SetFuncLine(CCdlTkImplementation& aImp, TLayoutLine& aLine, const string& aType, const string aOutputOrder[], int aOutputOrderSize, const string& aPreExtra, const string& aPostExtra)

	{

	const CCdlTkFunctionApi& api = aImp.Api().AsFunc();

	//const CCdlTkApiParams& params = api.Params();

	string asserts;

	string tables;

	string init;

	string lookups;

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

		{

		TValues& values = aLine[aOutputOrder[ii]];

		const string& paramName = values.ParamName();

		const string& paramLimit = CdlTkUtil::IntToString(values.size());

		const string& tableName = aOutputOrder[ii];

		if (ii != 0)

			init += ",";

		if (values.size() > 1)

			{

			string v;

			for (TValues::iterator pVal = values.begin(); pVal != values.end(); ++pVal)

				{

				if (pVal != values.begin())

					v += ",";

				v += TValues::CppValue(*pVal);

				}

			CdlTkUtil::CReplaceSet replaceSet;

			replaceSet.Add("#PARAMNAME", paramName);

			replaceSet.Add("#PARAMLIMIT", paramLimit); 

			replaceSet.Add("#TABLENAME", tableName); 

			replaceSet.Add("#VALUES", v);