/*
* Copyright (c) 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:  A class for creating country and city tags for media files
*
*/

#include "ctagcreator.h"
#include "locationmanagerdebug.h"

#include "mdccommon.h"
#include "mdeobjectdef.h"
#include "mdepropertydef.h"
#include "mderelation.h"
#include "mdequery.h"
#include "mdeconstants.h"

using namespace MdeConstants;

_LIT ( KCountry, "country:");   // country:finland
_LIT ( KCity, "city:");         // city:helsinki|country:finland
_LIT ( KSeparator, "|" );       // Separator for city tag. Separate city and country.

// --------------------------------------------------------------------------
// CTagCreator::NewL
// --------------------------------------------------------------------------
//
EXPORT_C CTagCreator* CTagCreator::NewL( )
    {
    LOG( "CTagCreator::NewL(), begin" );
    CTagCreator* self = new (ELeave) CTagCreator( );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    LOG( "CTagCreator::NewL(), end" );
    return self;
    }
        
// --------------------------------------------------------------------------
// CTagCreator::CTagCreator
// --------------------------------------------------------------------------
//  
CTagCreator::CTagCreator(  ) 
    {

    }

// --------------------------------------------------------------------------
// CTagCreator::ConstructL
// --------------------------------------------------------------------------
//    
void CTagCreator::ConstructL()
    {
    
    }
    
// --------------------------------------------------------------------------
// CTagCreator::~CTagCreator
// --------------------------------------------------------------------------
//    
CTagCreator::~CTagCreator()
    {
  		
    }

// --------------------------------------------------------------------------
// CTagCreator::SetMdeSession()
// --------------------------------------------------------------------------
//
EXPORT_C void CTagCreator::SetSession(CMdESession* aSession)
    {
    iMdeSession = aSession;
    }

// ---------------------------------------------------------------------------
// CTagCreator::CreateTagForCountryL() 
// ---------------------------------------------------------------------------
//
void CTagCreator::CreateTagForCountryL( const TPtrC& aCountry, 
                        TItemId& aCountryTagId )
    {
    LOG( "CTagCreator::CreateTagForCountryL - begin" );
    
    // Crete new string for uri, -> country:India.
    TUint totalLength = ( aCountry.Length() + KCountry().Length() );
    HBufC* buf = HBufC::NewLC( totalLength );
    TPtr uriPtr = buf->Des();
    _LIT(KCountryUriFormat, "%S%S");
    uriPtr.Format(KCountryUriFormat, &(KCountry()), &aCountry); 
    
    // Check if there is allready tag for current country.
    aCountryTagId = TagExistsL( uriPtr );
       
    if( !aCountryTagId )
	   {
	   // No tag, create tag for country.
	   aCountryTagId = CreateTagL( aCountry, uriPtr, MdeConstants::Tag::ESystemDefineCountryTags);
	   }  
      
    CleanupStack::PopAndDestroy( buf );
    
    LOG( "CTagCreator::CreateTagForCountryL - end" );
    }

// ---------------------------------------------------------------------------
// CTagCreator::CreateTagForCityL() 
// ---------------------------------------------------------------------------
//
void CTagCreator::CreateTagForCityL( const TPtrC& aCountry, const TPtrC& aCity, TItemId& aCityTagId )
    {
    LOG( "CTagCreator::CreateTagForCityL - begin" );

    // Crete new string for uri, -> city:bangalore|country:india
    TUint totalLength = ( aCity.Length() + KCity.iTypeLength +
        aCountry.Length() + KCountry.iTypeLength + KSeparator.iTypeLength );
    
    HBufC* buf = HBufC::NewLC( totalLength );
    TPtr uriPtr = buf->Des();
    _LIT(KCityCountryUriFormat, "%S%S%S%S%S");
    uriPtr.Format(KCityCountryUriFormat,
                    &(KCity()),
                    &aCity,
                    &(KSeparator()),
                    &(KCountry()),
                    &aCountry);
        
    // Check if there is allready tag for current city.
    aCityTagId = TagExistsL( uriPtr );
	
	if( !aCityTagId )
		{
		// No tag, create tag for city.
		aCityTagId = CreateTagL( aCity, uriPtr, MdeConstants::Tag::ESystemDefineCityTags);
		}
    
    CleanupStack::PopAndDestroy( buf );
 
    LOG( "CTagCreator::CreateTagForCityL - end" );
    }

// ---------------------------------------------------------------------------
// CTagCreator::CreateTagL 
// ---------------------------------------------------------------------------
//
TUint32 CTagCreator::CreateTagL( const TPtrC& aTitle, 
        const TPtrC& aUri,
        MdeConstants::Tag::TTagType aTagType)
    {
    LOG( "CTagCreator::CreateTagL - begin" );

    CMdENamespaceDef& defaultNamespace = iMdeSession->GetDefaultNamespaceDefL();
    // Create tag object.
    CMdEObjectDef& tagObjectDef = defaultNamespace.GetObjectDefL( Tag::KTagObject );

	CMdEObject* tagObject = NULL;
    tagObject = iMdeSession->NewObjectLC( tagObjectDef, aUri );
	
	// Type defs.
	CMdEPropertyDef& creationDef = tagObjectDef.GetPropertyDefL(
		Object::KCreationDateProperty );
	CMdEPropertyDef& modifiedDef = tagObjectDef.GetPropertyDefL(
		Object::KLastModifiedDateProperty );
	CMdEPropertyDef& sizeDef = tagObjectDef.GetPropertyDefL(
		Object::KSizeProperty );
	CMdEPropertyDef& itemTypeDef = tagObjectDef.GetPropertyDefL(
		Object::KItemTypeProperty );
	CMdEPropertyDef& titleDef = tagObjectDef.GetPropertyDefL(
		Object::KTitleProperty );
	
	// Set propertys.
	TTime universalTime;
    universalTime.UniversalTime(); 

    // Creation time.
	tagObject->AddTimePropertyL( creationDef, universalTime );   

    // Modification time.
	tagObject->AddTimePropertyL( modifiedDef, universalTime );

    // Size 
	tagObject->AddUint32PropertyL( sizeDef, aTagType); 
	
	// ItemType.
	tagObject->AddTextPropertyL( itemTypeDef, Tag::KTagItemType );
	
	// Title, for country.
	if ( aTitle.Length() > 0 )
	    {
	    tagObject->AddTextPropertyL( titleDef, aTitle ); // Add title
	    }
	
	// Finally add to database.
	TItemId itemId = iMdeSession->AddObjectL( *tagObject );
    
    CleanupStack::PopAndDestroy( tagObject );
    
    LOG( "CTagCreator::CreateTagL - end" );
    
    return itemId;
    }

// ---------------------------------------------------------------------------
// CTagCreator::TagExistsL 
// ---------------------------------------------------------------------------
//
TUint32 CTagCreator::TagExistsL( const TPtrC& aUri  )
    {
    LOG( "CTagCreator::TagExistsL - begin" );
  
    CMdEObject* mdeObject = NULL;
    mdeObject = iMdeSession->GetObjectL( aUri ) ; // Just to find out if it exists.
    
    if( mdeObject )
        {
        LOG( "CTagCreator::TagExistsL - returning object id" );
        return mdeObject->Id();
        }
    else
        {
        LOG( "CTagCreator::TagExistsL - No object, return 0" );
        return 0;
        } 
    }
    
// ---------------------------------------------------------------------------
// CGeoTagger::AttachTagsL 
// Create relationship to country and city tag
// ---------------------------------------------------------------------------
//
EXPORT_C void CTagCreator::AttachTagsL( const TUint32 aObjectId, const TItemId aCountryTagId, 
                             const TItemId aCityTagId )
    {
    LOG( "CGeoTagger::AttachTagsL" );
    CMdENamespaceDef& defaultNamespace = iMdeSession->GetDefaultNamespaceDefL();
    // contains relation definition
    CMdERelationDef& containsRelDef = defaultNamespace.GetRelationDefL(
        Relations::KContains );
    
    // Create relation between country tag and media object (image/video).
    CMdERelation* relationObject = NULL;
    if ( aCountryTagId )
        {
        relationObject = iMdeSession->NewRelationLC ( containsRelDef,
                aObjectId, aCountryTagId, 0 );
        
        if ( !relationObject )
            {
            LOG( "CGeoTagger::AttachTagsL - Couldn't create relation object!" );
            User::Leave ( KErrBadHandle );
            }
        
        iMdeSession->AddRelationL( *relationObject );
            
        CleanupStack::PopAndDestroy( relationObject );
        } 
    
    // Create relation between city tag and media object (image/video). 
    if ( aCityTagId )
        {
        relationObject = iMdeSession->NewRelationLC ( containsRelDef,
                    aObjectId, aCityTagId, 0 );
        
        if ( !relationObject)
            {
            LOG( "CGeoTagger::AttachTagsL - Couldn't create relation object!" );
            User::Leave ( KErrBadHandle );
            }
        
        iMdeSession->AddRelationL( *relationObject );
                
        CleanupStack::PopAndDestroy( relationObject );
        }      

    LOG( "CGeoTagger::AttachTagsL - end" );
    }

// ---------------------------------------------------------------------------
// CGeoTagger::CreateLocationTagsL 
// Create country and city tags
// ---------------------------------------------------------------------------
//
EXPORT_C void CTagCreator::CreateLocationTagsL( const TPtrC& aCountry, TItemId& aCountryTagId, 
                                               const TPtrC& aCity, TItemId& aCityTagId)
	{        
	LOG( "CGeoTagger::CreateLocationTagsL" );
    if( aCountry.Length() > 0 )
        {
        CreateTagForCountryL( aCountry, aCountryTagId );
        } 
                             
    if( aCity.Length() > 0 )
        {
        CreateTagForCityL( aCountry, aCity, aCityTagId );
        }
	} 
   
// End of file