/*

* Copyright (c) 2002-2007 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:  Declares CUPPrinterContainer class

*

*/

#include "cupprintercontainer.h"

#include "cuplogger.h"

#include "upconsts.h"

_LIT(KUPnPPrinterCache, "printers.txt");

#define KMaxCacheFileSize 512

// Public functions

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::~CUPPrinterContainer

//

//--------------------------------------------------------------------------------------------

CUPPrinterContainer::~CUPPrinterContainer()

{

	iPrinters.ResetAndDestroy();

	iPrinters.Close();

	iFsSession.Close();

	if(iCacheBuffer)

		delete iCacheBuffer;

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::NewL

//

//--------------------------------------------------------------------------------------------

CUPPrinterContainer* CUPPrinterContainer::NewL()

{

	CUPPrinterContainer* self = new (ELeave) CUPPrinterContainer();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();	// self

	return self;

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::Printer

//

//--------------------------------------------------------------------------------------------

CUPPrinter* CUPPrinterContainer::Printer(CUpnpDevice& aDevice)

{

	TInt index = PrinterIndex(aDevice);

	if(KErrNotFound != index)

	{

		return PrinterByIndex(index);

	}

	else

		return NULL;

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::Printer

//

//--------------------------------------------------------------------------------------------

CUPPrinter* CUPPrinterContainer::Printer(TInt aId)

{

	TInt index = PrinterIndex(aId);

	if(KErrNotFound != index)

	{

		return PrinterByIndex(index);

	}

	else

		return NULL;

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::ToTPrinter

//

//--------------------------------------------------------------------------------------------

TPrinter CUPPrinterContainer::ToTPrinter(CUpnpDevice& aDevice)

{

	TInt index = PrinterIndex(aDevice);

	return ToTPrinter(index);

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::ToTPrinter

//

//--------------------------------------------------------------------------------------------

TPrinter CUPPrinterContainer::ToTPrinter(TInt aIndex)

{

	if (aIndex >= iPrinters.Count() )

	{

		TPrinter nullPrinter;

		nullPrinter.iPrinterID = KErrNotFound;

		nullPrinter.iProtocol = 0;

		nullPrinter.iProperties = TPrinter::Cached;

		return nullPrinter;

	}

	return iPrinters[aIndex]->ToTPrinter();

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::PrinterCount

//

//--------------------------------------------------------------------------------------------

TInt CUPPrinterContainer::PrinterCount()

{

	return iPrinters.Count();

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::AddPrinterL

//

//--------------------------------------------------------------------------------------------

void CUPPrinterContainer::AddPrinterL(CUpnpDevice& aDevice, TInt& aId)

{

	aId = KErrNotFound;

	// Check if the discovered printer is cached/ disappeared

	for (TInt i=0; i < iPrinters.Count(); i++)

	{

		if (iPrinters[i]->UId().Compare(aDevice.Uuid()) == 0)

		{

			// Printer already in array - update pointer

			iPrinters[i]->SetDevice(&aDevice);

			if (iPrinters[i]->IsDisappeared())

			{

				// remove disappeared flag

				iPrinters[i]->SetDisappeared(EFalse);

			}

			aId = iPrinters[i]->Id();

			User::Leave(KErrAlreadyExists);

		}

	}

	// New printer - append to list

	TInt id = GenerateId();

	CUPPrinter* newPrinter = CUPPrinter::NewL(aDevice, id);

	CleanupStack::PushL(newPrinter);

	iPrinters.AppendL(newPrinter);

	CleanupStack::Pop(newPrinter);

	aId = id;

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::RemovePrinter

//

//--------------------------------------------------------------------------------------------

TInt CUPPrinterContainer::RemovePrinter(CUpnpDevice& aDevice)

{

	TInt index = PrinterIndex(aDevice);

	if(KErrNotFound != index)

	{

		return RemovePrinter(index);

	}

	else

		return index;

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::RemovePrinter

//

//--------------------------------------------------------------------------------------------

TInt CUPPrinterContainer::RemovePrinter(TInt aIndex)

{

	if (aIndex >= iPrinters.Count() || aIndex < 0)

		return KErrArgument;

	CUPPrinter* temp = iPrinters[aIndex];

	iPrinters.Remove(aIndex);

	if (temp)

	{

		delete temp;

		temp = NULL;	

	}

	return KErrNone;

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::RemovePrinter

//

//--------------------------------------------------------------------------------------------

TInt CUPPrinterContainer::RemoveCachedDeviceL(TInt aDeviceID)

{

	TInt err = KErrNone;

	TBool cached = EFalse;

	for (TInt i=0; i < iPrinters.Count(); i++)

	{

		if (iPrinters[i]->Id() == aDeviceID)

		{

			cached = iPrinters[i]->Cached();

			iPrinters[i]->SetCached(EFalse);

			break;

		}

	}

	if(!cached)

		return KErrNone;

	ReadCacheFileL();

	TInt startPos = 0;

	TInt endPos = 0;

	FindCachedPrinterL(aDeviceID, startPos, endPos);

	LOG1("[CUPPrinterContainer::RemoveCachedDeviceL]\t startPos:\t%d", startPos);

	LOG1("[CUPPrinterContainer::RemoveCachedDeviceL]\t endPos:\t%d", endPos);

	if(0 < endPos)

	{

		//Remove printer form the buffer

		iCacheBuffer->Des().Delete(startPos, endPos-startPos);

		//Write buffer in file

		RFile cacheFile;

		CleanupClosePushL(cacheFile);

		TInt err = cacheFile.Replace( iFsSession, KUPnPPrinterCache, EFileWrite);

		if (err == KErrNone)

		{

			err = cacheFile.Write(iCacheBuffer->Des());

		}

		CleanupStack::PopAndDestroy(&cacheFile);

	}

	delete iCacheBuffer;

	iCacheBuffer = NULL;

	return err;

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::Printer

//

//--------------------------------------------------------------------------------------------

CUPPrinter* CUPPrinterContainer::PrinterByIndex(TInt aIndex)

{

	if (aIndex >= iPrinters.Count() || aIndex < 0)	

		return NULL;

	return iPrinters[aIndex];

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::PrinterIndex

//

//--------------------------------------------------------------------------------------------

TInt CUPPrinterContainer::PrinterIndex(CUpnpDevice& aDevice)

{

	TPtrC8 uuid = aDevice.Uuid();

	TInt count = iPrinters.Count();

	for (TInt i=0; i<count; i++)

	{

		TPtrC8 tempUuid = KNullDesC8();

		if(!iPrinters[i]->IsDisappeared()) 

			tempUuid.Set( (iPrinters[i])->Device()->Uuid() );

		if (uuid.Compare(tempUuid) == 0)

			return i;

	}

	return KErrNotFound;

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::PrinterIndex

//

//--------------------------------------------------------------------------------------------

TInt CUPPrinterContainer::PrinterIndex(TInt aId)

{

	TInt count = iPrinters.Count();

	for (TInt i=0; i<count; i++)

	{

		if (aId == iPrinters[i]->Id())

			return i;

	}

	return KErrNotFound;

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::PrinterDisappeared

//

//--------------------------------------------------------------------------------------------

void CUPPrinterContainer::PrinterDisappeared(CUpnpDevice& aDevice)

{

  // Check if device is found from iPrinters array. If so add to disappeared array.

  TInt index = PrinterIndex(aDevice);

  if ( index >=0 )

  {

  	iPrinters[index]->SetDisappeared(ETrue);

  }

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::SyncPrinterArray

//

//--------------------------------------------------------------------------------------------

void CUPPrinterContainer::SyncPrinterArray()

{

	for(TInt i=0; i<iPrinters.Count(); i++)

	{

		if (iPrinters[i]->IsDisappeared())

		{

			RemovePrinter(i);

			i--;

		}

	}

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::UpdateCache

//

//--------------------------------------------------------------------------------------------

void CUPPrinterContainer::UpdateCacheL()

{

	// Calculate size for buffer

	TInt bufSize = 0;

	for (TInt i=0; i < iPrinters.Count(); i++)

	{

		bufSize += 3; // Separators and line feed

		TBuf8<10> id;

		id.AppendNum(iPrinters[i]->Id());

		TBuf8<10> vendor;

		vendor.AppendNum(iPrinters[i]->Vendor());

		bufSize += id.Length();

		bufSize += iPrinters[i]->DisplayName().Length();

		bufSize += vendor.Length();

		bufSize += iPrinters[i]->UId().Length();

	}

	// Create buffer

	if(iCacheBuffer)

	{

		delete iCacheBuffer;

		iCacheBuffer = NULL;

	}

	iCacheBuffer = HBufC8::NewL(bufSize);

	// Write buffer

	for (TInt i=0; i < iPrinters.Count(); i++)

	{

		iCacheBuffer->Des().AppendNum(iPrinters[i]->Id());

		iCacheBuffer->Des().Append(KUPnPComma());

		iCacheBuffer->Des().Append(iPrinters[i]->DisplayName());

		iCacheBuffer->Des().Append(KUPnPComma());

		iCacheBuffer->Des().AppendNum(iPrinters[i]->Vendor());

		iCacheBuffer->Des().Append(KUPnPComma());

		iCacheBuffer->Des().Append(iPrinters[i]->UId());

		iCacheBuffer->Des().Append(KUPnPLineFeed8());

	}

	// Write buffer to file

	RFile cacheFile;

	TInt err = cacheFile.Replace( iFsSession, KUPnPPrinterCache, EFileWrite);

	if (err == KErrNone)

	{

		err = cacheFile.Write(iCacheBuffer->Des());

	}

	cacheFile.Close();

	User::LeaveIfError(err);

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::UpdateCache

//

//--------------------------------------------------------------------------------------------

void CUPPrinterContainer::UpdateCacheL(TInt aDeviceId)

{

	// Get correct printer

	CUPPrinter* printer = NULL;

	for (TInt i=0; i < iPrinters.Count(); i++)

	{

		if(iPrinters[i]->Id() == aDeviceId)

		{

			printer = iPrinters[i];

			break;

		}

	}

	User::LeaveIfNull(printer);

	// Calculate size for buffer

	TInt bufSize = 0;

	if(!printer->Cached())

	{

		TBuf8<10> id;

		id.AppendNum(printer->Id());

		TBuf8<10> vendor;

		vendor.AppendNum(printer->Vendor());

		vendor.Append(_L8(" "));

		bufSize += id.Length();

		bufSize += KUPnPComma().Length();

		bufSize += printer->DisplayName().Length();

		bufSize += KUPnPComma().Length();

		bufSize += vendor.Length();

		bufSize += KUPnPComma().Length();

		bufSize += printer->UId().Length();

		bufSize += KUPnPLineFeed().Length();

		// Create buffer

		HBufC8* fileBuffer = HBufC8::NewL(bufSize);

		CleanupStack::PushL(fileBuffer);

		fileBuffer->Des().AppendNum(printer->Id());

		fileBuffer->Des().Append(KUPnPComma());

		fileBuffer->Des().Append(printer->DisplayName());

		fileBuffer->Des().Append(KUPnPComma());

		fileBuffer->Des().Append(vendor);

		fileBuffer->Des().Append(KUPnPComma());

		fileBuffer->Des().Append(printer->UId());

		fileBuffer->Des().Append(KUPnPLineFeed());

		RFile cacheFile;

		CleanupClosePushL(cacheFile);

		TInt fSize = 0;

		// Find end of file to write if exists

		TInt err = cacheFile.Open( iFsSession, KUPnPPrinterCache, EFileWrite);

		if (err == KErrNone)

		{

	    	cacheFile.Size(fSize);

	    	++fSize;

		}

		else

		{

			// Write buffer to file

			User::LeaveIfError(cacheFile.Replace( iFsSession, KUPnPPrinterCache, EFileWrite));

		}		

		User::LeaveIfError(cacheFile.Write(fSize, fileBuffer->Des()));

		printer->SetCached(ETrue);

		CleanupStack::PopAndDestroy(2); // fileBuffer, cacheFile

	}

}

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::GetDisappearedPrinters

//

//--------------------------------------------------------------------------------------------

void CUPPrinterContainer::GetDisappearedPrinters(RPointerArray<CUPPrinter>& aArray)

{

	for (TInt i=0; i < iPrinters.Count(); i++)

	{

		if (iPrinters[i]->IsDisappeared())

		{

			aArray.Append(iPrinters[i]);

		}

	}

}

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

// Protected functions

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

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::ConstructL

//

//--------------------------------------------------------------------------------------------

void CUPPrinterContainer::ConstructL()

{

	iCacheBuffer = NULL;

	// Init file server session

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

	TInt err = iFsSession.MkDirAll( KUPnPDataPath );

	if (err != KErrNone && err != KErrAlreadyExists)

	{

	  User::Leave(err);

	}

	User::LeaveIfError(iFsSession.SetSessionPath( KUPnPDataPath ));

}

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

// Private functions

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

//--------------------------------------------------------------------------------------------

//

// CUPPrinterContainer::CUPPrinterContainer

//

//--------------------------------------------------------------------------------------------

CUPPrinterContainer::CUPPrinterContainer()

{

	iIdCounter = 0;

}