/*

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

 *

 */

#include <QVariant>

#include <QList>

#include <xqconversions.h>

#include <xqsettingsmanager.h>

#include <xqcentralrepositoryutils.h>

#include <xqcentralrepositorysearchcriteria.h>

#include <pop3set.h>

#include <imapset.h>

#include <smtpset.h>

#include <iapprefs.h>

#include "ipssettingkeys.h"

#include "nmapiheaders.h"

#include <nmapisettingsmanager.h>

#include "nmapisettingsmanager_p.h"

namespace EmailClientApi

{

NmApiSettingsManagerPrivate::NmApiSettingsManagerPrivate(const quint64 mailboxId)

    : mAccount(0),

    mPop3Settings(0),

    mImap4Settings(0),

    mSmtpSettings(0),

    mMailboxOffset(-1),

    mMailboxId(0)

{

    QT_TRAP_THROWING(mAccount = CEmailAccounts::NewL());

    mMailboxId = (quint32)mailboxId;

    mQSettingsManager = new XQSettingsManager();

    Q_CHECK_PTR(mQSettingsManager);

    checkAccountType();

    QT_TRAP_THROWING(initAccountL());

    calculateMailboxOffset();

}

NmApiSettingsManagerPrivate::~NmApiSettingsManagerPrivate()

{

    delete mPop3Settings;

    delete mImap4Settings;

    delete mSmtpSettings;

    delete mQSettingsManager;

    delete mAccount;

}

/*!

 Loads QMail specific settings.

 \param mailboxId which settings are returned

 \param data consists of keys and values of settings.

 \return bool <true> when the setting items were found otherwise <false>.

 */

bool NmApiSettingsManagerPrivate::load(quint64 mailboxId, NmApiMailboxSettingsData &data)

{

	mMailboxId = mailboxId;

    return (readSetting(data) && readCenRepSetting(data));

}

/*!

 Saves QMail specific settings.

 \param data consists of keys and values of settings.

 \return bool <true> when the setting items were successfully saved otherwise <false>.

 */

bool NmApiSettingsManagerPrivate::save(const NmApiMailboxSettingsData &data)

{

    TInt err(KErrNone);

    TRAP(err, writeSettingL(data));

    return (!err && writeSettingToCenRep(data));

}

/*!

 Finds and returns the SMTP specific setting.

 \param settingItem SettingItem enum of the setting to return

 \param QVariant SettingValue of the found setting value.

 \return bool <true> when the setting item was found otherwise <false>.

 */

bool NmApiSettingsManagerPrivate::readSetting(NmApiMailboxSettingsData &data)

{

    if (mMailboxType == NmApiMailboxTypePop) {

        data.setValue(IncomingLoginName, XQConversions::s60Desc8ToQString(mPop3Settings->LoginName()));

        data.setValue(IncomingPassword, XQConversions::s60Desc8ToQString(mPop3Settings->Password()));

        data.setValue(MailboxName, XQConversions::s60DescToQString(mPop3Account.iPopAccountName));

        data.setValue(IncomingMailServer, XQConversions::s60DescToQString(mPop3Settings->ServerAddress()));

#if (defined SYMBIAN_EMAIL_CAPABILITY_SUPPORT)

        data.setValue(IncomingMailUsesAuthentication, mPop3Settings->POP3Auth());

#endif

        data.setValue(IncomingPort, mPop3Settings->Port());

    }

    else if (mMailboxType  == NmApiMailboxTypeImap) {

        data.setValue(IncomingLoginName, XQConversions::s60Desc8ToQString(mImap4Settings->LoginName()));

        data.setValue(IncomingPassword, XQConversions::s60Desc8ToQString(mImap4Settings->Password()));

        data.setValue(MailboxName, XQConversions::s60DescToQString(

                mImap4Account.iImapAccountName));

        data.setValue(IncomingMailServer, XQConversions::s60DescToQString(

                mImap4Settings->ServerAddress()));

#if (defined SYMBIAN_EMAIL_CAPABILITY_SUPPORT)

        data.setValue(IncomingMailUsesAuthentication, mImap4Settings->IAMP4Auth());

#endif

        data.setValue(IncomingPort, mImap4Settings->Port());

        data.setValue(FolderPath, XQConversions::s60Desc8ToQString(mImap4Settings->FolderPath()));

    }

    data.setValue(IncomingMailSecurityType, security());

    data.setValue(MyName, XQConversions::s60DescToQString(mSmtpSettings->EmailAlias()));

    data.setValue(EmailAlias, XQConversions::s60DescToQString(mSmtpSettings->EmailAlias()));

    data.setValue(EmailAddress, XQConversions::s60DescToQString(mSmtpSettings->EmailAddress()));

    data.setValue(ReplyAddress, XQConversions::s60DescToQString(mSmtpSettings->ReplyToAddress()));

    data.setValue(OutgoingMailServer, XQConversions::s60DescToQString(mSmtpSettings->ServerAddress()));

    data.setValue(OutgoingPort, mSmtpSettings->Port());

    data.setValue(OutgoingLoginName, XQConversions::s60Desc8ToQString(mSmtpSettings->LoginName()));

    data.setValue(OutgoingPassword, XQConversions::s60Desc8ToQString(mSmtpSettings->Password()));

    data.setValue(UseOutgoingAuthentication, mSmtpSettings->SMTPAuth());

    data.setValue(OutgoingMailUsesAuthentication, mSmtpSettings->SMTPAuth());

    data.setValue(OutgoingSecureSockets, mSmtpSettings->SecureSockets());

    data.setValue(OutgoingSSLWrapper, mSmtpSettings->SSLWrapper());

    data.setValue(OutgoingMailSecurityType, XQConversions::s60Desc8ToQString(mSmtpSettings->TlsSslDomain()));

    return true;

}

bool NmApiSettingsManagerPrivate::readCenRepSetting(NmApiMailboxSettingsData &data)

{

    bool ret = true;

    QVariant tmp;

    data.setValue(DownloadPictures, readFromCenRep(IpsServices::EmailKeyPreferenceDownloadPictures));

    data.setValue(MessageDivider, readFromCenRep(IpsServices::EmailKeyPreferenceMessageDivider));

    tmp = readFromCenRep(IpsServices::EmailKeyReceptionActiveProfile);

    switch(tmp.toInt()){

        case 0:

            data.setValue(ReceptionActiveProfile, EmailClientApi::EmailProfileOffsetKUTD);

            break;

        case 1:

            data.setValue(ReceptionActiveProfile, EmailClientApi::EmailProfileOffsetSE);

            break;

        case 2:

            data.setValue(ReceptionActiveProfile, EmailClientApi::EmailProfileOffsetMF);

            break;

        case 3:

            data.setValue(ReceptionActiveProfile, EmailClientApi::EmailProfileOffsetUD);

            break;

        default:

            data.setValue(ReceptionActiveProfile, EmailClientApi::EmailProfileOffsetKUTD);

            break;

    };

    data.setValue(ReceptionUserDefinedProfile, readFromCenRep(IpsServices::EmailKeyReceptionUserDefinedProfile));

    data.setValue(ReceptionInboxSyncWindow, readFromCenRep(mActiveProfileOffset

                        + IpsServices::EmailKeyReceptionInboxSyncWindow));

    data.setValue(ReceptionGenericSyncWindowInMessages, readFromCenRep(mActiveProfileOffset

                        + IpsServices::EmailKeyReceptionGenericSyncWindowInMessages));

    data.setValue(ReceptionWeekDays, readFromCenRep(mActiveProfileOffset

                        + IpsServices::EmailKeyReceptionWeekDays));

    data.setValue(ReceptionDayStartTime, readFromCenRep(mActiveProfileOffset

                        + IpsServices::EmailKeyReceptionDayStartTime));

    data.setValue(ReceptionDayEndTime, readFromCenRep(mActiveProfileOffset

                        + IpsServices::EmailKeyReceptionDayEndTime));

    data.setValue(ReceptionRefreshPeriodDayTime, readFromCenRep(mActiveProfileOffset

                        + IpsServices::EmailKeyReceptionRefreshPeriodDayTime));

    data.setValue(ReceptionRefreshPeriodOther, readFromCenRep(mActiveProfileOffset

                        + IpsServices::EmailKeyReceptionRefreshPeriodOther));

    data.setValue(UserNameHidden, readFromCenRep(IpsServices::EmailKeyUserNameHidden));

    data.setValue(EmailNotificationState, readFromCenRep(IpsServices::EmailKeyEMNState));

    data.setValue(FirstEmnReceived, readFromCenRep(IpsServices::EmailKeyFirstEmnReceived));

    data.setValue(EmnReceivedNotSynced, readFromCenRep(IpsServices::EmailKeyEmnReceivedNotSynced));

    QString aolState = alwaysOnlineState();

    if(aolState.length()>0)

        data.setValue(AlwaysOnlineState, aolState);

    data.setValue(AoLastSuccessfulUpdate, readFromCenRep(IpsServices::EmailKeyAoLastSuccessfulUpdateL));

    data.setValue(AoLastUpdateFailed, readFromCenRep(IpsServices::EmailKeyAoLastUpdateFailed));

    data.setValue(AoUpdateSuccessfulWithCurSettings, readFromCenRep(IpsServices::EmailKeyAoUpdateSuccessfulWithCurSettings));

    return ret;

}

/*!

 Writes POP3/IMAP4 specific settings.

 \param data consists of keys and values of settings.

 */

bool NmApiSettingsManagerPrivate::writeSettingL(const NmApiMailboxSettingsData &data)

{

    HBufC *tmp = 0;

    HBufC8 *tmp8 = 0;

    bool ret(false);

    int key;

    QVariant settingValue;

    QList<int> keylist;

    bool aliasSet = false;

    keylist = data.listSettings();

    for (int i = 0; i < keylist.size(); i++) {

        key = keylist[i];

        data.getValue(key, settingValue);

        switch (key) {

            case IncomingLoginName: {

                tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());

                if (mMailboxType == NmApiMailboxTypePop) {

                    mPop3Settings->SetLoginNameL(*tmp8);

                }

                else if (mMailboxType == NmApiMailboxTypeImap) {

                    mImap4Settings->SetLoginNameL(*tmp8);

                    }

                delete tmp8;

                break;

            }

            case IncomingPassword: {

                tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());

                if (mMailboxType == NmApiMailboxTypePop) {

                    mPop3Settings->SetPasswordL(*tmp8);

                }

                else if (mMailboxType == NmApiMailboxTypeImap) {

                    mImap4Settings->SetPasswordL(*tmp8);

                    }

                delete tmp8;

                break;

            }

            case MailboxName: {

                tmp = XQConversions::qStringToS60Desc(settingValue.toString());

                if (mMailboxType == NmApiMailboxTypePop) {

                    mPop3Account.iPopAccountName.Copy(*tmp);

                }

                else if (mMailboxType == NmApiMailboxTypeImap) {

                    mImap4Account.iImapAccountName.Copy(*tmp);

                    }

                delete tmp;

                break;

            }

            case IncomingMailServer: {

                tmp = XQConversions::qStringToS60Desc(settingValue.toString());

                if (mMailboxType == NmApiMailboxTypePop) {

                    mPop3Settings->SetServerAddressL(*tmp);

                }

                else if (mMailboxType == NmApiMailboxTypeImap) {

                    mImap4Settings->SetServerAddressL(*tmp);

                    }

                delete tmp;

                break;

            }

            case IncomingMailUsesAuthentication: {

#if (defined SYMBIAN_EMAIL_CAPABILITY_SUPPORT)

                if (mMailboxType == NmApiMailboxTypePop) {

                    mPop3Settings->SetPOP3Auth(settingValue.toBool());

                }

                else if (mMailboxType == NmApiMailboxTypeImap) {

                    mImap4Settings->SetIAMP4Auth(settingValue.toBool());

                }

#endif

                break;

            }

            case IncomingMailSecurityType: {

                setSecurity(settingValue.toString());

                break;

            }

            case IncomingPort: {

                if (mMailboxType == NmApiMailboxTypePop) {

                mPop3Settings->SetPort(settingValue.toInt());

                }

                else if (mMailboxType == NmApiMailboxTypeImap) {

                    mImap4Settings->SetPort(settingValue.toInt());

                }

                break;

            }

            case OutgoingPort: {

                mSmtpSettings->SetPort(settingValue.toInt());

                break;

            }

            case IncomingSecureSockets: {

                if (mMailboxType == NmApiMailboxTypePop) {

                    mPop3Settings->SetSecureSockets(settingValue.toBool());

                 }

                 else if (mMailboxType == NmApiMailboxTypeImap) {

                    mImap4Settings->SetSecureSockets(settingValue.toBool());

                     }

                break;

            }

            case IncomingSSLWrapper: {

                if (mMailboxType == NmApiMailboxTypePop) {

                    mPop3Settings->SetSSLWrapper(settingValue.toBool());

                }

                else if (mMailboxType == NmApiMailboxTypeImap) {

                    mImap4Settings->SetSSLWrapper(settingValue.toBool());

                    }

                break;

            }

            case EmailAddress: {

                tmp = XQConversions::qStringToS60Desc(settingValue.toString());

                mSmtpSettings->SetEmailAddressL(*tmp);

                break;

            }

            case ReplyAddress: {

                tmp = XQConversions::qStringToS60Desc(settingValue.toString());

                mSmtpSettings->SetReplyToAddressL(*tmp);

                break;

            }

            case EmailAlias: {

                QVariant tmpName;

                if(data.getValue(MyName,tmpName)) {

                    if(tmpName.toString()

                        ==XQConversions::s60DescToQString(mSmtpSettings->EmailAlias())) {

                        aliasSet = true;

                    }

                }

                tmp = XQConversions::qStringToS60Desc(settingValue.toString());

                mSmtpSettings->SetEmailAliasL(*tmp);

                break;

            }

            case MyName: {

                if(!aliasSet) {

                tmp = XQConversions::qStringToS60Desc(settingValue.toString());

                mSmtpSettings->SetEmailAliasL(*tmp);

                }

                break;

            }

            case OutgoingMailServer: {

                tmp = XQConversions::qStringToS60Desc(settingValue.toString());

                mSmtpSettings->SetServerAddressL(*tmp);

                break;

            }

            case OutgoingLoginName: {

                tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());

                mSmtpSettings->SetLoginNameL(*tmp8);

                break;

            }

            case OutgoingPassword: {

                tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());

                mSmtpSettings->SetPasswordL(*tmp8);

                break;

            }

            case UseOutgoingAuthentication:

            case OutgoingMailUsesAuthentication: {

                mSmtpSettings->SetSMTPAuth(settingValue.toBool());

                break;

            }

            case OutgoingSecureSockets: {

                mSmtpSettings->SetSecureSockets(settingValue.toBool());

                break;

            }

            case OutgoingSSLWrapper: {

                mSmtpSettings->SetSSLWrapper(settingValue.toBool());

                break;

            }

            case OutgoingMailSecurityType: {

                tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());

                mSmtpSettings->SetTlsSslDomainL(*tmp8);

                break;

            }

            case FolderPath: {

                tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());

                mImap4Settings->SetFolderPathL(*tmp8);

                break;

            }

            default: {

				break;

            }

        };

    }

    ret = saveSettings();

    return ret;

}

/*!

Writes settings to central repository.

\param data consists of keys and values of settings.

 */

bool NmApiSettingsManagerPrivate::writeSettingToCenRep(

    const NmApiMailboxSettingsData &data)

{

    int key;

    QVariant settingValue;

    QList<int> keylist;

    keylist = data.listSettings();

    bool ret = false;

    if(keylist.contains(ReceptionActiveProfile)) {

        data.getValue(ReceptionActiveProfile,settingValue);

        QVariant profileOffset = 0;

        if(settingValue.toString() == EmailClientApi::EmailProfileOffsetKUTD) {

            profileOffset=0;

        } else if(settingValue.toString() == EmailClientApi::EmailProfileOffsetSE){

            profileOffset = 1;

        } else if (settingValue.toString() == EmailClientApi::EmailProfileOffsetMF){

                    profileOffset = 2;

        } else if (settingValue.toString() == EmailClientApi::EmailProfileOffsetUD) {

            profileOffset = 3;

        }

        ret = writeToCenRep(IpsServices::EmailKeyReceptionActiveProfile, profileOffset);

        if(ret) {

            calculateActiveProfileOffset();

        }

    }

    if (ret) {

        for (int i = 0; i < keylist.size(); i++) {

            key = keylist[i];

            data.getValue(key, settingValue);

            switch (key) {

                case DownloadPictures: {

                    ret = writeToCenRep(IpsServices::EmailKeyPreferenceDownloadPictures,

                        settingValue);

                    break;

                }

                case MessageDivider: {

                    ret = writeToCenRep(IpsServices::EmailKeyPreferenceMessageDivider, settingValue);

                    break;

                }

                case ReceptionUserDefinedProfile: {

                    ret = writeToCenRep(IpsServices::EmailKeyReceptionUserDefinedProfile,

                        settingValue);

                    break;

                }

                case ReceptionInboxSyncWindow: {

                    ret = writeToCenRep(mActiveProfileOffset

                        + IpsServices::EmailKeyReceptionInboxSyncWindow, settingValue);

                    break;

                }

                case ReceptionGenericSyncWindowInMessages: {

                    ret = writeToCenRep(mActiveProfileOffset

                        + IpsServices::EmailKeyReceptionGenericSyncWindowInMessages, settingValue);

                    break;

                }

                case ReceptionWeekDays: {

                    ret = writeToCenRep(mActiveProfileOffset + IpsServices::EmailKeyReceptionWeekDays,

                        settingValue);

                    break;

                }

                case ReceptionDayStartTime: {

                    ret = writeToCenRep(mActiveProfileOffset + IpsServices::EmailKeyReceptionDayStartTime,

                        settingValue);

                    break;

                }

                case ReceptionDayEndTime: {

                    ret = writeToCenRep(mActiveProfileOffset + IpsServices::EmailKeyReceptionDayEndTime,

                        settingValue);

                    break;

                }

                case ReceptionRefreshPeriodDayTime: {

                    ret = writeToCenRep(mActiveProfileOffset

                        + IpsServices::EmailKeyReceptionRefreshPeriodDayTime, settingValue);

                    break;

                }

                case ReceptionRefreshPeriodOther: {

                    ret = writeToCenRep(mActiveProfileOffset

                        + IpsServices::EmailKeyReceptionRefreshPeriodOther, settingValue);

                    break;

                }

                case UserNameHidden: {

                    ret = writeToCenRep(IpsServices::EmailKeyUserNameHidden, settingValue);

                    break;

                }

                case EmailNotificationState: {

                    ret = writeToCenRep(IpsServices::EmailKeyEMNState, settingValue);

                    break;

                }

                case FirstEmnReceived: {

                    ret = writeToCenRep(IpsServices::EmailKeyFirstEmnReceived, settingValue);

                    break;

                }

                case EmnReceivedNotSynced: {

                    ret = writeToCenRep(IpsServices::EmailKeyEmnReceivedNotSynced, settingValue);

                    break;

                }

                case AlwaysOnlineState: {

                    setAlwaysOnlineState(settingValue);

                    break;

                }

                case AoLastSuccessfulUpdate: {

                    ret = writeToCenRep(IpsServices::EmailKeyAoLastSuccessfulUpdateL, settingValue);

                    break;

                }

                case AoLastUpdateFailed: {

                    ret = writeToCenRep(IpsServices::EmailKeyAoLastUpdateFailed, settingValue);

                    break;

                }

                case AoUpdateSuccessfulWithCurSettings: {

                    ret = writeToCenRep(IpsServices::EmailKeyAoUpdateSuccessfulWithCurSettings,

                        settingValue);

                    break;

                }

                case ReceptionActiveProfile:

                default: {

                    break;

                }

            };

        }

    }

    return ret;

}

/*!

 Stores the POP3/IMAP4 specific settings.

 \return bool <true> when the settings were succesfully written, otherwise <false>.

 */

bool NmApiSettingsManagerPrivate::saveSettings()

{

    bool ret(false);

    if (mMailboxType == NmApiMailboxTypePop) {

        TRAPD(err, mAccount->SavePopSettingsL(mPop3Account, *mPop3Settings));

        if (err == KErrNone) {

            ret = true;

        }

    }

    else if (mMailboxType == NmApiMailboxTypeImap) {

        TRAPD(err, mAccount->SaveImapSettingsL(mImap4Account, *mImap4Settings));

        if (err == KErrNone) {

            ret = true;

        }

    }