/*

* Copyright (c) 2002-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:  

*       Utility methods for UI and engine modules. Provides help for address

*       string parsing, resource files and contact database access.

*       General address format is either

*           alias<real-address>

*       or

*           <real-address>

*       as used in the Client MTM API.

*

*/

// INCLUDE FILES

#include <barsc.h>               // resource file

#include <bautils.h>

#include <miutpars.h>            // e-mail utilities

#include <miutconv.h>            // CharConv 

#include <flogger.h>

#include <e32svr.h>

#include <e32base.h>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <imcvcodc.h>

#else

#include <imcvcodc.h>

#include <cimconvertheader.h>

#endif

#include <f32file.h>                 

#include <UiklafInternalCRKeys.h>

#include <telconfigcrkeys.h>

#include <centralrepository.h>

#include <CoreApplicationUIsSDKCRKeys.h>

#include <data_caging_path_literals.hrh>

#include <MVPbkContactStore.h>

#include <MVPbkContactStoreProperties.h>

#include <MVPbkContactLink.h>

#include <CPbk2StoreConfiguration.h>   // Contact store configuration

#include <contactmatcher.h> // contact match wrapper

#include <CVPbkPhoneNumberMatchStrategy.h>

#include <CVPbkContactLinkArray.h>

#include <CVPbkFieldTypeRefsList.h>

#include <TVPbkFieldVersitProperty.h>

#include <VPbkFieldType.hrh>

#include <MVPbkStoreContactFieldCollection.h>

#include <MVPbkStoreContact.h>

#include <CVPbkContactStoreUriArray.h>

#include <VPbkContactStoreUris.h>

#include <TVPbkContactStoreUriPtr.h>

#include "mmsgenutils.h"

#include "MmsEnginePrivateCRKeys.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

const TInt KLogBufferLength = 256;

#ifdef _DEBUG

_LIT( KLogDir, "mmsc" );

_LIT( KLogFile, "mmsc.txt" );

#endif

const TUint KMinAliasMaxLength = 14;

const TUint KExtraSpaceForConversion10 = 10;

const TUint KExtraSpaceForConversion30 = 30;

const TInt KErrMultipleMatchFound = KErrGeneral;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// ==================== LOCAL FUNCTIONS ====================

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

// Constructor 

//

EXPORT_C TMmsGenUtils::TMmsGenUtils()

    {

    }

// Destructor 

//

// THERE SHOULD NOT BE DESTRUCTOR IN T-CLASS.

// MUST BE REMOVED

EXPORT_C TMmsGenUtils::~TMmsGenUtils()

    {

    }

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

// TMmsGenUtils::AddressTypeAndRealAddress

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

//

EXPORT_C TInt TMmsGenUtils::AddressTypeAndRealAddress(

    const TDesC& aAddress,

    TMmsAddressType& aType,

    TDes& aRealAddress,

    TInt aMaxLength,

    const TDesC& aOpen,

    const TDesC& aClose )

    {

    aRealAddress.Zero();

    aType = EMmsAddressTypeUnknown;

    TPtrC realAddress;

    realAddress.Set( PureAddress( aAddress, aOpen, aClose ) );

    if ( realAddress.Length() > aMaxLength )

        {

        return KErrTooBig;

        }

    if ( IsValidMMSPhoneAddress( realAddress ) )

        {

        aType = EMmsAddressTypeMobile;

        }

    else if ( IsValidEmailAddress( realAddress ) )

        {

        aType = EMmsAddressTypeEmail;

        }

    else

        {

        }

    // we returned earlier if address was too big.

    if ( aType != EMmsAddressTypeUnknown )

        {

        aRealAddress.Copy( realAddress );

        }

    return KErrNone; 

    }

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

// TMmsGenUtils::IsValidAddress

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

//

EXPORT_C TBool TMmsGenUtils::IsValidAddress( 

   const TDesC& aAddress,

   TBool aReal,

   const TDesC& aOpen,

   const TDesC& aClose )

   {

   TPtrC realAddress;

   if ( !aReal)

       {

       realAddress.Set( PureAddress( aAddress, aOpen, aClose ) );

       }

   else

       {

       realAddress.Set ( aAddress );

       }

   if ( !IsValidMMSPhoneAddress( realAddress ) )

       {

       return IsValidEmailAddress( realAddress );

       }

   return ETrue;

   }

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

// TMmsGenUtils::IsValidEmailAddress

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

//          

EXPORT_C TBool TMmsGenUtils::IsValidEmailAddress( 

    const TDesC& aAddress,

    TBool aReal,

    const TDesC& aOpen,

    const TDesC& aClose )

    {

    // Strip off alias part if necessary

    TPtrC realAddress;

    if ( aReal )

      {

      realAddress.Set( aAddress ); 

      }

    else

      {

      realAddress.Set( PureAddress( aAddress, aOpen, aClose ) );

      }

    TImMessageField email;

    return email.ValidInternetEmailAddress( realAddress );

    }

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

// TMmsGenUtils::IsValidMMSPhoneAddress

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

//

EXPORT_C TBool TMmsGenUtils::IsValidMMSPhoneAddress( 

  const TDesC& aAddress,

  TBool aReal,

  const TDesC& aOpen,

  const TDesC& aClose  )

  {

  // global_phone_number = [+] 1*(DIGIT, written-sep)

  // written_sep = ('-')

  // Strip off alias part if necessary

  TPtrC realAddress;

  if ( aReal )

      {

      realAddress.Set( aAddress ); 

      }

  else

      {

      realAddress.Set( PureAddress( aAddress, aOpen, aClose ) );

      }

  TInt length = realAddress.Length();

  if ( length == 0 )

      {

      return EFalse;

      }

  TInt pos = 0;

  TInt ich = realAddress[0];

  TChar ch = ich;

  if ( ch == '+' )

      {

      pos++;

      }

  if ( pos == length )

      {

      return EFalse;

      }

  while ( pos < length )

      {

      ich = realAddress[pos];

      ch = ich;

      ch.Fold(); 

      TInt fch = ch;

        // do not check for fch == '.'

	//Even # and * are valid characters now

        if ( !( ch.IsDigit() || fch == '-' || fch == '#' || fch == '*' ) )

          {

          return EFalse;

          }

      pos++;

      }

  return ETrue;

  }

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

// TMmsGenUtils::Alias

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

//

EXPORT_C TPtrC TMmsGenUtils::Alias( 

    const TDesC& aAddress,

    const TDesC& aOpen,

    const TDesC& aClose )

    {

    // syntax is :

    // <alias><separator1><pure_address><separator2> |

    // <pure_address>

    TInt firstPos = 0;

    TInt lastPos = 0;

    TInt length = aAddress.Length();

    TInt sepaLen1 = aOpen.Length();

    TInt sepaLen2 = aClose.Length();

    TInt firstSeparatorPosition = 0;

    while( firstSeparatorPosition >= 0 )

        {

        firstSeparatorPosition = aAddress.Mid( firstPos ).Find( aOpen );

        if ( firstSeparatorPosition >= 0 )

            {

            firstPos += firstSeparatorPosition + sepaLen1;

            }

        }

    if ( firstPos <= 0 )

        {

        // No alias

        return TPtrC();

        }

    // Search another separator after the first separator from

    lastPos = aAddress.Mid( firstPos ).Find( aClose );

    if ( lastPos == KErrNotFound )

        {

        return TPtrC();

        }

    firstPos -= sepaLen1; // point to first separator    

    if ( lastPos == length - firstPos - sepaLen1 - sepaLen2 )

        {

        // Alias part found

        // remove trailing and leading spaces

        lastPos = firstPos;

        firstPos = 0;

        while ( firstPos < aAddress.Length() &&

            aAddress.Mid( firstPos, 1 ).Compare( KSpace16 ) == 0 )

            {

            // remove leading spaces

            firstPos++;

            }

        while ( lastPos > 0 && aAddress.Mid( lastPos - 1, 1 ).Compare( KSpace16 ) == 0 )

            {

            lastPos--;

            }

        if ( lastPos > firstPos )

            {

            return aAddress.Mid( firstPos, lastPos - firstPos );

            }

        }

    // No alias defined - spaces alone do not count as alias.

    return TPtrC();

    }

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

// TMmsGenUtils::PureAddress

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

//

EXPORT_C TPtrC TMmsGenUtils::PureAddress( 

    const TDesC& aAddress,

    const TDesC& aOpen,

    const TDesC& aClose )

    {

    // syntax is :

    // <alias><separator1><pure_address><separator2> |

    // <pure_address>

    TInt firstPos = 0;

    TInt lastPos = 0;

    TInt length = aAddress.Length();

    TInt sepaLen1 = aOpen.Length();

    TInt sepaLen2 = aClose.Length();

    TInt firstSeparatorPosition = 0;

    while( firstSeparatorPosition >= 0 )

        {

        firstSeparatorPosition = aAddress.Mid( firstPos ).Find( aOpen );

        if ( firstSeparatorPosition >= 0 )

            {

            firstPos += firstSeparatorPosition + sepaLen1;

            }

        }

    if ( firstPos <= 0 )

        {

        // No alias

        return aAddress;

        }

    // Check if the second separator ends the address

    TPtrC last = aAddress.Right( sepaLen2 );

    lastPos = length - sepaLen2;

    if ( !last.Compare( aClose ) )

        {

        // Alias part found

        if ( lastPos > firstPos )

            {

            return aAddress.Mid( firstPos, lastPos - firstPos );

            }

        }

    // No alias defined - return the original string as pure address

    // If syntax is weird, namely 

    // alias <>

    // with nothing between the separators, we return the original string as is

    return aAddress;

    }

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

// TMmsGenUtils::GenerateDetails

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

//

EXPORT_C TInt TMmsGenUtils::GenerateDetails( 

    const TDesC& aAddress,

    TDes& aAlias,

    TInt aMaxLength,

    RFs& aFs ) 

    {

    TInt err = KErrNone;

    // alias search order: Local alias, remote alias, none

    TPtrC realAddress;

    realAddress.Set( PureAddress( aAddress, KSepaOpen, KSepaClose ) );

    TRAP( err, DoGetAliasL( aFs, realAddress, aAlias, aMaxLength ) );

    if ( err != KErrNone || aAlias.Length() == 0 )

        {

        // No alias found from Contact db, see if there is a local alias

        TPtrC myAddress = Alias( aAddress, KSepaOpen, KSepaClose );

        if ( myAddress.Length() > 0 )

            {

            // Alias was found from the address

            aAlias.Copy( myAddress.Left( aMaxLength ) );

            return KErrNone;

            }

        else

            {

            if ( err == KErrNotFound )

                {

                err = KErrNone;

                }

            // just keep the original address

            aAlias.Copy( aAddress.Left( aMaxLength ) );

            }

        }

    return err;

    }

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

// TMmsGenUtils::GetAlias

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

//

EXPORT_C TInt TMmsGenUtils::GetAlias( 

    const TDesC& aAddress,

    TDes& aAlias,

    TInt aMaxLength,

    RFs& aFs )

    {

    TInt err = KErrNone;

    TRAP( err, DoGetAliasL( aFs, aAddress, aAlias, aMaxLength ) );

    if ( err == KErrNotFound )

        {

        err = KErrNone;

        }

    return err;

    }

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

// TMmsGenUtils::GetAliasForAllL

// This function searches aliases for all addresses in a 

// address field by opening the contact db only once for all 

// addresses. This significantly reduces processing time 

// when executing "Create Reply to all" with a lot of addresses

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

// 

EXPORT_C void TMmsGenUtils::GetAliasForAllL(

    const CDesCArray& aAddress,

    CDesCArray& aAlias,

    TInt aMaxLength,

    RFs& aFs )

    {

    if ( aMaxLength <= 0 )

        {

        User::Leave( KErrArgument );

        }

    TUint stack = 0;

    //Let's find the number of digits to match

    TInt digitsToMatch = DigitsToMatch();

    TInt err = KErrNone;

    // Use contact wrapper to open all databases

    CContactMatcher* contactMatcher = OpenAllStoresL( aFs );

    CleanupStack::PushL( contactMatcher );

    stack++;

    HBufC* helpBuffer = HBufC::NewL( aMaxLength );

    CleanupStack::PushL( helpBuffer );

    stack++; 

    TPtr pHelpBuffer = helpBuffer->Des();   

    for ( TInt i = 0; i < aAddress.MdcaCount(); i++  )

        {  

        // We trap these one by one in order to be able

        // to continue to next match in case of error (not found)

        // make sure the alias is empty if nothing found

        pHelpBuffer.Zero();

    	TRAP( err, DoGetAliasL( 

            aAddress.MdcaPoint(i), 

    	    pHelpBuffer, 

    	    aMaxLength, 

    	    *contactMatcher, 

    	    digitsToMatch ) );

        // if alias is not found, we'll have an empty buffer

        // We have to insert it anyway to keep the indexes correct

        // as we have two parallel arrays

        aAlias.InsertL( i, pHelpBuffer );

        }

    // closing is best effort only.    

    TRAP_IGNORE( contactMatcher->CloseStoresL() );

    CleanupStack::PopAndDestroy( stack, contactMatcher );  //contactMatcher, helpBuffer   

    }

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

// TMmsGenUtils::GenerateAddress

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

//

EXPORT_C HBufC* TMmsGenUtils::GenerateAddressL(