#include <aknnotewrappers.h>            // CAknInformationNote

#include <aknViewAppUi.h>               // CAknViewAppUi

#include <StringLoader.h>               // Loads strings from resource

#include <aknappui.h>

#include <bautils.h>

#include <data_caging_path_literals.hrh>

#include <pathinfo.h>

#include <avkon.hrh>

#include "calenviewinfo.h"              // View information

#include <Calendar.rsg>                 // Calendar resourcess

#include <missedalarmstore.h>           // missed alarm store

#include <calsession.h>

#include <calencommandhandler.h>

#include <calencontext.h>

#include <calenconstants.h>             // KCalenLostAlarms etc

#include <calcalendarinfo.h>

#include "calendarui_debug.h"           // Debug macros

#include "calenactionui.h"              // Default command handling

#include "calennotifier.h"              // Broadcasts system events

#include "calenviewmanager.h"           // Responsible for all view activations

#include "calenalarmmanager.h" 			// Alarm Manager

#include "calensetting.h"

#include "calencmdlinelauncher.h"       // Command line launcher

#include "calenicons.h"

#include "calentoolbarimpl.h"

#include "calenmultipledbmanager.h"

#include "calenattachmentmodel.h"

_LIT( KResourceFile, "calencommonui.rsc" );

// CCalenController::NewL

// First stage construction. This will leave if an instance of the controller

// already exists.  All access to an instance of the controller should be

// through the InstanceL function, except for the initial construction

// which should be handled by the appui.

// This is to prevent usage of this API through the services dll when Calendar

// application is not running.

EXPORT_C CCalenController* CCalenController::NewL( CAknViewAppUi& aAppUi )

    {

    TRACE_ENTRY_POINT;

    CCalenController* self = NULL;

    TAny* tlsPtr = Dll::Tls();

    // Check Thread local storage

    if( !tlsPtr )

        {

        // TLS is NULL, so no CCalenController has been created yet.

        self = new( ELeave ) CCalenController( aAppUi );

        CleanupStack::PushL( self );

        // Store a self pointer in TLS

        User::LeaveIfError( Dll::SetTls( static_cast<TAny*>( self ) ) );

        // Increment ref count right away. If we don't do it here, and someone

        // calls Controller::InstanceL in ConstructL and then ConstructL

        // leaves, we will double delete the controller.

        ++self->iRefCount;

        self->ConstructL();

        CleanupStack::Pop( self );

        }

    else

        {

        // An instance of the controller exists already.

        // This function should only have been called once, by CCalenAppUi

        User::Leave( KErrAlreadyExists );

        }

    TRACE_EXIT_POINT;

    return self;

    }

EXPORT_C CCalenController* CCalenController::InstanceL()

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return self;

// CCalenController::ConstructL

// 2nd phase of construction

void CCalenController::ConstructL()

    TRACE_ENTRY_POINT;

       	TFileName fileName;

	// Get the complate path of the DLL from where it is currently loaded

	Dll::FileName( fileName );

	TFileName resFile;

	// Append the Drive letters ex., Z: or C:

	resFile.Append(fileName.Mid(0,2));

	resFile.Append(KDC_RESOURCE_FILES_DIR);

    resFile.Append(KResourceFile);

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

	iResourceFileOffset = CEikonEnv::Static()->AddResourceFileL( resFile );

	iStateMachine = CCalenStateMachine::NewL( *this );

    // Create the notifier.

    iNotifier = new( ELeave )CCalenNotifier( *this );

    // Get an instance of the global data

    iGlobalData = CCalenGlobalData::NewL( *iNotifier, iNotifier, iNotifier );

    iGlobalData->InitializeGlobalDataL();

    RArray<TCalenNotification> notificationArray;

    // Complete construction of the notifier and register the

    // global data for notifications

    iNotifier->ConstructL();

    notificationArray.Append(ECalenNotifyEntryInstanceViewCreated);

    notificationArray.Append(ECalenNotifyEntryInstanceViewCreationFailed);

    notificationArray.Append(ECalenNotifyDeleteInstanceView);

    notificationArray.Append(ECalenNotifyRealExit);

    notificationArray.Append(ECalenNotifyCalendarInfoCreated);

    notificationArray.Append(ECalenNotifyCalendarInfoUpdated);

    RegisterForNotificationsL( iGlobalData,notificationArray);

    notificationArray.Reset();

    // Create the cmd line handler

    iCmdLineLauncher = CCalenCmdLineLauncher::NewL( *this, iAppUi );

    // Create the services

    iServices = CCalenServicesImpl::NewL();

    // Create the action uis.

    iActionUi = CCalenActionUi::NewL( *this );

    // Create the settings

    iSetting = CCalenSetting::InstanceL();

    // Create the view manager, and register for notifications

    iViewManager = CCalenViewManager::NewL( iAppUi, *this );

    notificationArray.Append(ECalenNotifySettingsChanged);

    notificationArray.Append(ECalenNotifySettingsClosed);

    notificationArray.Append(ECalenNotifySystemLocaleChanged);

    notificationArray.Append(ECalenNotifyPluginEnabledDisabled);

    notificationArray.Append(ECalenNotifyEntrySaved);

    notificationArray.Append(ECalenNotifyEntryDeleted);

    notificationArray.Append(ECalenNotifyInstanceDeleted);

    notificationArray.Append(ECalenNotifyMultipleEntriesDeleted);

    notificationArray.Append(ECalenNotifyExternalDatabaseChanged);

    notificationArray.Append(ECalenNotifyDeleteFailed);

    notificationArray.Append(ECalenNotifyEntryClosed);

	notificationArray.Append(ECalenNotifyCancelDelete);

    notificationArray.Append(ECalenNotifySystemTimeChanged);

    notificationArray.Append(ECalenNotifyAppForegrounded);

    notificationArray.Append(ECalenNotifyDayViewClosed);

    notificationArray.Append(ECalenNotifyWeekViewClosed);

    notificationArray.Append(ECalenNotifyAppBackgrounded);

    notificationArray.Append(ECalenNotifyViewPopulationComplete);

    notificationArray.Append(ECalenNotifyCalendarFieldChanged);

    notificationArray.Append(ECalenNotifyCancelStatusUpdation);

    notificationArray.Append(ECalenNotifyMarkedEntryCompleted);

    notificationArray.Append(ECalenNotifyAttachmentAdded);

    notificationArray.Append(ECalenNotifyAttachmentViewerClosed);

    notificationArray.Append(ECalenNotifyAttachmentRemoved);

    notificationArray.Append(ECalenNotifyCalendarInfoCreated);

    notificationArray.Append(ECalenNotifyCalendarInfoUpdated);

    notificationArray.Append(ECalenNotifyCalendarFileDeleted);

    RegisterForNotificationsL( iViewManager, notificationArray );

    notificationArray.Reset();

    // Create the customisation manager, and register for 

    // notifications

    iCustomisationManager = CCalenCustomisationManager::NewL( *this,

                                                              iSetting->PluginAvailability(),

                                                              *iServices,

                                                              iViewManager->ViewInfoArray() );

    notificationArray.Append(ECalenNotifySettingsChanged);

    notificationArray.Append(ECalenNotifyCheckPluginUnloading);

    notificationArray.Append(ECalenNotifyEComRegistryChanged);

    RegisterForNotificationsL( iCustomisationManager,notificationArray);

    notificationArray.Reset();

    // Some plugins may have been added or removed - update the settings.

    iSetting->UpdatePluginListL( *iCustomisationManager );

    // View manager constructs the custom views using the

    // customisation manager

    iViewManager->ConstructCustomViewsL( *iCustomisationManager );

    // for handling missed alarms/msk improvements for alarm

    iAlarmManager = CCalenAlarmManager::NewL(*this); 

    notificationArray.Append(ECalenNotifyLostAlarms);

    notificationArray.Append(ECalenNotifyMissedAlarmViewClosed);

    notificationArray.Append(ECalenNotifyClearMissedAlarms);

    notificationArray.Append(ECalenNotifyMissedEventViewClosed);

    notificationArray.Append(ECalenNotifyEntryDeleted);

    notificationArray.Append(ECalenNotifyInstanceDeleted);

    notificationArray.Append(ECalenNotifyEntrySaved);

    notificationArray.Append(ECalenNotifyMultipleEntriesDeleted);

    notificationArray.Append(ECalenNotifySystemTimeChanged);

    notificationArray.Append(ECalenNotifyAlarmStopped);

    notificationArray.Append(ECalenNotifyAlarmSnoozed);

    notificationArray.Append(ECalenNotifyEntryClosed);

    notificationArray.Append(ECalenNotifyAppForegrounded);

    RegisterForNotificationsL( iAlarmManager, notificationArray );

    notificationArray.Reset();

    //iMultipleDbmanager = CCalenMultipleDbManager::NewL();

    iAttachmentData = CCalenAttachmentModel::NewL();

    notificationArray.Close();

    TRACE_EXIT_POINT;

// CCalenController::CCalenController

// C++ default constructor.

CCalenController::CCalenController( CAknViewAppUi& aAppUi )

    : iAppUi( aAppUi ),

      iNextServicesCommandBase( KCustomCommandRangeStart ),

      iFasterApp( EFalse )

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    {    

    TRACE_ENTRY_POINT;

    if(iSystemTimeChangedMsgDelayer)

        {

        iSystemTimeChangedMsgDelayer->Cancel();

        delete iSystemTimeChangedMsgDelayer;

        iSystemTimeChangedMsgDelayer = NULL;

        }

    if(iAttachmentData)

        {

        delete iAttachmentData;

        iAttachmentData = NULL;

        }

    if( iAlarmManager )

        {

        delete iAlarmManager;

        }

    if( iCustomisationManager )

        {

        delete iCustomisationManager;

        }

    if( iViewManager )

        {

        delete iViewManager;

        }

    if ( iSetting )

        {

        iSetting->Release();

        }

    if( iActionUi )

        {

        delete iActionUi;

        }

    if( iCmdLineLauncher )

        {

        delete iCmdLineLauncher;

        }

    if( iGlobalData )

        {

        iGlobalData->Release();

        }

        {

        delete iNotifier;

        }

    if( iStateMachine )

        {

        delete iStateMachine;

        }

   if( iResourceFileOffset )

       {

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

       }

    Dll::SetTls( NULL );

    TRACE_EXIT_POINT;

    }

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

// CCalenController::Release

// Decrement the reference count of this singleton.

// When the reference count is 0, the controller will self delete and free

// all resources

// (other items were commented in a header).

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

//

EXPORT_C void CCalenController::Release()

    {

    TRACE_ENTRY_POINT;

    --iRefCount;

    // The controller owns its own instance of the services, therefore the

    // reference count will be one, immediatley before deletion.

    if (iRefCount == 1)

        {

        delete this;

        }

    TRACE_EXIT_POINT;

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

// CCalenController::ReleaseCustomisations

// Releases any plugins by deleting the customisation manager

// should only be called on exiting by the document.

// (other items were commented in a header).

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

//

EXPORT_C void CCalenController::ReleaseCustomisations()

    {

    TRACE_ENTRY_POINT;

    delete iCustomisationManager;

    iCustomisationManager = NULL;

    TRACE_EXIT_POINT;

EXPORT_C TBool CCalenController::IssueCommandL( TInt aCommand )

    TRACE_ENTRY_POINT;

    TCalenCommand cmd;

    if( aCommand == EAknCmdHideInBackground ||

	  ( aCommand == EAknSoftkeyExit && iAppUi.ExitHidesInBackground() ) )

	    {

	    SetFasterAppFlag( ETrue );

	    aCommand = ECalenFasterAppExit;

	    }

    else if( aCommand == EAknCmdExit || aCommand == EEikCmdExit

             || aCommand == EAknSoftkeyExit )

        {

        if( iViewManager->CalenToolbar() )

            {

            iViewManager->CalenToolbar()->ResetCalendarToolbar();

            }

        }

    else

        {

        if((aCommand < ECalenViewCommandBase ) || (aCommand > iNextServicesCommandBase))

            {

            return EFalse;

            }

        }

    cmd.SetCommandAndContextL( aCommand, iGlobalData->Context() );

    TRACE_EXIT_POINT;

// CCalenController::RequestActivationL

// Request activation of a specific view

void CCalenController::RequestActivationL( const TVwsViewId& aViewId )

    TRACE_ENTRY_POINT;

    iViewManager->RequestActivationL( aViewId );

    TRACE_EXIT_POINT;

// CCalenController::BroadcastNotification

EXPORT_C void CCalenController::BroadcastNotification( TCalenNotification aNotification )

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

// CCalenController::RegisterForNotificationsL