#include <eikmenup.h>

#include <Calendar.rsg>

#include <aknsettingitemlist.h>          // CAknSettingItem

#include <calencommandhandler.h>

#include <calencustomisation.h>

#include <calenservices.h>

#include <mcalenpreview.h>

#include "calensend.h"

#include "calenviewinfo.h"

#include "calendarui_debug.h"

#include "calencustomisationmanager.h"

#include "calencontroller.h"

#include "calensetting.h"

EXPORT_C CCalenCustomisationManager* CCalenCustomisationManager::NewL( 

                                    CCalenPluginStatusArray& aPluginSettingsStatus,

                                    MCalenServices& aServices,

                                    RPointerArray<CCalenViewInfo>& aViewArray )

    TRACE_ENTRY_POINT;

                                                                 aServices,

                                                                 aViewArray,

                                                                 aPluginSettingsStatus );

    TRACE_EXIT_POINT;

                                                        MCalenServices& aServices,

                                                        RPointerArray<CCalenViewInfo>& aViewArray,

                                                        CCalenPluginStatusArray& aPluginSettingsStatus )

    : iServicesFactory( aFactory ),

      iViewInfoArray( aViewArray ),

      iSortOrder( CCalenViewInfo::CyclePositionComparison ), 

      iServices( aServices ),

      iPluginSettingsStatus( aPluginSettingsStatus )

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    TRACE_ENTRY_POINT;

    iInfoBarProviderUid = TUid::Uid(0);

    iPreviewPaneProviderUid = TUid::Uid(0);

    // Get a pointer to the global data and controller

    iGlobalData = CCalenGlobalData::InstanceL();

    // Get the setting singleton. We update it when settings change.

    iSetting = CCalenSetting::InstanceL();

    TRACE_EXIT_POINT;

EXPORT_C CCalenCustomisationManager::~CCalenCustomisationManager()

    TRACE_ENTRY_POINT;

    // reset deferred unload plugins list

    iDefferedUnloadPluginList.Reset();

    // Release the global data and controller

    if ( iGlobalData )

        {

        iGlobalData->Release();

        }

    if(iSetting)

        {

        iSetting->Release();

        }

    iHiddenViews.Reset();

    TRACE_EXIT_POINT;

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

// CCalenCustomisationManager::GetCommandHandlerL

// Get a command handler for a specific command.  Ownership remains with the

// plugin

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

EXPORT_C MCalenCommandHandler* CCalenCustomisationManager::GetCommandHandlerL( TInt aCommand )

    {

    TRACE_ENTRY_POINT;

    MCalenCommandHandler* handler( NULL );

    // Loop though all the enabled plugins asking for a command handler

    // to handle this command with.  Returns NULL if no plugin wants to 

    // handle the command.

    TInt count = iPlugins.Count();

    for ( TInt index = 0; index < count && !handler; ++index )

        {

        TRAPD( error,

            // Loop though until a command handler is found

            for (; index < count && !handler; ++index )

                {

                if ( !iPlugins[index]->IsDisabled() )

                    {

                    handler = iPlugins[index]->Plugin().CommandHandlerL( aCommand );

                    }

                }

             );

        if ( error )

            {

            // Report a problem with plugin.

            }

        }

    TRACE_EXIT_POINT;

    return handler;

    }

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

// CCalenCustomisationManager::GetPluginSettingsL

// Gets custom settings from the specified plugin

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

//

EXPORT_C void CCalenCustomisationManager::GetPluginSettingsL( TUid aPluginUid,

                                                              RPointerArray<CAknSettingItem>& aSettingArray )

    {

    TRACE_ENTRY_POINT;

    CCalenCustomisation* plugin = FindPluginL( aPluginUid );

    User::LeaveIfNull( plugin );

    TRAPD( error, plugin->GetCustomSettingsL( aSettingArray ));

    if ( error )

            {

            // Report a problem with plugin.

            }

    TRACE_EXIT_POINT;

    }

EXPORT_C const RArray<TUid>& CCalenCustomisationManager::ActivePlugins() const

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    TRACE_ENTRY_POINT;

    //Added resolver for corolla release

    // Set resolver params

    /*TLanguage lang = User::Language();

    TBuf8<40> langStr;

    langStr.Format( _L8("language(%d)"), lang );

    TEComResolverParams resolverParams;

    resolverParams.SetDataType( langStr );

    resolverParams.SetGenericMatch( ETrue );*/

    REComSession::ListImplementationsL( KCalenCustomisationInterfaceUid,/* resolverParams,*/ iPluginInfo );

    for ( TInt pluginIndex(0); pluginIndex < pluginCount; ++pluginIndex )

        {

        TUid pluginUid = iPluginInfo[pluginIndex]->ImplementationUid();

        // Find the plugin in the list of known plugins 

        TInt position = iPluginSettingsStatus.Find( pluginUid, PluginAvailabilityFinder );

        if ( ( position == KErrNotFound ) || ( iPluginSettingsStatus[position].iEnabled ) )

            {

            // If the plugin can not be found or if it is enabled

            // add it to the list of active plugins

            iActivePlugins.AppendL( pluginUid );

            // If the plugin is rom-based, store its uid

            if ( iPluginInfo[pluginIndex]->RomBased() )

                {

                iRomBasedPlugins.AppendL( pluginUid );

                }

            }

        }

    TRACE_EXIT_POINT;

// CCalenCustomisationManager::GetCustomViewsL

// GetCustomViews returns custom views info in an array for a given

// plugin. 

// NOTE: The contents of the array are owned by the caller - caller

// must guarantee to call ResetAndDestroy on the array in all cases.

EXPORT_C void CCalenCustomisationManager::GetCustomViewsL( TUid aPluginUid, 

                                                           RPointerArray<CCalenView>& aViews )

    {

    TRACE_ENTRY_POINT;

    CCalenCustomisation* plugin = FindPluginL( aPluginUid );

    User::LeaveIfNull( plugin );

    TRAPD( error, plugin->GetCustomViewsL( aViews ));

    if ( error )

        {

        // Report a problem with plugin.

        }

    TInt numViews = aViews.Count();

    for ( TInt index( 0 ); index < numViews; ++index )

        {

        CCalenView* customView = aViews[index];

        // Add to view info array

        const TUid viewId = customView->Id();

         // Check for duplicate view ids. 

        TInt position = iViewInfoArray.Find( viewId , 

                                     CCalenViewInfo::ViewInfoIdentifier );

        if ( position == KErrNotFound )

            {

            const TDesC& menuName = customView->LocalisedViewNameL( CCalenView::EMenuName );

            const TDesC& settingsName = customView->LocalisedViewNameL( CCalenView::ESettingsName );

            const CCalenView::TCyclePosition cyclePos = customView->CyclePosition();

            CCalenViewInfo* viewInfo = CCalenViewInfo::NewL( viewId,

                                                             aPluginUid, 

                                                             menuName,

                                                             settingsName,

                                                             cyclePos );

            // Check if the view has already been hidden.

            TBool hidden = ( iHiddenViews.Find( viewId.iUid ) != KErrNotFound );

            viewInfo->Hide( hidden );                     

            ViewInfoArray().InsertInOrderAllowRepeatsL( viewInfo, iSortOrder );

            }

         else

            {

            // A plugin with the same id already exists. ( It could be a replacement

            // view provided by a rom plugin, as currently preventing rom plugins from

            // being disabled if required is not implemented, it needs to be handled)

            delete customView;

            aViews.Remove( index );

            index--; 

            numViews--;

            // Report a problem with plugin.

            }

         }

	RArray<TInt> hiddenViews;

    CleanupClosePushL( hiddenViews );

    plugin->RemoveViewsFromCycle( hiddenViews );

    TInt hiddenViewCount = hiddenViews.Count();

    if ( hiddenViewCount )

       {

       // Get the default view form the settings to check if it is going to be hidden

       // by the installed plugin

       TUid defaultView = iSetting->DefaultView();

       for ( TInt index(0); index < hiddenViewCount; ++index )

           {

           TInt hiddenViewId = hiddenViews[index];

          // iHiddenViews.InsertInOrderAllowRepeatsL( hiddenViewId );

           // If this view is already on the view cycle list it needs

           // to be hidden.

           TUid hiddenViewUid = TUid::Uid( hiddenViewId );

           // If the current default view is hidden, then set the newly

           // installed plugin view as default view

           if(defaultView == hiddenViewUid)

               {

               TInt position = iViewInfoArray.Find( aPluginUid, 

                                                    CCalenViewInfo::ViewPluginIdentifier );

               if(position != -1)

                   {

                   for(TInt i = position; i < iViewInfoArray.Count(); i++)

                       {

                       if((iViewInfoArray[i]->PluginUid() == aPluginUid) &&

                               (iViewInfoArray[i]->CyclePosition() != CCalenView::ENoCyclePosition))

                           {

                           iSetting->SetDefaultView(iViewInfoArray[i]->ViewUid());

                           break;

                           }

                       }

                   }

               }

           }

       }

   CleanupStack::PopAndDestroy(); // removedViews

    TRACE_EXIT_POINT;

    }

EXPORT_C void CCalenCustomisationManager::SetPluginAvailabilityL( TUid aPluginUid,

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    TRACE_ENTRY_POINT;

            if(position == KErrNotFound ) // plugin has already been removed

                { 

                return ;

                }

            iActivePlugins.Remove( position );

            // Does this plugin hide any views

            RArray<TInt> removedViews;

            CleanupClosePushL( removedViews );

            CCalenCustomisation& plugin = pluginInfo->Plugin();

            plugin.RemoveViewsFromCycle( removedViews );

            TInt hiddenViewsCount = removedViews.Count();

            if ( hiddenViewsCount )

                {

                // Need to recalculate which views have been hidden, as 

                // more than one plugin might have hidden the same view.

                for ( TInt index( 0 ); index < hiddenViewsCount; ++index )

                    {

                    TUid viewUid = TUid::Uid( removedViews[index] );

                    CheckHiddenViewL( viewUid, aPluginUid );

                    }

                }

            // If the plugin does not offer any views, or the current

            // info or preview bar it can be deleted immediately,

            // otherwise the customisation needs to wait until it

            // is told it is safe to do so.

            // Does this plugin does not offer any views and the plugin

            // doesn't offer the current infobar or preview pane

            // bar it can be deleted immediately

            TInt offerViews = iViewInfoArray.Find( aPluginUid, 

                                       CCalenViewInfo::ViewPluginIdentifier );

            if ( offerViews == KErrNotFound &&

                 iInfoBarProviderUid != aPluginUid

                 && iPreviewPaneProviderUid != aPluginUid )

                {

                RArray<TUid> pluginArray;

                CleanupClosePushL( pluginArray );

                pluginArray.AppendL( aPluginUid );

                UnloadPluginsL( pluginArray );

                CleanupStack::PopAndDestroy(); // pluginArray

                }

            iPluginsEnabledDisabled = ETrue;

            iServices.IssueNotificationL( ECalenNotifyPluginEnabledDisabled );

            CleanupStack::PopAndDestroy(); // removedViews

        }

    TRACE_EXIT_POINT;

EXPORT_C void CCalenCustomisationManager::UnloadPluginsL( const RArray<TUid>& aPlugins )

    TRACE_ENTRY_POINT;