/*
* Copyright (c) 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 "CCdlEngine.h"
#include <CdlEngDef.h>
#include "CdlRefs.h"
#include "CdlServEng.h"



//
// CCdlEngineBase
//

CCdlEngineBase* CCdlEngineBase::Static()
	{
	return static_cast<CCdlEngineBase*>(Dll::Tls());
	}

CCdlEngineBase* CCdlEngineBase::NewLC()
	{
	CCdlEngineBase* self = new(ELeave) CCdlEngineBase;
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

CCdlEngineBase* CCdlEngineBase::InstanceLC(TBool& aPushed)
	{
	aPushed = EFalse;
	CCdlEngineBase* eng = CCdlEngineBase::Static();
	if (!eng)
		{
		eng = CCdlEngineBase::NewLC();
		aPushed = ETrue;
		}
	return eng;
	}

CCdlEngineBase::~CCdlEngineBase()
	{
	delete iLibMan;
	Dll::SetTls(0);
	}

void CCdlEngineBase::IncRefCount()
	{
	iRefCount++;
	}

void CCdlEngineBase::DecRefCount()
	{
	iRefCount--;
	if (iRefCount == 0)
		delete this;
	}

CCdlEngineBase::CCdlEngineBase()
	{
	Dll::SetTls(this);
	}

void CCdlEngineBase::ConstructL()
	{
	iLibMan = new(ELeave) CCdlLibManager;
	iLibMan->ConstructL();
	}

CCdlRefCollection* CCdlEngineBase::FileContentsLC(const TDesC& aLibName)
	{
	return CCdlLibraryContentsImp::NewLC(aLibName, this);
	}

CCdlLibManager* CCdlEngineBase::LibMan() const
	{
	return iLibMan;
	}

TInt CCdlEngineBase::IsPluginInRom(const TDesC& /*aFileName*/, TBool& /*aIsInRom*/) const
	{
	return KErrNotSupported;
	}

TInt CCdlEngineBase::PluginDrive(const TDesC& /*aFileName*/, TDriveUnit& /*aDrive*/) const
    {
	return KErrNotSupported;
    }


//
// CCdlEngine
//

CCdlEngine* CCdlEngine::Static()
	{
	return static_cast<CCdlEngine*>(Dll::Tls());
	}

CCdlEngine* CCdlEngine::NewLC()
	{
	CCdlEngine* self = new(ELeave) CCdlEngine;
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

CCdlEngine* CCdlEngine::InstanceLC(TBool& aPushed)
	{
	aPushed = EFalse;
	CCdlEngine* eng = CCdlEngine::Static();
	if (!eng)
		{
		eng = CCdlEngine::NewLC();
		aPushed = ETrue;
		}
	return eng;
	}

CCdlEngine& CCdlEngine::Instance()
	{
	CCdlEngine* eng = CCdlEngine::Static();
	__ASSERT_ALWAYS(eng, Panic(ECdlEngPanic_NoEngine));
	return *eng;
	}


CCdlEngine::~CCdlEngine()
	{
	delete iChangeMonitor;
	// Release the hash table
	CCdlCustomisations::TIter iterator(iCustomisations);
	while(iterator.NextKey())
	{
		CCdlCustomisationStack* stack = *(iterator.CurrentValue());
		delete stack;
	}
	
	iCustomisations.Close();
	iServer.Close();
	}

TAny* CCdlEngine::GetData(TUid aCdlUid, TInt aApiId) const
	{
	return LookupP(aCdlUid).GetData(aApiId);
	}

TCdlEngineFunc* CCdlEngine::GetFunction(TUid aCdlUid, TInt aApiId) const
	{
	return LookupP(aCdlUid).GetFunction(aApiId);
	}

CCdlEngine::CCdlEngine()
	{
	}

void CCdlEngine::ConstructL()
	{
	CCdlEngineBase::ConstructL();
	User::LeaveIfError(iServer.Connect());
	iChangeMonitor = new(ELeave) CCdlChangeMonitor(iServer, this);
	}

CCdlCustomisationStack* CCdlEngine::LookupOrCreateL(TUid aCdlUid)
	{
	CCdlCustomisationStack* stack = Lookup(aCdlUid);
	if (!stack)
		{
		stack = CCdlCustomisationStack::NewLC(aCdlUid, this);
		iCustomisations.InsertL(aCdlUid.iUid, stack);
		CleanupStack::Pop(stack);
		}
	return stack;
	}

void CCdlEngine::RequireCustomisationL(const SCdlInterface* aInterfaceParams)
	{
	LookupOrCreateL(aInterfaceParams->iUid)->RequireCustomisationL(aInterfaceParams);
	}

void CCdlEngine::LoadCustomisationL(const TCdlRef& aRef)
	{
	LookupOrCreateL(aRef.iUid)->LoadCustomisationL(aRef);
	}

TBool CCdlEngine::IsCustomisationStarted(const SCdlInterface* aInterfaceParams) const
	{
	CCdlCustomisationStack* stack = Lookup(aInterfaceParams->iUid);
	if (!stack)
		return EFalse;
	return stack->IsCustomisationStarted(aInterfaceParams);
	}

const CCdlInstance& CCdlEngine::CustomisationInstance(TUid aCdlUid) const
	{
	return LookupP(aCdlUid).Top();
	}

CCdlCustomisationStack* CCdlEngine::Lookup(TUid aCdlUid) const
	{
	CCdlCustomisationStack * const * stack = iCustomisations.Find(aCdlUid.iUid);
	if(stack)
		{
		// Found from the hash map
		return *stack;
		}
		
	return NULL;
	}

CCdlCustomisationStack& CCdlEngine::LookupP(TUid aCdlUid) const
	{
	CCdlCustomisationStack* stack = Lookup(aCdlUid);
	__ASSERT_ALWAYS(stack, Panic(ECdlEngPanic_CustomisationNotPresent));
	return *stack;
	}

const CCdlInstance* CCdlEngine::LastAccessedInstance(TUid aCdlUid) const
	{
	return LookupP(aCdlUid).LastAccessedInstance();
	}

const TCdlRef& CCdlEngine::LastAccessedRef(TUid aCdlUid) const
	{
	return LastAccessedInstance(aCdlUid)->Ref();
	}

void CCdlEngine::FileNameRelativeToLastAccessedInstance(TUid aCdlUid, TFileName& aFileName) const
	{
	LastAccessedInstance(aCdlUid)->FileNameRelativeToLastAccessedInstance(aFileName);
	}

TInt CCdlEngine::LastApiId() const
	{
	return iLastApiId;
	}

CCdlRefs* CCdlEngine::FindInstancesLC(TUid aCdlUid) const
	{
	return iServer.FindInstancesLC(aCdlUid);
	}

CCdlRefCollection* CCdlEngine::FileContentsLC(const TDesC& aLibName)
	{
	return iServer.FileContentsLC(aLibName);
	}

CCdlNames* CCdlEngine::FindCustomisationFilesLC() const
	{
	return iServer.FindCustomisationFilesLC();
	}

CCdlRefs* CCdlEngine::AllAvailableRefsLC() const
	{
	return iServer.AllAvailableRefsLC();
	}

TInt CCdlEngine::IsPluginInRom(const TDesC& aFileName, TBool& aIsInRom) const
	{
	return iServer.IsPluginInRom(aFileName, aIsInRom);
	}

TInt CCdlEngine::PluginDrive(const TDesC& aFileName, TDriveUnit& aDrive) const
    {
	return iServer.PluginDrive(aFileName, aDrive);
    }

TInt* CCdlEngine::LastApiRefL(TUid aCdlUid)
	{
	CCdlCustomisationStack* stack = LookupOrCreateL(aCdlUid);
	return stack->LastApiRef();
	}

void CCdlEngine::SetLocalStateL(const CCdlRefs& aState)
	{
	CCdlUids* uids = CCdlUids::NewLC();
	TRAPD(err, DoSetLocalStateL(aState, *uids));
	iObservers.HandleCustomisationChangeL(*uids);
	CleanupStack::PopAndDestroy();
	User::LeaveIfError(err);
	}

void CCdlEngine::DoSetLocalStateL(const CCdlRefs& aState, CCdlUids& aChangedUids)
	{
	CCdlUids* uids = aState.UidsLC();
	TInt uidCount = uids->Count();
	aChangedUids.ResizeL(uidCount, TUid::Uid(0));
	for (TInt ii=0; ii<uidCount; ++ii)
		{
		TUid uid = uids->At(ii);
		CCdlCustomisationStack* stack = LookupOrCreateL(uid);
		stack->ClearOverrides();
		aChangedUids[ii] = uid;
		for (CCdlRefs::TIterator pRef = aState.Begin(uid); pRef != aState.End(); ++pRef)
			{
			stack->LoadCustomisationL(*pRef);
			}
		}
	CleanupStack::PopAndDestroy(uids);
	}

void CCdlEngine::SetGlobalStateL(const CCdlRefs& aState)
	{
	HBufC8* buf = aState.ExportLC();
	iServer.SetCustL(*buf);
	CleanupStack::PopAndDestroy(buf);
	}

CCdlRefs* CCdlEngine::LocalStateLC(const CCdlUids& aCdlUids) const
	{
	CCdlRefs* state = CCdlRefs::NewLC();
	TInt count = aCdlUids.Count();
	for (TInt ii=0; ii<count; ii++)
		{
		TUid uid = aCdlUids[ii];
		AddLocalStateToRefs(uid, state);
		}
	return state;
	}

void CCdlEngine::AddLocalStateToRefs(TUid aUid, CCdlRefs* aState) const
	{
	CCdlCustomisationStack* stack = Lookup(aUid);
	if (stack)
		{
		const CCdlCustomisationStack::CStack& insts = stack->Stack();
		TInt iCount = insts.Count();
		for (TInt jj=0; jj<iCount; jj++)
			{
			aState->AppendL(insts[jj]->Ref());
			}
		}
	}

CCdlRefs* CCdlEngine::GlobalStateLC(const CCdlUids& aCdlUids) const
	{
	TInt size;
	iServer.RequestGetCustL(aCdlUids, size);
	return GlobalStateLC(size);
	}

CCdlRefs* CCdlEngine::GlobalStateLC(TInt aSize) const
	{
	const TInt KMaxRetries = 10;
	CCdlRefs* state = CCdlRefs::NewLC();
	HBufC8* buf = HBufC8::NewMaxLC(aSize);
	TInt ii;
	for (ii=0; ii<KMaxRetries; ii++)
		{
		TPtr8 ptr = buf->Des();
		TInt err = iServer.GetCust(ptr, aSize);
		if (err == KErrNone)
			{
			state->ImportL(ptr);
			CleanupStack::PopAndDestroy(buf);
			break;
			}
		else if (err == KCdlRefsSizeChanged)
			{
			CleanupStack::PopAndDestroy(buf);	// makes ptr invalid
			buf = HBufC8::NewMaxLC(aSize);
			}
		else
			{
			User::Leave(err);
			}
		}

	if (ii == KMaxRetries)
		User::Leave(KErrNotReady);

	return state;
	}

void CCdlEngine::EnableGlobalCustomisationL(const CCdlUids& aCdlUids, TBool aEnabled)
	{
	TInt count = aCdlUids.Count();
	for (TInt ii=0; ii<count; ii++)
		{
		TUid uid = aCdlUids[ii];
		CCdlCustomisationStack* stack = Lookup(uid);
		if (stack)
			{
			stack->EnableGlobalCustomisation(aEnabled);
			}
		}
	StartGlobalCustomisationL();
	}

void CCdlEngine::StartGlobalCustomisationL()
	{
	CCdlUids* add = CCdlUids::NewLC();
	
	CCdlCustomisations::TIter iterator(iCustomisations);
	while(iterator.NextKey())
		{
		CCdlCustomisationStack* stack = *(iterator.CurrentValue());
		TUid uid = stack->Uid();
		TBool isEnabled = (iGloballyCustomised.FindIndex(uid) != KErrNotFound);
		TBool reqEnabled = stack->GlobalCustomisationEnabled();
		if (isEnabled && !reqEnabled)			// enabled, but not required -> remove
			iGloballyCustomised.Remove(uid);
		if (!isEnabled && reqEnabled)			// not enabled, but required -> add
			add->AppendL(uid);
		// other combinations of enabled & required need no action.
		}

	if (add->Count())
		{
		CCdlRefs* state = GlobalStateLC(*add);
		SetLocalStateL(*state);
		CleanupStack::PopAndDestroy(state);
		iGloballyCustomised.AddL(*add);
		}

	iServer.SetUidsToNotifyL(iGloballyCustomised);

	CleanupStack::PopAndDestroy(add);
	}

void CCdlEngine::HandleGlobalCustomisationChangeL(TInt aSize)
	{
	CCdlRefs* state = GlobalStateLC(aSize);
	SetLocalStateL(*state);
	CleanupStack::PopAndDestroy(state);
	}

void CCdlEngine::HandleAvailableRefsChangeL()
	{
	iObservers.HandleAvailableRefsChangeL();
	}

void CCdlEngine::AddCustomisationChangeObserverL(MCdlChangeObserver* aObserver, TUid aUid)
	{
	iObservers.AddCustomisationChangeObserverL(aObserver, aUid);
	}

void CCdlEngine::AddGeneralChangeObserverL(MCdlChangeObserver* aObserver)
	{
	iObservers.AddGeneralChangeObserverL(aObserver);
	}

void CCdlEngine::RemoveChangeObserver(MCdlChangeObserver* aObserver)
	{
	iObservers.RemoveChangeObserver(aObserver);
	}


//
// CCdlLibraryContentsImp
//

CCdlLibraryContentsImp* CCdlLibraryContentsImp::NewLC(const TDesC& aLibName, CCdlEngineBase* aEngine)
	{
	CCdlLibraryContentsImp* self = new(ELeave) CCdlLibraryContentsImp();
	CleanupStack::PushL(self);
	self->ConstructL(aEngine, aLibName);
	return self;
	}

CCdlLibraryContentsImp::~CCdlLibraryContentsImp()
	{
	iLib.Close();
	}

TInt CCdlLibraryContentsImp::CountRefs() const
	{
	return iContent.Count();
	}

TCdlRef CCdlLibraryContentsImp::Ref(TInt aIndex) const
	{
	const SCdlCustomisation& cust = iContent[aIndex];
	TCdlRef ref = 
		{
		cust.iId, 
		{ cust.iInterface->iUid.iUid }, 
		iLib.Lib()->FullName()
		};
	return ref;
	}

void CCdlLibraryContentsImp::ConstructL(CCdlEngineBase* aEngine, const TDesC& aLibName)
	{
	CCdlLibManager* libMan = aEngine->LibMan();
    RCdlLibrary* lib = libMan->FindLib(aLibName);
	iLib = libMan->LoadL(aLibName, lib, EFalse);
	iContent = iLib.Lib()->ContentsL();
	}