// Copyright (c) 2003-2009 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:

//

/**

 @file ced.cpp

 @internalComponent

*/

#include <e32base.h>

#include <e32cons.h>

#include <e32std.h>

#include <f32file.h>

#include <bacline.h>

#include "dbdef.h"

#include "filedump.h"

#include "input.h"

#include "database.h"

#include "CXMLFile.h"

#include "CXMLContentHandler.h"

#include "CDBSTD.H"

#include <centralrepository.h>

/** max length of path/filename/column/table name */

#define MAX_BUFFER_LEN			256								

/** max length of path/filename/column/table name */

#define MAX_ATTRIB_LEN			32		

/** max length of arg list to program */

#define MAX_ARG_LEN				(MAX_BUFFER_LEN * 3)			

/** Application name  */

#define APPLICATIONNAME			_L("CommsDat Configuration Utility")

/** Version Info  */

#define CEDUNVERSIONED			_L("CED deliberately un-versioned") /** refer DEF092743 */

#ifdef __TOOLS2__

_LIT(CFG_TARGET, "ced.cfg");

_LIT(XML_TARGET, "ced.xml");

_LIT(LOG_TARGET, "ced.log");

_LIT(KMeshPrefaceFile, "meshpreface1.cfg");

	#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

		#ifndef SYMBIAN_COMMSDAT_USE_INT_RECORD_LINKS

			_LIT(SUPPORTED_OS, "95");

		#else

			_LIT(SUPPORTED_OS, "");

		#endif

	#else

		#ifndef SYMBIAN_COMMSDAT_USE_INT_RECORD_LINKS

			_LIT(SUPPORTED_OS, "94");

		#else

			_LIT(SUPPORTED_OS, "93");

		#endif

	#endif

#else

_LIT(CFG_TARGET, "c:\\ced.cfg");

_LIT(XML_TARGET, "c:\\ced.xml");

_LIT(LOG_TARGET, "c:\\ced.log");

_LIT(KMeshPrefaceFile, "z:\\system\\data\\meshpreface1.cfg");

_LIT(DEFAULT_SESSION_PATH, "c:\\");

#endif

// GLOBALS

/** Logging  */

CFileDump* gMsg;	

/** Database access */	

DBAccess* gDB;

/** .ini file parsing */

CfgFile gCfg;

/** XML file parsing */		

XMLFile* gXML;

/** Console accessor */		

LOCAL_D CConsoleBase* gConsole;

/** Passed in arg list */		

HBufC* gArgumentLine;

/** Flag to indicate a successful run */

TBool gProcessingSuccessful = ETrue;

/** Flag to indicate whether the '-V' arg was passed in */

TBool gValidityChecking = EFalse;

/** flag to indicate whether the execution format is .dll or .exe*/

TBool gIsExeDLL = EFalse;

/** flag to indicate whether the configuration file is in XML format */

TBool gIsXML = ETrue; 

#ifdef SYMBIAN_NETWORKING_3GPPDEFAULTQOS

TBool gDeprecatedFields = EFalse;

#endif

//SYMBIAN_NETWORKING_3GPPDEFAULTQOS

// PROTOTYPES

TInt ParseCommandLineL(TInt &aDebugOn, TBool &aOverWrite, TBool &aForceXMLProcessing, TDes &aIn, TDes &aOut, TDes &aInPref);

TInt ParseArgument(TInt &aDebugOn, TBool &aOverWrite, TBool &aForceXMLProcessing, TDes &aIn, TDes &aOut);

TInt DoProcessL(TBool aIsCfg);

void DoDeleteL();

TInt DoCfgTemplateL(TDesC &aTable, const TInt &aIndex);

TInt DoCfgInsertsL(TDesC &aTable, const TInt &aIndex);

TInt DoXMLTemplateL(const TInt &aIndex);

TInt DoXMLInsertsL(const TInt &aIndex);

TInt SetColumnDetailsL(TInt aIndex, TInt aRecordCount);

TInt SetXMLColumnDetailsL(TInt aEntryIndex, TInt aIndex, TInt aRecCount);

void DisplayMessage(TPtrC aMessage, TInt aJustTheMessage = EFalse);

void HelpDump();

void MainL();

LOCAL_C void doMainL();

TInt DoProcessL(TBool aIsCfg)

/** Store the information provided in the configuration file to CommDB

@param aIsCfg Whether the file to be parsed is an older style .cfg rather than .xml

@return TInt refer only called functions

@leave refer only called functions and dependant components

*/

	{

	TRAPD(ret, gDB->InitCommsdatL());

	// connect to DB manager

	if (ret==KErrNone)

		{

		TVersion version = gDB->Version();

		gMsg->Msg(_L("Database Version Maj %d Min %d Build %d"), version.iMajor, version.iMinor, version.iBuild);

		gMsg->Dbg(_L(""));

		gMsg->Dbg(_L("Session started"));

		// loop through tables

		TInt i = 0;

		TInt j = 0;

		TBuf<MAX_BUFFER_LEN> table = tableArray[i];

		TBuf<MAX_BUFFER_LEN> tempColumn;

		TBool changed;

		while (table.Compare(TPtrC(NO_MORE_RECORDS)) != 0)

			{

			gMsg->Msg(_L(" "));

			gMsg->Msg(_L("%S Table"), &table);

			// get a count of editable columns

			j = 0;

			tempColumn = ColumnArray[i][j];

			while(tempColumn.Compare(TPtrC(NO_MORE_RECORDS)) != 0)

				{

				j++;

				tempColumn = ColumnArray[i][j];

				}

			gMsg->Dbg(_L("(%d editable fields in table)"), j);

			TBool commitIndividualRecords = (table.CompareC(_L("ConnectionPreferences")) == 0);

			if(commitIndividualRecords)

				{

				// Commit any current changes

				TInt ret = gDB->CommitTransaction();

				if(ret != KErrNone)

					{

					gMsg->Msg(_L("ERROR: CommitTransaction returned err [%d]"), ret);

					if (gValidityChecking) 

						{

						gProcessingSuccessful = EFalse;

						}

					}

				}

			else

				{

				gDB->MaybeBeginTransactionL();

				}

			gDB->SetCommitIndividualRecords(commitIndividualRecords);

			changed = EFalse;			

			//Create a recordset for the table

			ret = KErrNone;

			if(!commitIndividualRecords)

				{

				TRAP(ret, gDB->CreateOrInsertRecordL(DBAccess::ECreateNew,elementIdArray[i], 0));			

				}

			if(ret == KErrNone)

				{

				if (aIsCfg?DoCfgTemplateL(table,i):DoXMLTemplateL(i))	

					{

					gMsg->Msg(_L(" "));

					changed = ETrue;

					}					

				if (aIsCfg?DoCfgInsertsL(table, i):DoXMLInsertsL(i))

					{

					gMsg->Msg(_L(" "));

					changed = ETrue;

					}				

				if (changed)

					{

					TInt  commitErr = gDB->CommitChanges();

					if (commitErr == KErrNone)

						{

						gMsg->Msg(_L("Insert successful"));

						}

					else

						{

						gMsg->Msg(_L("Insert failed [%d ]"), commitErr);

						if (gValidityChecking) 

							{

							gProcessingSuccessful = EFalse;

							}

						}

					}	

				else

					{

					gMsg->Dbg(_L("Nothing to process"));	

					}

				if(gDB->CommitIndividualRecords())

					{

					ret = gDB->CommitChanges();

					}

					gDB->CloseTable();				

				}

			else

				{

				gMsg->Dbg(_L("(Creating Record set Failed [%d ])"), ret);	

				}

			i++;

			table = tableArray[i];

			}

		ret = gDB->CommitTransaction();

		gDB->Close();

		}

	else

		{

		gMsg->Dbg(_L("(Could not connect to Commsdat [%d ])"), ret);

		}	

	return ret;

	}

void DoDeleteL()

/** Completely erase the communications database, not used when the append flag set

@return void

@leave refer only called functions and dependant components

*/

	{

	gMsg->Msg(_L("The old database will be replaced ") );

	// Get a session with the central repository

	const TUid KCDCommsRepositoryId = { 0xCCCCCC00 };

	CRepository*  storage = NULL;

	TRAPD(err, storage = CRepository::NewL(KCDCommsRepositoryId));

	if (KErrNone != err)

		{

		gMsg->Msg(_L("Failed to create Central Repository with ID : %x   (error %d)"), KCDCommsRepositoryId, err);

		_LIT(KCEDPanic, "CED");

		User::Panic(KCEDPanic, KErrNotFound);

		}

	CleanupStack::PushL(storage);

    // open transaction - if can't do this then fail.

    User::LeaveIfError(storage->StartTransaction(CRepository::EReadWriteTransaction));

	// Find everything in the database

	RArray<TUint32> ids;

    CleanupClosePushL(ids);

	err = storage->FindL(0, 0, ids);

	if(err != KErrNotFound)

		{

		User::LeaveIfError(err);

		}

	// delete everything in the database

	if (ids.Count())

		{

		for ( TInt i = ids.Count()-1; i >=0 ; i--)

			{

			if( i == ids.Count()-1 || i>=10000 && i%10000==0 || i<10000 && i>= 1000 && i%1000==0 ||

				i<1000 && i>=100 && i%100==0 || i<100 && i>=10 && i%10==0 || i<10)

				{

				gMsg->Msg(_L("%d"),i);

				}

			User::LeaveIfError(storage->Delete(ids[i]));

			}

		}

	TUint32 aErrorId;

	err = storage->CommitTransaction(aErrorId);

	CleanupStack::PopAndDestroy(2);

	if (err != KErrNone)

		{

		gMsg->Msg(_L("Central Repository CommitTransaction returned err [%d]"), err);

		}	

	User::LeaveIfError(err);	

	}

void MainL()

/** Central processing unit of CED

@return void

@leave refer only called functions and dependant components

*/

	{

	TInt bDebugOn = EFalse;

	TBool bOverWrite = EFalse;

	TBool bForceXMLProcessing = EFalse;

	TBuf<MAX_BUFFER_LEN> fIn;

	TBuf<MAX_BUFFER_LEN> fOut;

	TBuf<MAX_BUFFER_LEN> fInPref;

	RFs fsSession;		// file system session

	// connect to file system

	User::LeaveIfError(fsSession.Connect());

	CleanupClosePushL(fsSession);

	// check command line

	TInt valid;

	if (gIsExeDLL == EFalse)

		{

		// exe's get arguments from the command line

		valid = ParseCommandLineL(bDebugOn, bOverWrite, bForceXMLProcessing, fIn, fOut, fInPref);

		}

	else

		{

		// exedll'd get the parameters passed in 

		valid = ParseArgument(bDebugOn, bOverWrite, bForceXMLProcessing, fIn, fOut);

		}

	if (valid)

		{					

		// Get the type of the input file i.e. whether it is

		// an XML file or a CFG file

		(fIn.FindF(_L(".XML")) != KErrNotFound)?gIsXML = ETrue:gIsXML = EFalse;

		// display title

		gConsole->Printf(_L("------------------------------------------------------------\n"));

		gConsole->Printf(APPLICATIONNAME);

		gConsole->Printf(_L("\n------------------------------------------------------------\n\n"));

		gConsole->Printf(_L("CED is now processing the configuration file from [%S], \n"), &fIn);

		if ( bOverWrite )	gConsole->Printf(_L("The old database will be replaced \n") );

		if ( gIsXML )

			{

			gConsole->Printf(_L("The config file is in XML format \n") );

			if ( bForceXMLProcessing )

				{

				gConsole->Printf(_L("Invalid table entry links will be allowed \n") );

				}

			else

				{

				gConsole->Printf(_L("Invalid table entry links will not be allowed \n") );

				}

			}

		else

			{

			gConsole->Printf(_L("The config file is in CFG format \n") );

			}

		// initialise output log file

#ifndef __TOOLS2__

		// Set up the session path for WINSCW / ARMv5 incase the log file name has no path.

		fsSession.SetSessionPath( DEFAULT_SESSION_PATH );

#endif

		gMsg = CFileDump::NewL(fsSession, fOut, TPtrC(APPLICATIONNAME),

								TPtrC(CEDUNVERSIONED), bDebugOn, gConsole, EFalse);

		CleanupStack::PushL(gMsg);

		if (!gMsg->IsInitialised())

			{

			gConsole->Printf(_L("Failed to open the output log file [%S]\n"), &fOut);

			}

		gMsg->Msg(_L(" "));

		gMsg->Msg(_L("===================================================="));

		gMsg->Msg(APPLICATIONNAME);

		gMsg->Msg(_L("===================================================="));

		gMsg->Msg(_L(" "));

		gMsg->Msg(_L("Processing configuration from [%S]"), &fIn);

		gIsXML?gMsg->Msg(_L("The config file is in XML format ")):gMsg->Msg(_L("The config file is in CFG format ") );			

		if(gProcessingSuccessful)

			{

			gDB = new (ELeave) DBAccess(gIsXML);

			CleanupStack::PushL(gDB);

			gDB->CheckElementValidity(gValidityChecking);

	        //If the settings are not ovewritten we are appending

		    //This will take care of commdb ids

		    gDB->SetInAppendMode(!bOverWrite);

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

            TBool isMeshCompatible(EFalse);

            if (bOverWrite)

            //The database has to be re-built...

                {

                CInputFileParser* fileParser = CInputFileParser::FactoryLC(gIsXML, fIn, gMsg);

                TRAPD(leaveVal, isMeshCompatible = fileParser->IsMeshCompatibleL());

                CleanupStack::PopAndDestroy(fileParser);

                if (leaveVal == KErrNone)

                    {

                    if (!isMeshCompatible)

                        {

        				gMsg->Msg(_L("MESHINFO: Configuration file [%S] is not mesh-compatible, inserting default meshtables"), &fIn);

                        // Insert the new mesh related tables/records into the database.

                        // The preface is a .cfg file, whatever the type of the original input file.

                        //

    			        if (gCfg.OpenConfigFile(fInPref))

    				        {

    						if (bOverWrite)

    							{

    				            DoDeleteL();

    							}

                            /**

                              create a link resolver object which resolves all of the

                              link by tag linking (Link.TableName.Id) to link by recordId

                              (TableName.RecordId).

                              This is important because there can be circular referencing

                              between tables and if these tables contain link by tag refencing

                              to each other commsDat doesn't allow to commit those tables...

                            */

                        	//this object will resolve the linkByTag linking to simple linkByRecId format

            				LinkByTagResolver* resolver = LinkByTagResolver::NewLC(&gCfg, gMsg);

                            //set the resolver object to the gDB object

                            gDB->SetLinkByTagResolver(resolver);

                            //Set the iIsXML field to false as we are processing now a cfg file...

            				gDB->CfgXmlSetting() = EFalse;

            				//The MeshPreface file will be processed first. This is important to know since here

            				//we don't want to do any mappings...

            				gDB->SetMeshProcessing(ETrue); 

            				DoProcessL(ETrue);

            				//if originally xml processing was set then set it back now...

            				gDB->CfgXmlSetting() = gIsXML;

            				//remove the resolver object form the gDB because it's not needed anymore

            				gDB->RemoveLinkByTagResolver();

            				CleanupStack::PopAndDestroy(resolver);

            				resolver = NULL;

            				gCfg.CloseConfigFile();

            				if (!gValidityChecking)

            					{

            					gProcessingSuccessful = ETrue;

            					}

            				}

    			        else

    				        {

            				gMsg->Error(_L("MESHERR: Configuration file [%S] could not be opened"), &fInPref);

            				gProcessingSuccessful = EFalse;

            				}

            			}

            		else

            		    {

        				gMsg->Msg(_L("MESHINFO: Configuration file [%S] is mesh-compatible"), &fIn);

            		    }

            		}

                else

                    {

    				gMsg->Error(_L("MESHERR: Configuration file [%S], processing failed, reason=<%d>"), &fIn, leaveVal);

    				gProcessingSuccessful = EFalse;

    				}

                }

            else

                {

                gMsg->Msg(_L("Appending data to the DB - no need to use the meshpreface config file"));

                }

            if (gProcessingSuccessful)

                {

#endif

			// Process the XML configuration file

			if (gIsXML)

				{			    

				// Create the XML database

				CXMLDatabase* xmlDb = CXMLDatabase::NewL();

				CleanupStack::PushL(xmlDb);

				gXML = new (ELeave) XMLFile;

				CleanupStack::PushL(gXML);

				if (gXML->OpenConfigFile(fsSession,fIn,xmlDb,bForceXMLProcessing, !bOverWrite))

					{

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

                    if (isMeshCompatible)

                        {

#endif

						if (bOverWrite)

    					    {