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

#include "sysconfigimpl.h"
#include <hal.h>
#include <hal_data.h>

using namespace BSUL;

namespace Ulogger
{

//////////////////////////////////////////////////////////////////////////////
CConfigSettingsImpl* CConfigSettingsImpl::NewL()
	{
	CConfigSettingsImpl* self=new (ELeave) CConfigSettingsImpl();
	return self;
	}

TBool CConfigSettingsImpl::Next(TPtrC8& aSetting,TPtrC8& aSettingValue)
	{
	if (!iIniSecIter)
		{
		return EFalse;
		}
	return iIniSecIter->Next(aSetting,aSettingValue);	
	}
	
void CConfigSettingsImpl::Reset()
	{	
	if (iIniSecIter)
		{
		iIniSecIter->Reset();
		}
	}

CConfigSettingsImpl::~CConfigSettingsImpl()
	{
	if (iIniSecIter)
		{
		delete iIniSecIter;
		iIniSecIter=NULL;			
		}
	}

CConfigSettingsImpl::CConfigSettingsImpl():iIniSecIter(NULL)
	{
	}	

///////////////////////////////////////////////////////////////////////////////


CConfigImpl* CConfigImpl::NewL(RHeap* aHeap,TFileName& aFileName)
	{
	CConfigImpl* self=new (ELeave)CConfigImpl(aHeap,aFileName);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

void CConfigImpl::ConstructL()
	{
	// Create/open a handle onto global mutex used to protect
	// access to the config file.
	TInt ret = KErrAlreadyExists;
	for ( ; ret==KErrAlreadyExists; )
		{
		ret = iWriteMutex.OpenGlobal(KSysConfigMutex, EOwnerProcess);
		if (ret == KErrNotFound)
			ret = iWriteMutex.CreateGlobal(KSysConfigMutex, EOwnerProcess);
		}
	User::LeaveIfError(ret);

	//establishing connection to file server
	User::LeaveIfError(iFs.Connect());
	// allow this connection to be shared with other threads
	// - this facilitates sharing of config objects between threads
	User::LeaveIfError(iFs.ShareProtected());

	// load config
//	iIniFileWatcher = NULL;
	LoadConfigFileL();
	}

CConfigImpl::~CConfigImpl()
	{
	if (iIniFileDocument)
		{
		delete iIniFileDocument;
		iIniFileDocument=NULL;
		}	
	//closing the mutex
	if (iWriteMutex.Handle() && iWriteMutex.IsHeld())
		{
		iWriteMutex.Signal();
		}
	iWriteMutex.Close();
	//closing the file handle
	iFs.Close();	
	}




/**
Load the Ulogger config file contents.
The existing iIniFileDocument and caches are cleared.
This method assumes that iFs is connected. 
*/
void CConfigImpl::LoadConfigFileL()
	{
	//switch to private heap
	RHeap* threadHeap = NULL;
	if (iHeap)
		threadHeap = User::SwitchHeap(iHeap);		
	
	// delete existing document
	if (iIniFileDocument)
		{
		delete iIniFileDocument;
		iIniFileDocument=NULL;
	
		}
	
	TEntry dummy;
	TInt ret=iFs.Entry(iFileName,dummy);

	// grab the mutex
	iWriteMutex.Wait();
		
	//Creating an instance of IniDocument from default
	iIniFileDocument=CIniDocument8::NewL(iFs,iFileName);
	
	// release the mutex
	iWriteMutex.Signal();
	//switch back to user heap
	if (threadHeap)
		User::SwitchHeap(threadHeap);
	}


TInt CConfigImpl::PersistIniFile()
	{
	// grab the mutex
	iWriteMutex.Wait();
	
	TInt ret=iIniFileDocument->Externalise(iFileName);	
	
	// release the mutex
	iWriteMutex.Signal();
	return ret;
	}	


TInt CConfigImpl::GetKeyValue(const TDesC8& aSectionName,const TDesC8& aKeyName ,TPtrC8& aValue)
	{
	return iIniFileDocument->GetKeyValue(aSectionName,aKeyName,aValue);
	}
	
TInt CConfigImpl::RemoveKey(const TDesC8& aSectionName,const TDesC8& aKeyName)
	{
	return iIniFileDocument->RemoveKey(aSectionName,aKeyName);
	}

TInt CConfigImpl::SetKeyValue(const TDesC8& aSectionName,const TDesC8& aKey, const TDesC8& aValue)
	{
	return iIniFileDocument->SetKey(aSectionName,aKey,aValue);
	}

/*TInt CConfigImpl::AddSection(const TDesC8& aSectionName)
	{
	return iIniFileDocument->AddSection(aSectionName);
	}*/

TInt CConfigImpl::RemoveSection(const TDesC8& aSectionName)
	{
	return iIniFileDocument->RemoveSection(aSectionName);
	}

TInt CConfigImpl::GetSection(const TDesC8& aSectionName,CConfigSettingsIter& aSection)
	{
	//clear any previous internal iIniSecIterator
	if (aSection.iImpl->iIniSecIter)
		{
		delete (aSection.iImpl->iIniSecIter);
		aSection.iImpl->iIniSecIter=NULL;
		}
	//initializing its internal iIniSecIterator
	TRAPD(ret,aSection.iImpl->iIniSecIter=CIniSecIter8::NewL(aSectionName,iIniFileDocument));
	return ret;	
	}


	
//util to check any key within that section holds that value
//if not found simply return the number of keys within that section
TInt CConfigImpl::CheckValueExist(const TDesC8& aSectionName,const TDesC8& aValue,TInt& aKeyCount)
	{
	CIniSecIter8* iter=NULL;
	TRAPD(err,iter=CIniSecIter8::NewL(aSectionName,iIniFileDocument));
	//if section not found it might be the first time we are creating
	//the document so it is fine to return KErrNone
	if (err==KErrNotFound)
		{
		return KErrNone;
		}
	//return the error code if else than KErrNotFound e.g. KErrNoMemory;
	if (err!=KErrNone)
		{
		return err;
		}
	TPtrC8 key;
	TPtrC8 value;
	TInt keyCount=0;
	while (iter->Next(key,value))
		{
		if (value.Compare(aValue)==0)
			{
			delete iter;
			keyCount=0;
			return KErrAlreadyExists;
			}
		keyCount++;	 	
		}
	aKeyCount=keyCount;
	delete iter;	
	return KErrNone;	
	}

	
TInt CConfigImpl::GenerateInternalKey(const TDesC8& aSection,TBuf8<15>& aKeyName)
	{
	TPtrC8 lastKey;
	TInt ret=GetKeyCount(aSection,lastKey);
	if (ret<0)
		{
		return ret;		
		}
	//either "mediaX" or "X"
	//TInt key=ret;

	if(aSection.Compare(KPrimaryFilterSection)== 0 ) 
	{
		TInt lastKeyValue=0;
		if(lastKey.Length())
			{
			TLex8 lex(lastKey);
			TInt err = lex.Val(lastKeyValue);
			if(err != KErrNone)
				return err;
			}
		aKeyName.Format(_L8("%03d"),++lastKeyValue);
	}
	else if(aSection.Compare(KSecondaryFilterSection) == 0)
	{
		TInt lastKeyValue=0;
		if(lastKey.Length())
			{
			TLex8 lex(lastKey);
			TInt err = lex.Val(lastKeyValue);
			if(err != KErrNone)
				return err;
			}
		aKeyName.Format(_L8("%04d"),++lastKeyValue);
	}
	else
	{
		TInt lastKeyValue=0;
		if(lastKey.Length())
			{
			TLex8 lex(lastKey);
			TInt err = lex.Val(lastKeyValue);
			if(err != KErrNone)
				return err;
			}
		aKeyName.Format(_L8("%d"),++lastKeyValue);
	}	
	return KErrNone;	
}

/*TInt CConfigImpl::GenerateInternalSessionName(const TDesC8& aSection,TBuf8<15>& aKeyName)
	{
	TPtrC8 lastKey;
	TInt ret=GetKeyCount(aSection,lastKey);
	if (ret<0)
		{
		return ret;		
		}
	//either "mediaX" or "X"
	TInt index=(aSection.Compare(KActiveSection)==0?5:0);
	TInt key=0;
	if (lastKey.Length()!=0)
		{
		TLex8 lex;		
		lex.Assign(lastKey.Mid(index));
		lex.Val(key);
		}
	aKeyName.Format((aSection.Compare(KActiveSection)==0?_L8("Session%d"):_L8("%d")),++key);	
	return KErrNone;	
	}*/


TInt CConfigImpl::GetKeyCount(const TDesC8& aSectionName,TPtrC8& aLastKey)
	{
	CIniSecIter8* iter=NULL;
	TRAPD(err,iter=CIniSecIter8::NewL(aSectionName,iIniFileDocument));
	//if section not found it indicates the keycount is 0;
	if (err==KErrNotFound)
		{
		return 0;			
		}
	//return any error code e.g KErrNoMemory here;
	if (err!=KErrNone)
		{
		return err;		
		}
	TPtrC8 key;
	TInt keyCount=0x0000;
	while (iter->Next(aLastKey,key))
		{	
		keyCount++;
		}
	delete iter;
	return keyCount;
	}
	
TInt CConfigImpl::GetPointerToKeyName(const TDesC8& aSectionName,const TDesC8& aKeyName,TPtrC8& aKeyPointer)
	{
	CIniSecIter8* iter=NULL;
	TRAPD(err,iter=CIniSecIter8::NewL(aSectionName,iIniFileDocument));
	if (err!=KErrNone)
		{
		return err;		
		}
	TPtrC8 value;
	while (iter->Next(aKeyPointer,value))
		{
		if (aKeyName.Compare(aKeyPointer)==0)
			{
			delete iter;
			return KErrNone;
			}
		}
	delete iter;	
	return KErrNotFound;
	}	
}