/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QApplication>

#include <QtTest/QtTest>

#include <QDebug>

#include <QEventLoop>

#include <QTimer>

#include "qmessagemanager.h"

#include "qmessage.h"

#ifdef Q_OS_SYMBIAN

#include <msvapi.h>

#include <msvids.h>  // KMsvGlobalInBoxIndexEntryId

#include <mtclreg.h>  // CClientMtmRegistry

#include <smsclnt.h>  // CSmsClientMtm

#include <smut.h>  // KUidMsgTypeSMS

#include <txtrich.h>  // CRichText

#include <cemailaccounts.h>

#include <mmsconst.h>

#include <miutmsg.h>

#include <msvfind.h>  

#include <impcmtm.h>

#include <mmsclient.h>

#include <etelmm.h>

#include <msvapi.h>

#include <iapprefs.h>

#include <smtcmtm.h>

#include <smuthdr.h>

#endif

#include <qdebug.h>

QTM_USE_NAMESPACE

class OsNative;

#if defined(Q_OS_SYMBIAN)

class OsNative : public MMsvSessionObserver {

public:

  OsNative()

  {    

  };

  void HandleSessionEventL(TMsvSessionEvent aEvent, TAny* aArg1, TAny* aArg2, TAny* aArg3) { };

  void getFolders(RArray<TMsvId> &folders);

  int countMessages();

  void deleteAllMessages();

  void createMailAccountL();

  void printAccounts();

  void deleteAccounts();

  void deleteAllFolders();

  TInt createFolder(TPtrC name);

  TMsvId makeSMS(TMsvId folder);

  TMsvId makeIMAP4(TMsvId folder);

  CMsvSession *iSession;

  CClientMtmRegistry *iMtmRegistry;

  CSmsClientMtm *iSmsMtm;

  CImap4ClientMtm *iImap4Mtm;

  CSmtpClientMtm *iSmtpMtm;

  CMmsClientMtm *iMmsMtm;

  RArray<TMsvId> iFolders;

  RArray<TMsvId> iNewMsgs;

  TMsvId iMsvImapService;

  TMsvId iMsvSmtpService;

};

TMsvId OsNative::makeSMS(TMsvId folder){    

    TBuf<10> aAddress(_L("Nokia"));

    TBuf<20> aDescription(_L("Important Message"));

    _LIT(KTxt1,"Hi phone owner, how r u?");

    TBuf<150> iMessage; 

    iMessage.Copy(KTxt1);

    iSmsMtm->SwitchCurrentEntryL(folder); //inbox

// Clean phones without a SIM doesn't have a default service

//    TMsvId serviceId;

//    TRAPD(err, serviceId = iSmsMtm->DefaultServiceL());

//    if(err) {

//      qDebug() << "No default service";

//      return 0;

//    }

    TRAPD(err1, iSmsMtm->SwitchCurrentEntryL( folder ));

    if(err1){

        qDebug() << "Failed to create SMS1: " << err1;

        return 0;

    }

    TRAPD(err, iSmsMtm->CreateMessageL( iSmsMtm->ServiceId() )); 

    //TRAPD(err, iSmsMtm->CreateMessageL(KMsvLocalServiceIndexEntryId));

    if(err){

        qDebug() << "Failed to create SMS: " << err;

        return 0;

    }

    CSmsHeader& iHeader = iSmsMtm->SmsHeader();

    TRAP(err, iHeader.SetFromAddressL(aAddress));

    if(err)

      qDebug() << "Failed to set from address: " << err;    

    CRichText& body = iSmsMtm->Body();

    body.Reset();

    TRAP(err, body.InsertL(0, iMessage));

    if(err)

      qDebug() << "Failed to add body: " << err;

    TMsvEntry entry = iSmsMtm->Entry().Entry();

    entry.SetInPreparation(EFalse);

    entry.SetVisible(ETrue);

    entry.iDate.HomeTime();

    entry.iDescription.Set(aDescription);

    entry.iDetails.Set(aAddress);

    entry.SetUnread(ETrue);

    TRAP(err,

        iSmsMtm->Entry().ChangeL(entry);

        iSmsMtm->SaveMessageL();

        );

    if(err)

      qDebug() << "Failed to save changes: " << err;

   return entry.Id();

}

void OsNative::printAccounts(){

  RArray<TPopAccount> aPop;

  RArray<TImapAccount> aImap;

  RArray<TSmtpAccount> aSmtp;

  CEmailAccounts* account = CEmailAccounts::NewLC();

  TRAPD(err, 

      account->GetPopAccountsL(aPop);

      account->GetImapAccountsL(aImap);

      account->GetSmtpAccountsL(aSmtp);

      );

  if(err){

    qDebug()<< "Can't get all accounts";

  }

  for(int i = 0; i < aPop.Count(); i++){

    QString name  = QString::fromUtf16(aPop[i].iPopAccountName.Ptr(), aPop[i].iPopAccountName.Length());

    qDebug() << "Pop account: " << name << hex << " SMTP: " << aPop[i].iSmtpService;

//    account->DeletePopAccountL(aPop[i]);

  }

  for(int i = 0; i < aImap.Count(); i++){

    QString name  = QString::fromUtf16(aImap[i].iImapAccountName.Ptr(), aImap[i].iImapAccountName.Length());

    qDebug() << "Imap account: " << name << hex << " SMTP: " << aImap[i].iSmtpService;

//    account->DeleteImapAccountL(aImap[i]);

  }

  for(int i = 0; i < aSmtp.Count(); i++){

    QString name  = QString::fromUtf16(aSmtp[i].iSmtpAccountName.Ptr(), aSmtp[i].iSmtpAccountName.Length());

    qDebug() << "SMTP account: " << name << hex << " Related: " << aSmtp[i].iRelatedService;

//    account->DeleteSmtpAccountL(aSmtp[i]);

  }

  aPop.Close();

  aSmtp.Close();

  aImap.Close();

  CleanupStack::PopAndDestroy(account);

}

void OsNative::deleteAccounts(){

  RArray<TPopAccount> aPop;

  RArray<TImapAccount> aImap;

  RArray<TSmtpAccount> aSmtp;

  CEmailAccounts* account = CEmailAccounts::NewLC();

  TRAPD(err, 

      account->GetPopAccountsL(aPop);

      account->GetImapAccountsL(aImap);

      account->GetSmtpAccountsL(aSmtp);

      );

  if(err){

    qDebug()<< "Can't get all accounts";

  }

  for(int i = 0; i < aPop.Count(); i++){

    QString name  = QString::fromUtf16(aPop[i].iPopAccountName.Ptr(), aPop[i].iPopAccountName.Size());

    if(name.startsWith("BMTestAccount"))

      account->DeletePopAccountL(aPop[i]);

  }

  for(int i = 0; i < aImap.Count(); i++){

    QString name  = QString::fromUtf16(aImap[i].iImapAccountName.Ptr(), aImap[i].iImapAccountName.Size());

    if(name.startsWith("BMTestAccount"))

      account->DeleteImapAccountL(aImap[i]);

  }

  for(int i = 0; i < aSmtp.Count(); i++){

    QString name  = QString::fromUtf16(aSmtp[i].iSmtpAccountName.Ptr(), aSmtp[i].iSmtpAccountName.Size());

    if(name.startsWith("BMTestAccount"))

      account->DeleteSmtpAccountL(aSmtp[i]);

  }

  aPop.Close();

  aSmtp.Close();

  aImap.Close();

  CleanupStack::PopAndDestroy(account);

}

TMsvId OsNative::makeIMAP4(TMsvId folder){

  // create a new object to access an existing entry

  CMsvEntry* msvEntry = CMsvEntry::NewL(*iSession, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());

  CleanupStack::PushL(msvEntry); // 1

  msvEntry->SetEntryL(folder);

  // mtm takes ownership of entry context     

  CleanupStack::Pop(msvEntry); // 0

  iSmtpMtm->SetCurrentEntryL(msvEntry);

  // create a new message

  TMsvId defaultServiceId(0);

  defaultServiceId = iSmtpMtm->DefaultServiceL();

  CMsvEntry *pE = iSession->GetEntryL(defaultServiceId);

  CleanupStack::PushL(pE);  

  QString name = QString::fromUtf16(pE->Entry().iDetails.Ptr(), pE->Entry().iDetails.Length());

  CleanupStack::PopAndDestroy(pE);

  iSmtpMtm->CreateMessageL(defaultServiceId);

  // set subject

  iSmtpMtm->SetSubjectL( _L("Test Message") );

  // set body

  iSmtpMtm->Body().Reset();

  iSmtpMtm->Body().InsertL(0, _L("This is the text body")); 

  // get the entry of the message

  TMsvEntry messageEntry = iSmtpMtm->Entry().Entry();

//      AddSenderToMtmAddresseeL(*iSmtpMtm, parameters, ETrue );

//      SetSenderToEntryDetails(messageEntry, parameters, ETrue);

  messageEntry.iMtm = KUidMsgTypeIMAP4;  // or any other than KUidMsgTypeSMTP to display 'from' field instead of 'to' field 

  // set the description field same as the message subject

  messageEntry.iDescription.Set( _L("test") );  

  messageEntry.iDetails.Set( _L("test subject") );

  // save the changes done above

  iSmtpMtm->Entry().ChangeL(messageEntry);

  // get an access to the message store

  CMsvStore* store = msvEntry->EditStoreL();

  CleanupStack::PushL(store); // 1

  // save the attachments

  // save the changes made to the message store

  store->CommitL();

  CleanupStack::PopAndDestroy(store); // 0 

  // save the message      

  iSmtpMtm->SaveMessageL();

  // final fine tuning

  TMsvEmailEntry temailEntry = static_cast<TMsvEmailEntry>(messageEntry);

  temailEntry.SetMessageFolderType(EFolderTypeUnknown);

  temailEntry.SetDisconnectedOperation(ENoDisconnectedOperations);

  temailEntry.SetEncrypted(EFalse);

  temailEntry.SetSigned(EFalse);

  temailEntry.SetVCard(EFalse);

  temailEntry.SetVCalendar(EFalse);

  temailEntry.SetReceipt(EFalse);

  temailEntry.SetMHTMLEmail(EFalse);

  temailEntry.SetBodyTextComplete(ETrue);

  temailEntry.SetAttachment(EFalse);

  temailEntry.iDate.HomeTime();

  temailEntry.SetVisible(ETrue);

  temailEntry.SetInPreparation(EFalse);

  temailEntry.SetUnread(ETrue);

  temailEntry.SetNew(ETrue);

  temailEntry.SetComplete(ETrue);

  temailEntry.iServiceId = iMsvSmtpService;

  temailEntry.iRelatedId = 0;

  iSmtpMtm->Entry().ChangeL(temailEntry);

  // reset email headers

  CImHeader* header = CImHeader::NewLC(); // 1

  CMsvStore* msvStore = msvEntry->EditStoreL();

  CleanupStack::PushL(msvStore); // 2

  header->RestoreL(*msvStore);

  header->SetSubjectL( _L("test email") );

  header->SetFromL( _L("blah@blah.com") );

  header->SetReceiptAddressL( _L("Foo@bar.com") );

  header->StoreL( *msvStore );

  msvStore->CommitL();

  CleanupStack::PopAndDestroy(2); // msvStore, header // 0

  // id has been generated, store it for being able to delete

  // only entries created with Creator

  TMsvId id = messageEntry.Id();

  return id;

}

void OsNative::deleteAllFolders() {

    RArray<TMsvId> aFolders;

    TRAP_IGNORE(getFolders(aFolders));   

    TMsvSelectionOrdering sort;

    sort.SetSorting(EMsvSortByNone);

    sort.SetShowInvisibleEntries(ETrue);

    for(int i = 0; i < aFolders.Count(); i++) {

        CMsvEntry* inboxContext = CMsvEntry::NewL(*iSession, aFolders[i], sort);                

        CleanupStack::PushL(inboxContext);

        // Get all entries in the folder

        CMsvEntrySelection* entries = inboxContext->ChildrenL();

        CleanupStack::PushL(entries);

        QString desc = QString::fromUtf16(inboxContext->Entry().iDetails.Ptr(), inboxContext->Entry().iDetails.Length());

        for (TInt j = 0; j < entries->Count(); j++) {

            CMsvEntry* pEntry = CMsvEntry::NewL(*iSession, entries->At(j), sort);

            CleanupStack::PushL(pEntry);

            QString desc2 = QString::fromUtf16(pEntry->Entry().iDetails.Ptr(), pEntry->Entry().iDetails.Length());

            const TMsvEntry &entry = pEntry->Entry();            

            if((desc != "My folders" || desc2 == "Templates")) {

              CleanupStack::PopAndDestroy(pEntry);

              continue;

            }

            CleanupStack::PopAndDestroy(pEntry);

            TMsvId id = entries->At(j);

            qDebug() << "Deleting: " << desc << "/" << desc2;

            TRAPD(ierr, iSession->RemoveEntry(id)); // works

            if(ierr){

                qDebug() << "Failed to delete: " << ierr << " " << hex << entries->At(j);

            }            

        }        

        CleanupStack::PopAndDestroy(2, inboxContext);

    }

}

void OsNative::createMailAccountL() {

  CImIAPPreferences* outgoingIAPSet = CImIAPPreferences::NewLC(); // 1

  CImIAPPreferences* incomingIAPSet = CImIAPPreferences::NewLC(); // 2

  CEmailAccounts* account = CEmailAccounts::NewLC(); // 3

  CImImap4Settings* imap4Set = new(ELeave) CImImap4Settings;

  CleanupStack::PushL(imap4Set); // 4

  CImSmtpSettings* smtpSet = new(ELeave) CImSmtpSettings;

  CleanupStack::PushL(smtpSet); // 5

  account->PopulateDefaultSmtpSettingsL(*smtpSet, *outgoingIAPSet);

  account->PopulateDefaultImapSettingsL(*imap4Set, *outgoingIAPSet);

 imap4Set->SetDisconnectedUserMode(ETrue);

 imap4Set->SetSynchronise(EUseLocal);

 imap4Set->SetSubscribe(EUpdateNeither);

 imap4Set->SetAutoSendOnConnect(EFalse);

 imap4Set->SetGetMailOptions(EGetImap4EmailBodyText);

 imap4Set->SetUpdatingSeenFlags(ETrue);

 imap4Set->SetServerAddressL(_L("test.sdfsdf.wer.sadazsdsddf.com"));

 TImapAccount imapAccountId = account->CreateImapAccountL(_L("BMTestAccount"), *imap4Set, *incomingIAPSet, EFalse);

 TSmtpAccount smtpAccountId = account->CreateSmtpAccountL(imapAccountId, *smtpSet, *outgoingIAPSet, EFalse);

 account->SetDefaultSmtpAccountL(smtpAccountId);

 iMsvImapService = imapAccountId.iImapService;

 iMsvSmtpService = smtpAccountId.iSmtpAccountId;

 // Fails with NotSupported 

 //iImap4Mtm->ChangeDefaultServiceL(iMsvImapService);

 // Failed with invalid arg

 // iSmtpMtm->ChangeDefaultServiceL(iMsvSmtpService);

 CleanupStack::PopAndDestroy(5);

}

int OsNative::countMessages() {

    RArray<TMsvId> aFolders;

    int total = 0;

    TRAPD(err, getFolders(aFolders));

    if(err){

        qDebug() << "getFodlers faield: " << err;

        return 0;

    }

    for(int i = 0; i < aFolders.Count(); i++){

        TMsvSelectionOrdering sort;

        sort.SetSorting(EMsvSortByNone);

        sort.SetShowInvisibleEntries(ETrue);

        CMsvEntry* inboxContext = CMsvEntry::NewL(*iSession, 

                aFolders[i], sort);                

        CleanupStack::PushL(inboxContext); // 1

        // Get all entries in the Inbox

        CMsvEntrySelection* entries = inboxContext->ChildrenL();

        CleanupStack::PushL(entries); // 2

        for (TInt i = 0; i < entries->Count(); i++) {              

            TMsvId entryID = entries->At(i);

            const TUid mtm = inboxContext->ChildDataL(entryID).iMtm;

            if (mtm == KUidMsgTypeSMS) {

                total++;

            }

            else if ((mtm == KUidMsgTypeIMAP4) || (mtm == KUidMsgTypeSMTP)) {

                total++;                

            }

            else {

            }           

        }

        CleanupStack::PopAndDestroy(2, inboxContext);

    }

    return total;

}

void OsNative::deleteAllMessages() {

    RArray<TMsvId> aFolders;    

    TRAPD(err, getFolders(aFolders));

    if(err){

        qDebug() << "getFodlers faield: " << err;

        return;

    }

    for(int i = 0; i < aFolders.Count(); i++){

        TMsvSelectionOrdering sort;

        CMsvEntry* inboxContext = CMsvEntry::NewL(*iSession, aFolders[i], sort);                

        CleanupStack::PushL(inboxContext); // 1

        // Get all entries in the Inbox

        CMsvEntrySelection* entries = inboxContext->ChildrenL();

        CleanupStack::PushL(entries); // 2

        for (TInt i = 0; i < entries->Count(); i++) {              

            TMsvId entryID = entries->At(i);        

            const TUid mtm = inboxContext->ChildDataL(entryID).iMtm;

            if ((mtm == KUidMsgTypeSMS) || (mtm == KUidMsgTypeIMAP4) || (mtm == KUidMsgTypeSMTP)) {

                iSession->RemoveEntry(entryID);                

            }

        }

        CleanupStack::PopAndDestroy(2, inboxContext);

    }

}

#define KMsvMyFoldersEntryIdValue 0x1008

const TMsvId KMsvMyFoldersEntryId=KMsvMyFoldersEntryIdValue;

TInt OsNative::createFolder(TPtrC name){

    TMsvId msvServId;                                                                       

    CMsvEntry *entry1 = NULL;                                                                

    CMsvEntry * rootEntry = NULL;                                                           

    CMsvEntry *entryRootService = NULL;                                                     

    TInt newFldrID = 0;                                                                     

    //Get the entry (whatever is passed in)                                                    

    entry1 = iSession->GetEntryL(KMsvMyFoldersEntryIdValue);   

    CleanupStack::PushL(entry1);                                                             

    if (entry1)                                                                              

    {                          

        msvServId = entry1->OwningService();                                                    

        entryRootService = iSession->GetEntryL(msvServId);                            

        CleanupStack::PushL(entryRootService);                                                 

        rootEntry = iSession->GetEntryL(msvServId);                                   

        CleanupStack::PushL(rootEntry);                                                        

        rootEntry->SetEntryL(KMsvMyFoldersEntryIdValue); // set to parent

        TMsvEntry newServiceEntry;                                                             

        newServiceEntry.iDate.HomeTime();

        newServiceEntry.iSize = 0;

        newServiceEntry.iType = KUidMsvFolderEntry;                                            

        newServiceEntry.iMtm = KUidMsvLocalServiceMtm;

//        newServiceEntry.iServiceId = iSmsMtm->ServiceId();

//        newServiceEntry.iServiceId = KMsvLocalServiceIndexEntryId;

        newServiceEntry.iServiceId = iMsvImapService;

        newServiceEntry.iDetails.Set(name);                                             

        newServiceEntry.iDescription.Set(KNullDesC);