/*

* Copyright (c) 2005-2006 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 "aicalendarplugin2.h"

#include "aicalendarplugin2contentmodel.h"

#include "AIAgendaPluginEngineIf.h"

#include "aicalendarplugin2constantdata.h"

#include "aicalendarplugin2data.h"

#include "aicalendarplugin2constants.hrh"

#include "aicalendarplugin2uids.hrh"

#include <aicalendarplugin2.mbg>

#include <calendar.mbg>

#include <gulicon.h>

#include <bautils.h>

#include <ecom/implementationproxy.h>

#include <aistrparser.h>

#include <aiutility.h>

#include <aipluginsettings.h>

// CONSTANTS

const TInt KAI2CurrentIconLoadSizeX = 40;

const TInt KAI2CurrentIconLoadSizeY = 40;

const TInt KAI2InternalIdForNoEvents = -357;

const TInt KAI2InternalIdForNoMoreEvents = -38;

const TInt KAI2InternalIdForNextEvent = -44;

const TInt KAI2InternalIdForNextEvents = -45;

const TInt KAI2InternalIdForNextEventTomorrow = -762;

enum TAi2CalIcons

    {

    // Lets be explicit to maintain readability

    KAi2IconCalendar = 0,

    KAi2MeetingIcon, // 1

    KAi2Memo, // 2

    KAi2Anniversary, // 3

    KAi2UncompeledTodo // 4

    };

_LIT( KResourceDrive, "z:" );

_LIT( KCalendarBitmapFile, "calendar.mif" );

_LIT( KAIPluginIconBitmapFile, "aicalendarplugin2.mif" );

_LIT( KCalendarResourceFile, "calendar.rsc" );

_LIT( KAIPluginTextsResourceFileName,    "aicalendarplugin2res.rsc");

_LIT16( KHexPrefix16, "0x" );

TInt ParseInt

        ( TInt32& aValue, const TDesC16& aStringValue )

    {

    const TInt pos = aStringValue.FindF( KHexPrefix16 );

    if (pos != KErrNotFound)

        {

        TLex16 lex( aStringValue.Mid( pos + KHexPrefix16().Length() ) );

        // Hex parsing needs unsigned int

        TUint32 value = 0;

        const TInt parseResult = lex.Val( value, EHex );

        if ( parseResult == KErrNone )

            {

            aValue = value;

            }

        return parseResult;

        }

    else

        {

        TLex16 lex( aStringValue );

        return lex.Val(aValue);

        }

    }

TInt GetTimedItemLineNeed(

                RPointerArray<CAiCalendarPlugin2EventItem>& /*aArray*/,

                TInt /*aArrayOffset*/ )

    {

    // Multiline cale

    return 1;

    }

TInt GetTimedArrayLineNeed(

                RPointerArray<CAiCalendarPlugin2EventItem>& aArray, TInt aSpaceTaken )

    {

    // Multiline cale

    return aArray.Count() * aSpaceTaken;

    }

TInt CalculateStartIndexBackwards(

                RPointerArray<CAiCalendarPlugin2EventItem>& aArray,

                TInt aLinesAvailable,

                TInt spaceUse,

                TBool aHasPriority )

    {

    TInt i = aArray.Count() - 1;

    TInt totalSpace = 0;

    for( ; i >= 0; --i )

        {

        if( totalSpace + spaceUse >= aLinesAvailable )

            {

            if( totalSpace + spaceUse > aLinesAvailable )

                {

                ++i;

                }

            break;

            }

        totalSpace += spaceUse;

        }

    if( i >= aArray.Count() )

        {

        i = aArray.Count() - 1;

        }

    else if( ( ( i < 0 ) && aHasPriority ) ||// <- if there is little space left only priority item are

                                        //    fitted to the screen

        ( aLinesAvailable > aArray.Count() ) )// <- if theres lot of space, make sure to fit us too

        {

        i = 0;

        }

    return i;

    }

// Provide a key pair value table for ECOM.

// Used to identify the correct construction function for the requested interface.

const TImplementationProxy ImplementationTable[] = 

    {

    IMPLEMENTATION_PROXY_ENTRY( AI_UID_ECOM_IMPLEMENTATION_CONTENTPUBLISHER_CALENDARPLUGIN,

                                CAICalendarPlugin2::NewL )

    };

// ============================ MEMBER FUNCTIONS ===============================

CAICalendarPlugin2* CAICalendarPlugin2::NewL()

    {

    CAICalendarPlugin2* self = new( ELeave )CAICalendarPlugin2;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CAICalendarPlugin2::CAICalendarPlugin2()

  : iActualLinesInUse( KAICal2DefaultActualLines ),

    iNonTimedItemReservation( KAICal2DefaultItemReservation )

    {

    }

void CAICalendarPlugin2::ConstructL()

    {

    if( !iCalendarResourceFileOffset )

        {

        TFileName resFile;

        resFile.Append( KResourceDrive );

        resFile.Append( KDC_APP_RESOURCE_DIR );

        resFile.Append( KCalendarResourceFile );

        BaflUtils::NearestLanguageFile( CCoeEnv::Static()->FsSession(), resFile );

        iCalendarResourceFileOffset = CCoeEnv::Static()->AddResourceFileL( resFile );

        }

    if( !iTextResourceFileOffset )

        {

        TFileName resFile;

        resFile.Append( KResourceDrive );

        resFile.Append( KDC_RESOURCE_FILES_DIR );

        resFile.Append( KAIPluginTextsResourceFileName );

        BaflUtils::NearestLanguageFile( CCoeEnv::Static()->FsSession(), resFile );

        iTextResourceFileOffset = CCoeEnv::Static()->AddResourceFileL( resFile );

        }

    iCalendarIconFileName = HBufC::NewL( KResourceDrive().Length() +

                                         KDC_APP_BITMAP_DIR().Length() +

                                         KCalendarBitmapFile().Length() );

    iCalendarIconFileName->Des().Append( KResourceDrive );

    iCalendarIconFileName->Des().Append( KDC_APP_BITMAP_DIR );

    iCalendarIconFileName->Des().Append( KCalendarBitmapFile );

    iPluginIconFileName = HBufC::NewL( KResourceDrive().Length() +

                                       KDC_APP_BITMAP_DIR().Length() +

                                       KAIPluginIconBitmapFile().Length() );

    iPluginIconFileName->Des().Append( KResourceDrive );

    iPluginIconFileName->Des().Append( KDC_APP_BITMAP_DIR );

    iPluginIconFileName->Des().Append( KAIPluginIconBitmapFile );

    iConstantData = CAICalendarPlugin2ConstantData::NewL();

    iEventData = CAICalendarPlugin2Data::NewL();

    iStrParser = AiUtility::CreateStrParserL();

    }

CAICalendarPlugin2::~CAICalendarPlugin2()

    {

    if( iCalendarResourceFileOffset )

        {

        CCoeEnv::Static()->DeleteResourceFile( iCalendarResourceFileOffset );

        }

    if( iTextResourceFileOffset )

        {

        CCoeEnv::Static()->DeleteResourceFile( iTextResourceFileOffset );

        }

    delete iEngine;

    delete iEventData;

    delete iConstantData;

    Release( iStrParser );

    iBitmaps.ResetAndDestroy();

    iMasks.ResetAndDestroy();

    delete iPluginIconFileName;

    delete iCalendarIconFileName;

    iPublishedDataStore.Reset();

    iNewCollectedDataStore.Reset();

	delete iPrevUid;

    }

void CAICalendarPlugin2::CreateBitmapSkinnedIconL( const TAknsItemID& aSkinIconId,

                                                   const TDesC& aFilename,

                                                   TInt aNormalIconId,

                                                   TInt aNormalMaskId,

                                                   CFbsBitmap*& aBitmap,

                                                   CFbsBitmap*& aMask )

    {

    AknsUtils::CreateIconLC( AknsUtils::SkinInstance(), 

                             aSkinIconId, 

                             aBitmap, 

                             aMask, 

                             aFilename, 

                             aNormalIconId, 

                             aNormalMaskId );

    CleanupStack::Pop( 2 );  // bitmap, mask, cant use pop param here, we dont know

                             // the push order of the CreateIconLC

    }

void CAICalendarPlugin2::CreateIconsL(void)

    {

    CFbsBitmap* bitmap;

    CFbsBitmap* mask;

    iBitmaps.ResetAndDestroy();

    iMasks.ResetAndDestroy();

    TSize iconSize( TSize( KAI2CurrentIconLoadSizeX,

                           KAI2CurrentIconLoadSizeY ) );

    /**

     * Creation order!:

     *   Calendar icon

     *   Meeting icon

     *   Note icon

     *   Anniversary icon

     *   Uncompleted to-do icon

     *   

     **/

    CreateBitmapSkinnedIconL( KAknsIIDQgnIndiAiCale, 

                              *iPluginIconFileName, 

                              EMbmAicalendarplugin2Qgn_indi_ai_cale, 

                              EMbmAicalendarplugin2Qgn_indi_ai_cale_mask,

                              bitmap, mask );

    // These bitmaps are permanently owned by arrays here.

    // Only duplicates are provided to system, are they can

    // do whatever they want to them.

    User::LeaveIfError( iBitmaps.Append( bitmap ) );

    User::LeaveIfError( iMasks.Append( mask ) );

    User::LeaveIfError( 

        AknIconUtils::SetSize( bitmap, iconSize ) );

    CreateBitmapSkinnedIconL( KAknsIIDQgnIndiCdrMeeting, 

                              *iCalendarIconFileName, 

                              EMbmCalendarQgn_indi_cdr_meeting, 

                              EMbmCalendarQgn_indi_cdr_meeting_mask,

                              bitmap, mask );

    User::LeaveIfError( iBitmaps.Append( bitmap ) );

    User::LeaveIfError( iMasks.Append( mask ) );

    User::LeaveIfError( 

        AknIconUtils::SetSize( bitmap, iconSize ) );

    CreateBitmapSkinnedIconL( KAknsIIDQgnIndiCdrReminder, 

                              *iCalendarIconFileName, 

                              EMbmCalendarQgn_indi_cdr_reminder, 

                              EMbmCalendarQgn_indi_cdr_reminder_mask,

                              bitmap, mask );

    User::LeaveIfError( iBitmaps.Append( bitmap ) );

    User::LeaveIfError( iMasks.Append( mask ) );

    User::LeaveIfError( 

        AknIconUtils::SetSize( bitmap, iconSize ) );

    CreateBitmapSkinnedIconL( KAknsIIDQgnIndiCdrBirthday, 

                              *iCalendarIconFileName, 

                              EMbmCalendarQgn_indi_cdr_birthday, 

                              EMbmCalendarQgn_indi_cdr_birthday_mask,

                              bitmap, mask );

    User::LeaveIfError( iBitmaps.Append( bitmap ) );

    User::LeaveIfError( iMasks.Append( mask ) );

    User::LeaveIfError( 

        AknIconUtils::SetSize( bitmap, iconSize ) );

    CreateBitmapSkinnedIconL( KAknsIIDQgnPropTodoUndone, 

                              *iCalendarIconFileName, 

                              EMbmCalendarQgn_indi_cdr_todo, 

                              EMbmCalendarQgn_indi_cdr_todo_mask,

                              bitmap, mask );

    User::LeaveIfError( iBitmaps.Append( bitmap ) );

    User::LeaveIfError( iMasks.Append( mask ) );

    User::LeaveIfError( 

        AknIconUtils::SetSize( bitmap, iconSize ) );

    iBitmaps.Compress();

    iMasks.Compress();

    }    

void CAICalendarPlugin2::Resume( TResumeReason aReason )

    {

    TRAP_IGNORE( DoResumeL( aReason ) );

    }

void CAICalendarPlugin2::DoResumeL( TResumeReason aReason )

    {

    if( aReason == EForeground )

        {

        if( !iEngine )

            {

            iEngine = CAIAgendaPluginEngineIf::NewL( *this, ECalendarAndTodoObserver );

            }

        else

            {

            iEngine->Refresh();

            }

        }

    }

void CAICalendarPlugin2::Suspend( TSuspendReason aReason )

    {

    if ( aReason == EGeneralThemeChange )

        {

        // Reset for republishing. Especially icons!

        iPublishedDataStore.Reset();

        }

    }

void CAICalendarPlugin2::Start( TStartReason /*aReason*/ )

    {    

    }

void CAICalendarPlugin2::Stop( TStopReason /*aReason*/ )

    {

    delete iEngine;

    iEngine = NULL;

    iPublishedDataStore.Reset();

    }

void CAICalendarPlugin2::SubscribeL( MAiContentObserver& aObserver )

    {

    iEventData->AppendObserverL( aObserver );

    }

void CAICalendarPlugin2::ConfigureL( RAiSettingsItemArray& aSettings )

    {

    // Receive the settings for this plugin from the user(theme or similar).

    // There are four settings we need for the current implementation to work

    // properly:

    //

    // 1) total item count of the UI = EPluginEventItemCount

    //

    // 2) the vertical space taken by timed item (relative to the size of non timed item)

    //    = EPluginTimedEventLineCount

    //

    // 3) the vertical space taken by non timed item (relative to the size of timed item)

    //    = EPluginNonTimedEventLineCount

    //

    // 4) the amount of lines we reserve for non timed events if many timed and non timed

    //    events are present = EPluginNonTimedReservedItems

    //

    // In the current 2.6.2006 specification for example (Navibar theme), we have non timed items

    // half the vertical size of timed items. Timed items take 2 lines visible space and

    // non timed take 1 line of visible space. We need to able to show at maximum 6

    // non timed items, so we need total 6 items (1 line items). As timed items take

    // 2 lines we can fit three of them in to the view (no setting need/can be calculated)

    // as stated in the specification. If many timed and non timed calendar events are 

    // present we always reserve 2 times for non timed events.

    // So the setting to satisfy the UI spec of the "Navibar UI" are 6, 2, 1, 2

    //

    //

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

        {

        MAiPluginSettingsItem& item = (aSettings[i])->AiPluginSettingsItem();

        TInt32 value = 0;

        if( ParseInt( value, item.Value() ) != KErrNone )

            {

            continue;

            }

        if( value < 0 )

            {

            continue;

            }

        if( item.Key() == EPluginEventItemCount )

            {

            iActualLinesInUse = value;

            continue;

            }

        else if( item.Key() == EPluginTimedEventLineCount )

            {

            iEventData->SetSpaceTakenByTimedEvent( value );

            continue;

            }

        else if( item.Key() == EPluginNonTimedEventLineCount )

            {

            iEventData->SetSpaceTakenByNonTimedEvent( value );

            continue;

            }

        else if( item.Key() == EPluginNonTimedReservedItems )

            {

            iNonTimedItemReservation = value;

            continue;

            }

        else if( item.Key() == EPluginAppendEndTimeToOngoingItems )

            {

            iConstantData->iAppendEndTimeToOngoingItems = value;

            continue;

            }

        else if( item.Key() == EPluginUseAlternatePublishForUpcomingAndOngoingItems )

            {

            iConstantData->iUseAlternatePublish = value;

            continue;

            }

        else if( item.Key() == EPluginOpenInViewerOrEditor )

            {

            iConstantData->iOpenInViewer = !value;

            continue;

            }

        else if( item.Key() == EPluginDaysToHandleAsNotToday )

            {

            iConstantData->iDaysToHandleAsNotToday = value;

            continue;

            }

        else if( item.Key() == EPluginOpenFirstValidOnIndexZero )

            {

            iConstantData->iOpenFirstValid = value;

            continue;

            }

        else if ( item.Key() == EPluginPublishInfoWithAlternateId )

            {

            iConstantData->iUseAlternateInfoPublish = value;

            continue;

            }

        }

    // Last op, free array and items

    aSettings.ResetAndDestroy();

    }

TAny* CAICalendarPlugin2::GetProperty( TProperty aProperty )

    {

    TAny* result( NULL );

    TRAP_IGNORE( result = iConstantData->GetPropertyL( aProperty ) );

	return result;

    }

void CAICalendarPlugin2::HandleEvent( TInt aEvent, const TDesC& aParam )

    {

    if( aEvent == EAICalendarPlugin2EventItemSelected )

        {

        TInt32 index = 0;

        if( ParseInt( index, aParam ) != KErrNone )

            {

            return;

            }

        // Other "out of bounds" checked inside launch method.

        if( index > iActualLinesInUse )

            {

            // invalid index

            return;

            }

        iEventData->LaunchCalendarApplication( index, iConstantData->iOpenFirstValid );

        }

    }

void CAICalendarPlugin2::PluginDataChanged(

                    const RPointerArray<CCalInstance>& aEntryArray,

                    TBool aHadEvents )

    {

    iEventData->SetHadExpiredEvents( aHadEvents );

    iEventData->ClearDataArrays();

    TRAP_IGNORE(

        FillDataArraysL( aEntryArray );

        PublishDataArraysL();

        );

    }

void CAICalendarPlugin2::FillDataArraysL(

                    const RPointerArray<CCalInstance>& aEntryArray )

    {

    /**

     * [uses icon y/n] time formatting | subject and location formatting

     *

     * [Y] 13:05-14:00 subject, location...  // normal day event

     * [Y] 00:00-08:00 subject, location...  // event starting yesterday

     * [Y] 19:00-23:59 subject, location...  // event ends tomorrow

     * [Y] 16:50-16:50 subject, location...  // event with no duration

     * [Y] 25/8/04 16:00- subject...  // normal not today event

     * [Y] subject...  // normal non timed event

     * [Y] 25/8/04 subject...  // not today non timed event

     * 26.10.2006 Tuomas Karjagin: - all item now will use icons

     *                             - end time removed from normal not today.

     **/

    // extract new data from CAgnEntry objects

    TInt daynoteIndex = 0; // to insert day notes in correct order...