/*

* Copyright (c) 2004-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:  

*

*/

#include <fbs.h>

#include <eikenv.h>

#include <e32std.h>

#include "tprintcapability.h"

#include "csettingsmanager.h"

#include "ctemplatesettings.h"

#include "cprintsettings.h"

#include "ctintcapability.h"

#include "clistcapability.h"

#include "cfloatcapability.h"

#include "ctemplatedata.h"

#include "printcapabilitycodes.h"

#include "settingsconverter.h"

#include "crealfactory.h"

#include "imageprint.h"

#include "cimageprint.h"

#include "imageprintvariant.h"

#include <centralrepository.h>

#include "imageprintprivatecrkeys.h"

#include "mdiscovery.h"

#include "clog.h"

namespace

    {

    const TInt KDefaultPrinterNameMaxLength = 100;

    const TInt KTemplateSize = 16;

    const TInt KTemplates[] = {1554,1552,1565,1555,1501,1553,1551,1558,1502,1504,1564,1506,1509,1512,1513,1516};

    }

#include "clog.h"

// CONSTRUCTION

CSettingsManager* CSettingsManager::NewL(

    CRealFactory* aFactory )

    {

    CSettingsManager* self = CSettingsManager::NewLC(

        aFactory );

    CleanupStack::Pop();    // self

    return self;

    }

CSettingsManager* CSettingsManager::NewLC(

    CRealFactory* aFactory )

    {

    CSettingsManager* self =

        new ( ELeave ) CSettingsManager( aFactory );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Constrcutor

CSettingsManager::CSettingsManager(

    CRealFactory* aFactory ) :

      iFactory( aFactory ),

      iActivePage( 1 )

    {

    }

// Destructor

CSettingsManager::~CSettingsManager()

    {

    delete iPrintSettings;

    delete iTemplateSettings;

    delete iCurrentPrinterName;

    delete iCRSession;

    iNumberOfCopiesArray.Close();

    iNumberOfCopiesCumulativeArray.Close();

    }

// 2nd phase constructor

void CSettingsManager::ConstructL()

    {

    iPrintSettings = new ( ELeave ) CPrintSettings;

    iTemplateSettings = CTemplateSettings::NewL( iFactory );

    iCRSession  = CRepository::NewL( KCRUidImagePrint );

    }

// Clones the current template settings

CTemplateSettings* CSettingsManager::TemplateSettingsL()

    {

    return iTemplateSettings->CloneL();

    }

// Changes active template to a new one

void CSettingsManager::SetActiveTemplateL(

    TUint aUid )

    {

    LOG1( "CSettingsManager::SetActiveTemplateL START || aUid = %d", aUid );

    // Set active template to preview manager, if one available

    iTemplateSettings->iActiveTemplateUid = aUid;

    CListCapability* capab = static_cast<CListCapability*>(

        FetchCapabilityL( EPrintCapabLayout ) );

    capab->iValue = aUid;

    LOG1( "CSettingsManager::SetActiveTemplateL || iImagesOnPage = %d", iImagesOnPage );

    }

// Returns the number of pages

TUint CSettingsManager::NumOfPagesL()

    {

    // Always 1, fix this for the release 2

    // return iFactory->Engine()->GetNumPrintPages();

    TInt num( 1 );

    return num;

    }

// Returns the number of copies

TInt CSettingsManager::NumberOfCopies( RArray<TInt>& aArray )

    {

    TInt err( KErrNone );

    aArray.Reset();

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

        {

        err = aArray.Append( iNumberOfCopiesArray[ i ] );

        if( err != KErrNone )

            {

            return err;

            }

        }

    return KErrNone;

    }

TInt CSettingsManager::NumberOfCopies( TInt& aNumberOfCopies, TInt aIndex )

    {

    if( -1 < aIndex && aIndex < iNumberOfCopiesArray.Count() )

        {

        aNumberOfCopies = iNumberOfCopiesArray[ aIndex ];

        return KErrNone;

        }

    else

        {

        return KErrArgument;

        }

    }

// Sets the number of copies

TInt CSettingsManager::SetNumberOfCopiesL( const RArray<TInt>& aArray )

    {

    TInt err( KErrNone );

    TInt numberOfCopiesCumulative( 1 );

    iNumberOfCopiesArray.Close();

    iNumberOfCopiesCumulativeArray.Close();

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

        {

        err = iNumberOfCopiesArray.Append( aArray[ i ] );

        if( err != KErrNone )

            {

            return err;

            }

        err = iNumberOfCopiesCumulativeArray.Append( numberOfCopiesCumulative );

        numberOfCopiesCumulative += aArray[ i ];

        if( err != KErrNone )

            {

            return err;

            }

        }

    return err;

    }

TInt CSettingsManager::UpdateNumberOfCopiesToServer()

    {

    return iFactory->Engine()->SetNumberOfCopies( iNumberOfCopiesArray );

    }

// Returns

TBool CSettingsManager::IsMMC()

    {

    TBool retVal = EFalse;

    TInt supportedProtocols = iFactory->DiscoveryIF()->SupportedProtocols();

	if( (supportedProtocols & KImagePrint_PrinterProtocol_DPOF)  && 

    	( iPrinterUid == iMMCUid ))

		{

		retVal = ETrue;

		}

	LOG1( "CSettingsManager::IsMMC: %d ", retVal );

    return retVal;

    }

// Changes active page for drawing a new preview

void CSettingsManager::SetActivePageL(

    TUint aActivePage )

    {

    }

// Returns current active page

TUint CSettingsManager::CurActivePageL()

    {

    TUint num( 1 );

    return num;

    }

// Clones current print settings

CPrintSettings* CSettingsManager::PrinterSettingsL()

    {

    return iPrintSettings->CloneL();

    }

// Sets all settings, not supported at the moment

void CSettingsManager::SetPrinterSettingsL(

    CPrintSettings& /*aSettings*/ )

    {

    User::Leave( KErrNotSupported );

    }

// Sets a single setting

TInt CSettingsManager::SetPrinterSettingL(

    CBaseCapability& aCapab )

    {

    LOG( "CSettingsManager::SetPrinterSettingL START" );

    TInt getSettings( 0 );

    TInt err = iFactory->Engine()->SetJobSettingL(

        aCapab.iUid, aCapab.iValue, getSettings );

    getSettings  = 0;

    User::LeaveIfError( err );

    CBaseCapability* capab = FetchCapabilityL( aCapab.iUid );

    capab->iValue = aCapab.iValue;

#ifdef IMG_PRINT_DYNAMIC_PRINT_SETTINGS

    // Do not initialize if only template was changed

    if( aCapab.iUid != 500 )

        {

        LOG( "CSettingsManager::SetPrinterSettingL || aCapab.iUid != 500" );

        InitCapabilitiesL( iPrinterUid );

        InitTemplateSettingsL();

        }

     else

        {

        LOG( "CSettingsManager::SetPrinterSettingL || aCapab.iUid == 500" );

        SetActiveTemplateL( aCapab.iValue );

        }

#else

     InitCapabilitiesL( iPrinterUid );

     InitTemplateSettingsL();

#endif

    LOG1( "CSettingsManager::SetPrinterSettingL getSettings = %d", getSettings );

    return getSettings;

    }

// Initializes the printer settings

void CSettingsManager::InitSettingsL(

    TInt aPrinterUid,

    TInt aMMCUid )

    {

    LOG1( "CSettingsManager::InitSettingsL aPrinterUid = %d", aPrinterUid );

    LOG1( "CSettingsManager::InitSettingsL aMMCUid     = %d", aMMCUid     );

    iMMCUid = aMMCUid;

    InitCapabilitiesL( aPrinterUid );

    InitTemplateSettingsL();

    iPrinterUid = aPrinterUid;

    }

// Inititalizes the capabilities

void CSettingsManager::InitCapabilitiesL(

    TInt aPrinterUid )

    {

    LOG1("CSettingsManager::InitCapabilitiesL Begin: %d", aPrinterUid);

    RArray<TInt> capabIDs;

    CleanupClosePushL( capabIDs );

    // Get list of IDs

    iFactory->Engine()->GetPrinterCapabilityIDsL( aPrinterUid, capabIDs );

    CPrintSettings* printSettings = new ( ELeave ) CPrintSettings;

    CleanupStack::PushL( printSettings );

    TInt i( 0 );

    TInt num( capabIDs.Count() );

    LOG1("CSettingsManager::InitCapabilitiesL number of capabs: %d", num);

    for ( i = 0; i < num; i++ )

        {

        TPrintCapability capab;

        iFactory->Engine()->GetPrinterCapabilityL( aPrinterUid, capabIDs[i], capab );

        capab.iType = TPrintCapability::Enum;

        CBaseCapability* capability = 0;

        // Create capability

        switch ( capab.iType )

            {

            case TPrintCapability::Int:

                capability = SettingsConverter::AddTIntCapabilityLC(

                    capab, i, capabIDs[i] );

                break;

            case TPrintCapability::Enum:

                capability = SettingsConverter::AddListCapabilityLC(

                    capab, i, capabIDs[i], iFactory );

                break;

            case TPrintCapability::Float:

                capability = SettingsConverter::AddFloatCapabilityLC(

                    capab, i, capabIDs[i] );

                break;

            default:

                User::Leave( KErrUnknown );

                break;

            }

        iFactory->Engine()->GetJobSetting( capabIDs[i], capability->iValue );

        // Add the capability to the list

        User::LeaveIfError(

            printSettings->iCapabilities.Append( capability ) );

        CleanupStack::Pop();    // capability

        }

    delete iPrintSettings;

    iPrintSettings = printSettings;

    CleanupStack::Pop();    // printSettings

    CleanupStack::PopAndDestroy();  // capabIDs

    LOG("CSettingsManager::InitCapabilitiesL End");

    }

// Initializes the templates

void CSettingsManager::InitTemplateSettingsL()

    {

    LOG("CSettingsManager::InitTemplateSettingsL Begin");

    CTemplateSettings* settings = CTemplateSettings::NewL( iFactory );

    CleanupStack::PushL( settings );

    TInt templateBuffer = iFactory->SettingsIF()->TemplateUid();

    TInt i( 0 );

    TInt num( iPrintSettings->iCapabilities.Count() );

    for ( i = 0; i < num; i++ )

        {

        if ( iPrintSettings->iCapabilities[i]->iUid == EPrintCapabLayout )

            {

            TInt j( 0 );

            CListCapability* layouts =

                static_cast<CListCapability*>

                        ( iPrintSettings->iCapabilities[i] );

            for ( j = 0; j < layouts->iEnumIDs.Count(); j++ )

                {

                // Create new template data with the icon and Uid value

                CTemplateData* data = CTemplateData::NewL();

                data->iUid = layouts->iEnumIDs[j];

                CleanupStack::PushL( data );

                LOG1( "CSettingsManager::InitTemplateSettingsL, UID: %d", data->iUid );

                User::LeaveIfError( settings->iTemplates.Append( data ) );

                CleanupStack::Pop( data );

                }

            }

        }

    // Sort the templates to "standard" order

    CTemplateSettings* sortsettings = CTemplateSettings::NewL( iFactory );

    CleanupStack::PushL( sortsettings );

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

        {

        for ( TInt j = 0; j < settings->iTemplates.Count(); j++ )

            {

            if ( KTemplates[i] == settings->iTemplates[j]->iUid )

                {

                CTemplateData* data = CTemplateData::NewL();

                data->iUid = settings->iTemplates[j]->iUid;

                CleanupStack::PushL( data );

                LOG1( "CSettingsManager::InitTemplateSettingsL, UID: %d", data->iUid );

                User::LeaveIfError( sortsettings->iTemplates.Append( data ) );

                CleanupStack::Pop( data );

                break;

                }

            }

        }

    CleanupStack::Pop( sortsettings );

    CleanupStack::PopAndDestroy( settings );

    delete iTemplateSettings;

    iTemplateSettings = sortsettings;

    TBool templateFound = EFalse;

    if ( iTemplateSettings->iTemplates.Count() > 0 )

        {

        for (TInt g = 0; g < iTemplateSettings->iTemplates.Count(); g++) 

        	{

	        if (iTemplateSettings->iTemplates[g]->iUid == templateBuffer)

	        	{

	        		iTemplateSettings->iActiveTemplateUid = templateBuffer;

	        		templateFound = ETrue;

	        	}

        	}

        if (!templateFound){

        iTemplateSettings->iActiveTemplateUid = 

        iTemplateSettings->iTemplates[0]->iUid;

        }

        SetActiveTemplateL( iTemplateSettings->iActiveTemplateUid );

        }

    // If there are no templates available, draw the preview using

    // 1/page template

    else

        {

        LOG("CSettingsManager::InitTemplateSettingsL || No templates available!");

        SetActiveTemplateL( EPrintCapabLayout1UpMedium );

        }

    LOG("CSettingsManager::InitTemplateSettingsL End");

    }

// Fetches capability from the list and returns it

CBaseCapability* CSettingsManager::FetchCapabilityL(

    TInt aUid )

    {

    LOG1("CSettingsManager::FetchCapabilityL Begin: %d", aUid);

    CBaseCapability* capab = NULL;

    TInt found( KErrNotFound );

    TInt i( 0 );

    TInt num( iPrintSettings->iCapabilities.Count() );

    for ( i = 0; i < num && found != KErrNone; i++ )

        {

        if ( iPrintSettings->iCapabilities[i]->iUid == aUid )

            {

            capab = iPrintSettings->iCapabilities[i];

            found = KErrNone;

            }

        }

    User::LeaveIfError( found );

    LOG("CSettingsManager::FetchCapabilityL End");

    return capab;

    }

TInt CSettingsManager::TemplateUid()

    {

    LOG1( "CSettingsManager::TemplateUid || iActiveTemplateUid = %d", iTemplateSettings->iActiveTemplateUid );

    return iTemplateSettings->iActiveTemplateUid;

    }

TBool CSettingsManager::UpdatePageNumberL( TInt aCurrentImage )

    {

    TBool retValue = EFalse;

    TUint pageNumber;

    if( iNumberOfCopiesCumulativeArray.Count() > aCurrentImage-1 )

        {

        aCurrentImage = iNumberOfCopiesCumulativeArray[aCurrentImage-1];

        }

    pageNumber = aCurrentImage / iImagesOnPage;

    if ( ( aCurrentImage % iImagesOnPage ) != 0 )

        {

        pageNumber++;

        }

    if ( iActivePage != pageNumber )

        {

        iActivePage = pageNumber;

        retValue = ETrue;

        }

    return retValue;

    }

TInt CSettingsManager::PrinterUid()

    {

    return iPrinterUid;

    }

TBool CSettingsManager::GetUsbState()

    {

    return iUsbConnected;

    }

void CSettingsManager::SetUsbState( TBool aConnected )

    {

    iUsbConnected = aConnected;

    }

TInt CSettingsManager::GetDefaultPrinterProtocol()

    {

    TInt retValue;

    TInt err = iCRSession->Get( KDefaultPrinterProtocol, retValue );

    LOG2("CSettingsManager::GetDefaultPrinterProtocol: %d, err: %d", retValue, err);

    return ( err ) ? err : retValue;

    }

TInt CSettingsManager::SetDefaultPrinterProtocol( TInt aProtocol )

    {

    TInt err = iCRSession->Set( KDefaultPrinterProtocol, aProtocol );

    LOG2("CSettingsManager::SetDefaultPrinterProtocol: %d, err: %d", aProtocol, err);

    return err;

    }

TInt CSettingsManager::GetCurrentPrinterProtocol()

    {

    LOG1("CSettingsManager::GetCurrentPrinterProtocol: %d", iCurrentPrinterProtocol );

    return iCurrentPrinterProtocol;

    }

void CSettingsManager::SetCurrentPrinterProtocol( TInt aProtocol )

    {

    LOG1("CSettingsManager::SetCurrentPrinterProtocol: %d", aProtocol );

    iCurrentPrinterProtocol = aProtocol;

    }

TUint CSettingsManager::GetCurrentPrinterVendor()

    {

    LOG1("CSettingsManager::GetCurrentPrinterVendor() vendor: %d",iVendor);

    return iVendor;