/*
* Copyright (c) 2008-2009 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:    Tag collection plugin implementation
*
*/




// INCLUDE FILES
#include "glxcollectionplugintags.h"
#include "glxcollectionplugintags.hrh"

 
#include <mpxmediageneraldefs.h>        //KMPXMediaIdGeneral
#include <mpxmediacontainerdefs.h>      //Attributes for KMPXMediaIdContainer
#include <StringLoader.h>
#include <glxplugintags.rsg>
#include <mglxdatasource.h>         //MGlxDataSource
#include <glxlog.h>                 //For Logging
#include <glxtracer.h>

_LIT(KResourceFile, "z:glxplugintags.rsc");
/**
 * @internal reviewed 14/06/2007 by Alex Birkett
 */

// ----------------------------------------------------------------------------
// Two-Phased Constructor
// ----------------------------------------------------------------------------

CGlxCollectionPluginTags* CGlxCollectionPluginTags::NewL(TAny* aObs)
    {    
    TRACER("CGlxCollectionPluginTags::NewL");

    CGlxCollectionPluginTags* self = new (ELeave) CGlxCollectionPluginTags(
                                static_cast<MMPXCollectionPluginObserver*>(aObs));
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }
    
    
// ----------------------------------------------------------------------------
// Destructor
// ----------------------------------------------------------------------------
//
 CGlxCollectionPluginTags::~CGlxCollectionPluginTags()
    {
    //Do Nothing
    }
 	
 	
// ----------------------------------------------------------------------------
// Constructor
// ----------------------------------------------------------------------------
void CGlxCollectionPluginTags::ConstructL()
    {            
    TRACER("CGlxCollectionPluginTags::ConstructL");

    // iDataSource - @owner is CGlxCollectionPluginBase
    iDataSource = MGlxDataSource::OpenDataSourceL(KGlxDefaultDataSourceUid, *this);     
    }
    
    
// ----------------------------------------------------------------------------
//  Constructor
// ----------------------------------------------------------------------------

CGlxCollectionPluginTags::CGlxCollectionPluginTags(
    MMPXCollectionPluginObserver* aObs)
    {
    iObs = aObs;
    }


// ----------------------------------------------------------------------------
// Add Additional attributes
// ----------------------------------------------------------------------------

void CGlxCollectionPluginTags::CpiAttributeAdditionalAttributesL(
				const TMPXAttribute& aCpiAttribute, RArray<TMPXAttribute>& aAttributeArray)
	{
    TRACER("CGlxCollectionPluginTags::CpiAttributeAdditionalAttributesL");  
    // Only need to process KGlxMediaCollectionPluginSpecificSubTitle here as all
    // the others are reading straight from resource files
    // KGlxMediaCollectionPluginSpecificSubTitle requires a usage count
	if (aCpiAttribute == KGlxMediaCollectionPluginSpecificSubTitle)
	    {
	    // need to add the usage count. but check first if it is already present
	    TInt attrCount = aAttributeArray.Count();
	    TBool found = EFalse;
	    
	    GLX_DEBUG1("CGlxCollectionPluginTags::CpiAttributeAdditionalAttributes-AttributesCount");  
	    
	    for ( TInt index = 0 ; index < attrCount ; index++)
	        {
	        if (aAttributeArray[index] == KMPXMediaGeneralCount)
	            {
	            found = ETrue;
	            break;
	            }
	        }
	        
	    if (!found)
	        {
	        aAttributeArray.AppendL(KMPXMediaGeneralCount);
	        }
	    }
	}


// ----------------------------------------------------------------------------
// Modify the response
// ----------------------------------------------------------------------------

void CGlxCollectionPluginTags::HandleCpiAttributeResponseL(
        CMPXMedia* aResponse, TArray<TMPXAttribute> aCpiAttributes, TArray<
                TGlxMediaId> aMediaIds)
    {
    TRACER("CGlxCollectionPluginTags::HandleCpiAttributeResponseL");
    const TInt mediaIdCount = aMediaIds.Count();

    switch (mediaIdCount)
        {
        case 0:
            User::Leave(KErrNotSupported);
            break;

        case 1:
            GLX_LOG_INFO("CGlxCollectionPluginTags::HandleCpiAttributeResponseL-MediaID");

            HandleCpiAttributeResponseL(aResponse, aCpiAttributes,
                    aMediaIds[0]);
            break;

        default:
            {
            // We have an array of CMPXMedia items

            if (TGlxMediaId(KGlxCollectionRootId) == aMediaIds[0])
                {
                User::Leave(KErrNotSupported);
                }

            CMPXMediaArray* mediaArray = aResponse->ValueCObjectL<
                    CMPXMediaArray> (KMPXMediaArrayContents);
            CleanupStack::PushL(mediaArray);

            const TInt arrayCount = mediaArray->Count();

            // Sanity check
            if (arrayCount != mediaIdCount)
                {
                User::Leave(KErrArgument);
                }

            for (TInt index = 0; index < arrayCount; index++)
                {
                HandleCpiAttributeResponseL((*mediaArray)[index],
                        aCpiAttributes, aMediaIds[index]);
                }
            aResponse->SetCObjectValueL(KMPXMediaArrayContents, mediaArray);
            CleanupStack::PopAndDestroy(mediaArray);
            }
            break;
        }
    }
	
	
// ----------------------------------------------------------------------------
// Modify the response
// ----------------------------------------------------------------------------	

void CGlxCollectionPluginTags::HandleCpiAttributeResponseL(CMPXMedia* aResponse,
			 TArray<TMPXAttribute> aCpiAttributes, TGlxMediaId aMediaId)
    {
    
    TRACER("CGlxCollectionPluginTags::HandleCpiAttributeResponseL-Enter"); 
    const TInt KDateBufferPadding = 10; 

    const TInt attribCount = aCpiAttributes.Count();
	
    GLX_LOG_INFO("CGlxCollectionPluginTags::HandleCpiAttributeResponseL-Attributes created");
	
	for (TInt index = 0; index < attribCount ; index++)
	    {
	    const TMPXAttribute attr = aCpiAttributes[index];
	    
	    if (attr == KGlxMediaCollectionPluginSpecificSubTitle)
	        {
            GLX_LOG_INFO("CGlxCollectionPluginTags::HandleCpiAttributeResponseL-Subtitle");
	        
	        if (!aResponse->IsSupported(KMPXMediaGeneralCount))
	            {
	            User::Leave(KErrNotSupported);
	            }
            else
                {
                TInt usageCount = aResponse->ValueTObjectL<TInt>(KMPXMediaGeneralCount);
                HBufC* tempTitle = NULL;
                
                if (TGlxMediaId(KGlxCollectionRootId) == aMediaId)
                	{
                	if(0 == usageCount)
                		{
                    	tempTitle = LoadLocalizedStringLC(KResourceFile, 
                    			R_TAG_SUB_TITLE_NO_ITEMS);                    	
                    	// Set the title in the response.
                		aResponse->SetTextValueL(attr, *tempTitle);  
                		CleanupStack::PopAndDestroy(tempTitle);
                		continue;  
                		}
                	else if (1 == usageCount)
                    	{
                    	tempTitle = LoadLocalizedStringLC(KResourceFile,
                   			 R_TAG_SUB_TITLE_SINGLE);
                        aResponse->SetTextValueL(attr, *tempTitle);  
                        CleanupStack::PopAndDestroy(tempTitle);
                        continue;
                    	}
                    else 
                    	{
                    	tempTitle = LoadLocalizedStringLC(KResourceFile,
                   			 R_TAG_SUB_TITLE_MULTI);
                    	}
                	}
                else
                	{
                	if(0 == usageCount)
                		{
                    	tempTitle = LoadLocalizedStringLC(KResourceFile, 
                    			R_TAG_SUB_TITLE_NO_ITEMS);                    	
                    	// Set the title in the response.
                		aResponse->SetTextValueL(attr, *tempTitle);  
                		CleanupStack::PopAndDestroy(tempTitle);
                		continue;  
                		}
                	else if (1 == usageCount)
                		{
                		tempTitle = LoadLocalizedStringLC(KResourceFile,
                   			 R_TAG_ITEM_SUB_TITLE_SINGLE);
                        aResponse->SetTextValueL(attr, *tempTitle);  
                        CleanupStack::PopAndDestroy(tempTitle);
                        continue;
                		}
                    else
                        {
                        tempTitle = LoadLocalizedStringLC(KResourceFile,
                        			 R_TAG_ITEM_SUB_TITLE_MULTI);
                        }
                    }
                TPtr formatString = tempTitle->Des();
                
                // Now create a buffer that will contain the result. 
                // needs to be length of format string plus a few 
                // extra for the number
                HBufC* title = HBufC::NewLC(formatString.Length() + KDateBufferPadding);
                TPtr ptr = title->Des();
                StringLoader::Format(ptr, formatString, -1, usageCount);
                
                // Set the title in the response.
                aResponse->SetTextValueL(attr, *title);    

                CleanupStack::PopAndDestroy(title);
                CleanupStack::PopAndDestroy(tempTitle);
                }
	        }
	    else if (attr == KGlxMediaCollectionPluginSpecificSelectMediaPopupTitle)
	        {
            GLX_LOG_INFO("CGlxCollectionPluginTags::HandleCpiAttributeResponseL-Popup Title");
	        
	        HBufC* title = LoadLocalizedStringLC(KResourceFile, R_TAG_POPUP_TITLE);
            aResponse->SetTextValueL(attr, *title);  
            CleanupStack::PopAndDestroy(title);
            
	        }
	    else if (attr == KGlxMediaCollectionPluginSpecificNewMediaItemTitle)
	        {
            GLX_LOG_INFO("CGlxCollectionPluginTags::HandleCpiAttributeResponseL-Mediaitem");
	        
	        HBufC* title = LoadLocalizedStringLC(KResourceFile, R_TAG_ITEM_TITLE);
            aResponse->SetTextValueL(attr, *title);  
            CleanupStack::PopAndDestroy(title);
            
	        }
	        
	    else if (attr == KGlxMediaCollectionPluginSpecificDefaultMediaTitle)
	        {
            GLX_LOG_INFO("CGlxCollectionPluginTags::HandleCpiAttributeResponseL-Defualt mediatitle");
	        
	        HBufC* title = LoadLocalizedStringLC(KResourceFile, R_TAG_DEFAULT_TITLE);
            aResponse->SetTextValueL(attr, *title);  
            CleanupStack::PopAndDestroy(title);
            
	        }
	    else if (attr == KMPXMediaGeneralTitle)
	        {
            GLX_LOG_INFO("CGlxCollectionPluginTags::HandleCpiAttributeResponseL-Attr Title");
	        
	        HBufC* title = LoadLocalizedStringLC(KResourceFile, R_TAG_GENERAL_TITLE);
            aResponse->SetTextValueL(attr, *title);  
            CleanupStack::PopAndDestroy(title); 
	        }
	    }
    }

// ----------------------------------------------------------------------------
// Ignore the Updated Message
// ----------------------------------------------------------------------------	
TBool CGlxCollectionPluginTags::IsUpdateMessageIgnored(CMPXMessage& /*aMessage*/)
	{
	TRACER("CGlxCollectionPluginTags::IsUpdateMessageIgnored");  
	TBool ignore = EFalse;
	return ignore;
	}

// ----------------------------------------------------------------------------
// Set the filter Properties
// ----------------------------------------------------------------------------	

TGlxFilterProperties CGlxCollectionPluginTags::DefaultFilter(TInt aLevel)
    {
    TRACER("CGlxCollectionPluginTags::DefaultFilter");
    __ASSERT_DEBUG(( (aLevel == KGlxCollectionRootLevel) 
                    || (aLevel == KGlxCollectionTagLevel)
                    || (aLevel == KGlxCollectionTagContentsLevel) 
                    || (aLevel == KGlxCollectionTagFSContentsLevel)),
                    Panic(EGlxPanicInvalidPathLevel));
    TGlxFilterProperties filterProperties;
    filterProperties.iSortDirection = EGlxFilterSortDirectionAscending;
    switch(aLevel)
        {
        case KGlxCollectionRootLevel:
        case KGlxCollectionTagLevel: 
            {
            filterProperties.iSortOrder = EGlxFilterSortOrderAlphabetical;
            filterProperties.iItemType = EGlxFilterTag;
            break;
            }
        case KGlxCollectionTagContentsLevel:
	        {
        	filterProperties.iSortDirection = EGlxFilterSortDirectionDescending;
	        }
        case KGlxCollectionTagFSContentsLevel:
            {
            filterProperties.iSortOrder = EGlxFilterSortOrderCaptureDate;
            break;
            }
        }
    return filterProperties;
    }
    
//End of File