/*

* 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 "cimconvertcharconv.h"

#include "cimconvertheader.h"

#include <miutconv.h>            // CharConv 

#include <flogger.h>

#include <e32svr.h>

#include <e32base.h>

#include <imcvcodc.h>

#include <f32file.h>                 

#include <UiklafInternalCRKeys.h>

// #include <telconfigcrkeys.h>

#include <centralrepository.h>

#include <CoreApplicationUIsSDKCRKeys.h>

#include <data_caging_path_literals.hrh>

#include "telconfigcrkeys.h"

#include "mmsgenutils.h"

#include "MmsEnginePrivateCRKeys.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

#ifdef _DEBUG

const TInt KLogBufferLength = 256;

_LIT( KLogDir, "mmsc" );

_LIT( KLogFile, "mmsc.txt" );

#endif

const TUint KExtraSpaceForConversion10 = 10;

const TUint KExtraSpaceForConversion30 = 30;

// 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*/ )

    {

    return KErrNone;

    }

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

// 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*/ )

    {

    }

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

// TMmsGenUtils::GenerateAddress

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

//

EXPORT_C HBufC* TMmsGenUtils::GenerateAddressL(

    const TDesC& aRealAddress,

    const TDesC& aAlias,

    const TDesC& aOpen,

    const TDesC& aClose )

    {

    TInt sepaLen1 = aOpen.Length();

    TInt sepaLen2 = aClose.Length();

    TInt length = aRealAddress.Length() + aAlias.Length() + sepaLen1 + sepaLen2;

    HBufC* buf = HBufC::NewL( length );

    buf->Des().Copy( aAlias );

    buf->Des().Append( aOpen );

    buf->Des().Append( aRealAddress );

    buf->Des().Append( aClose );

    return buf;

    }

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

// TMmsGenUtils::GetDescriptionL

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

//

EXPORT_C void TMmsGenUtils::GetDescriptionL( 

    RFs& aFs,

    const TDesC& aPath,

    TInt aFileSize,

    TPtrC8 aMimetype,

    TInt aCharSet,

    TDes& aDescription )

    {

    TInt fileSize = aFileSize;  // file size in characters

    TInt error = KErrNone;

    // set empty description if we cannot get anything

    aDescription = TPtrC();

    // No subject set, so we have to 

    // find the first text/plain attachment.

    // Update iDescription if necessary 

    if ( aMimetype.CompareF( KMmsTextPlain ))

        {

        // no description available

        return;

        }

    TInt outLength = aDescription.MaxLength();

    // Open the attachment file

    RFileReadStream reader;

    reader.PushL(); 

    error = reader.Open( aFs, 

        aPath, 

        EFileShareReadersOnly );

    if ( error != KErrNone )

        {

        CleanupStack::PopAndDestroy( &reader );  //reader

        // cannot open file, cannot get description

        return;

        }

    TInt firstSize = 0;

    if ( TUint( aCharSet ) == KMmsIso10646Ucs2 )

       {                    

       // Read the content

       TUint16 word = 0;

       TBool bom = EFalse;

       TBool nativeEndian = EFalse;

       // Check if first character is BOM and if so, then what kind it is.

       TRAP ( error, {word = reader.ReadUint16L();}); 

       if ( error != KErrNone )

           {

           CleanupStack::PopAndDestroy( &reader ); //reader

           return; // no description available        

           }