/*
* 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 "lay2MLInst.h"
#include "LayoutParse.h"
#include "LayoutCompilerErr.h"

#include <fstream>
#include <iostream>
#include <algorithm>
#include "MLInstWriter.h"
//#include "MLInstParse.h"

string TextOutputOrder(int aIndex, bool aMirrored);
string WindowOutputOrder(int aIndex, bool aMirrored);

using namespace std;

class LayoutToMLInstArgsErr : public LayoutCompilerErr
	{
	void Show(ostream& aStream) const;
	};

void LayoutToMLInstArgsErr::Show(ostream& stream) const
	{
	LayoutToMLInst::ShowHelp(stream);
	}

string LayoutToMLInst::InterfaceName(const string& aFileName)
	{
	return aFileName.substr(0,aFileName.find_last_of('.'));
	}

int LayoutToMLInst::Process(const vector<string>& args)
	{
	if (args.size() != 4)
		throw LayoutToMLInstArgsErr();

	// first read in the lay file
	string layoutName = args[2];
	auto_ptr<TLayParseLayout> layoutParse(TLayParseLayout::Parse(layoutName));

	// then convert it to internal structure format
	auto_ptr<TMLInst> mlInst(LayoutToInst(*layoutParse));

	// finally write out the structure XML
	string xmlName = args[3];
	cout << "writing XML file " << xmlName << endl;
	TMLInstWriter writer(*mlInst, xmlName);
	writer.Write(layoutName);
	return 0;
	}

void LayoutToMLInst::ShowHelp(ostream& stream)
	{
	stream << "Lay2MLInst <layoutName> <instXmlName>" << endl;
	}

auto_ptr<TMLInst> LayoutToMLInst::LayoutToInst(const TLayout& aLayout)
	{
	auto_ptr<TMLInst> mlInst(new TMLInst);

	for (TLayout::const_iterator pTab = aLayout.begin(); pTab != aLayout.end(); ++pTab)
		{
		AddTableToInst(*mlInst, **pTab);
		}
	
	return mlInst;
	}

void LayoutToMLInst::AddTableToInst(TMLInst& aInst, TLayoutTable& aTable)
	{
	TMLInstTable* instTable = new TMLInstTable(&aInst, aTable);

	for (TLayoutTable::iterator pLine = aTable.begin(); pLine != aTable.end(); ++pLine)
		{
		if (aTable.iType == TLayoutTable::EWindowTable)
			AddWindowLineToInstTable(*instTable, **pLine);
		else
			AddTextLineToInstTable(*instTable, **pLine);
		}

/*
	int tableNum = 0;
	for (TLayoutTable::TLayoutSubTables::const_iterator pSub = aTable.iSubTables.begin(); pSub != aTable.iSubTables.end(); ++pSub)
		{
		AddTableLimitsToInterface(aInterface, aTable, **pSub, tableNum);
		if (aTable.iType == TLayoutTable::EWindowTable)
			AddSubTableToInterface("TAknWindowLineLayout", aInterface, aTable, **pSub, tableNum);
		else
			AddSubTableToInterface("TAknTextLineLayout", aInterface, aTable, **pSub, tableNum);
		tableNum++;
		}
*/
	aInst.push_back(instTable);
	}

void LayoutToMLInst::AddWindowLineToInstTable(TMLInstTable& aInstTable, TLayoutLine& aLine)
	{
	TMLInstLine* instLine = new TMLInstLine(&aInstTable, aLine);
/*
	CCdlTkApi* api = CreateGenericApi(aInterface, aLine);
	api->SetName(LineApiName(aLine));
	api->SetReturnType("TAknWindowLineLayout");
	aInterface.ApiList().push_back(api);
*/


	// add a value for each top level cell
	for (int i=0; i<7; i++)
		{
		string cellName = WindowOutputOrder(i, false);
//		WriteCell(line, cellName, aLine[cellName]);
		AddParamToLine(*instLine, aLine[cellName]);
		}

/*
	for(TLayoutLine::iterator pValue = aLine.begin(); pValue != aLine.end(); ++pValue)
		{
		AddParamToLine(instLine, *pValue);
		}
*/
	aInstTable.push_back(instLine);
	}

void LayoutToMLInst::AddTextLineToInstTable(TMLInstTable& aInstTable, TLayoutLine& aLine)
	{
	TMLInstLine* instLine = new TMLInstLine(&aInstTable, aLine);

/*
	CCdlTkApi* api = CreateGenericApi(aInterface, aLine);

	api->SetName(LineApiName(aLine));
	api->SetReturnType("TAknTextLineLayout");

	aInterface.ApiList().push_back(api);
*/

	for (int i=0; i<6; i++)
		{
		string cellName = TextOutputOrder(i, false);
//		WriteCell(line, cellName, aLine[cellName]);
		AddParamToLine(*instLine, aLine[cellName]);
		}

/*
	for(TLayoutLine::iterator pValue = aLine.begin(); pValue != aLine.end(); ++pValue)
		{
		AddParamToLine(instLine, *pValue);
		}
*/
	aInstTable.push_back(instLine);


/*
	TValues& v = aLine["B"];
	if (v.size()>1)
		{
		CCdlTkFunctionApi* multiline = static_cast<CCdlTkFunctionApi*>(CreateGenericApi(aInterface, aLine));
		CCdlTkApiParams& params = multiline->Params();
		CCdlTkApiParams::iterator pParam = params.FindByName("aIndex_B");
		if (pParam != params.end())
			params.erase(pParam);
		params.push_back(CCdlTkApiParam("TInt", "aNumberOfLinesShown"));

		multiline->SetName(string("Multiline_") + LineApiName(aLine));
		multiline->SetReturnType("TAknMultiLineTextLayout");

		aInterface.ApiList().push_back(multiline);
		}
*/
	}

/*
string LayoutToMLInst::TableApiName(TLayoutTable& aTable, TLayoutTable::TLayoutSubTable& aSubTable, int aSubTableNum)
	{
	if (aTable.size() == aSubTable.size())
		return CdlTkUtil::ToCpp(aTable.Name());
	else
		return CdlTkUtil::ToCpp(aTable.Name()) + "_SUB_TABLE_" + IntToString(aSubTableNum);
	}

string LayoutToMLInst::LineApiName(TLayoutLine& aLine)
	{
	if (aLine.iTable->iType == TLayoutTable::EWindowTable)
		{
		TWindowLineCppWriter writer(aLine);
		return writer.Name();
		}
	else
		{
		TTextLineCppWriter writer(aLine);
		return writer.Name();
		}
	}

void LayoutToMLInst::AddSubTableToInterface(const string& aType, CCdlTkInterface& aInterface, TLayoutTable& aTable, TLayoutTable::TLayoutSubTable& aSubTable, int aSubTableNum)
	{
	TLayoutLine& line = *aTable[aSubTable[0]];
	CCdlTkFunctionApi* api = new CCdlTkFunctionApi(aInterface);
	api->Params().push_back(CCdlTkApiParam("TInt", "aLineIndex"));
	AddParamsToFunc(line, *api);

	api->SetReturnType(aType);

	api->SetName(TableApiName(aTable, aSubTable, aSubTableNum));

	aInterface.ApiList().push_back(api);
	}

void LayoutToMLInst::AddTableLimitsToInterface(CCdlTkInterface& aInterface, TLayoutTable& aTable, TLayoutTable::TLayoutSubTable& aSubTable, int aSubTableNum)
	{
	CCdlTkFunctionApi* api = new CCdlTkFunctionApi(aInterface);
	api->SetReturnType("TAknLayoutTableLimits");
	api->SetName(TableApiName(aTable, aSubTable, aSubTableNum)+"_Limits");
	aInterface.ApiList().push_back(api);
	}

CCdlTkApi* LayoutToMLInst::CreateGenericApi(CCdlTkInterface& aInterface, TLayoutLine& aLine)
	{
	CCdlTkFunctionApi* func = new CCdlTkFunctionApi(aInterface);
	AddParamsToFunc(aLine, *func);
	return func;
	}

void LayoutToMLInst::AddParamsToFunc(TLayoutLine& aLine, CCdlTkFunctionApi& aFunc)
	{
	CCdlTkApiParams& params = aFunc.Params();

	if (aLine.iNeedsP)
		params.push_back(CCdlTkApiParam("const TRect&", "aParentRect"));

	if (aLine.iNeedsIndex)
		{
		const string* KParams;
		int count;
		if (aLine.iTable->iType == TLayoutTable::EWindowTable)
			{
			KParams = KWindowOutputOrder;
			count = KWindowOutputOrderSize;
			}
		else
			{
			KParams = KTextOutputOrder;
			count = KTextOutputOrderSize;
			}

		for (int i=0; i<count; i++)
			{
			const string& name = KParams[i];

			const TValues& defValues = aLine[name];
			if (defValues.iNeedsIndex)
				{
				CCdlTkApiParam param("TInt", CdlTkUtil::ToCpp(defValues.ParamName()));
				if (params.FindByName(param.Name()) == params.end())
					params.push_back(param);
				}
			}
		}
	}

*/

void LayoutToMLInst::AddParamToLine(TMLInstLine& aInstLine, TValues& aValue)
	{
//	CCdlTkApiParams& params = aFunc.Params();

	TMLInstParam* instLine = new TMLInstParam(&aInstLine, aValue);

	for(TValues::iterator pInt = aValue.begin(); pInt != aValue.end(); ++pInt)
		{
		instLine->iValues.push_back(*pInt);
		}

/*
	if (aLine.iNeedsP)
		params.push_back(CCdlTkApiParam("const TRect&", "aParentRect"));

	if (aLine.iNeedsIndex)
		{
		const string* KParams;
		int count;
		if (aLine.iTable->iType == TLayoutTable::EWindowTable)
			{
			KParams = KWindowOutputOrder;
			count = KWindowOutputOrderSize;
			}
		else
			{
			KParams = KTextOutputOrder;
			count = KTextOutputOrderSize;
			}

		for (int i=0; i<count; i++)
			{
			const string& name = KParams[i];

			const TValues& defValues = aLine[name];
			if (defValues.iNeedsIndex)
				{
				CCdlTkApiParam param("TInt", CdlTkUtil::ToCpp(defValues.ParamName()));
				if (params.FindByName(param.Name()) == params.end())
					params.push_back(param);
				}
			}
		}
*/

	aInstLine.push_back(instLine);
	}