/*

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

namespace EmailClientApi

{

NmApiMailboxSettingsDataPrivate::NmApiMailboxSettingsDataPrivate() :

    mId(0), mSettings(new QHash<int, QVariant>())

{

    NM_FUNCTION;

    Q_CHECK_PTR( mSettings );

}

NmApiMailboxSettingsDataPrivate::~NmApiMailboxSettingsDataPrivate()

{

    NM_FUNCTION;

}

/*!

 \fn setMailboxId 

 \param mailboxId - valid mailbox id as quint64.

 Sets the mailbox id               

 */

void NmApiMailboxSettingsDataPrivate::setMailboxId(quint64 mailboxId)

{

    NM_FUNCTION;

    mId = mailboxId;

}

/*!

 \fn mailboxId

 \return quint64 - the mailbox id.

 Gets the mailbox id.              

 */

quint64 NmApiMailboxSettingsDataPrivate::mailboxId() const

{

    NM_FUNCTION;

    return mId;

}

/*!

 \fn setValue 

 \param key - setting data to be set.

 \param settingValue - Value to be set as QVariant.

 Sets individual setting value.        

 */

void NmApiMailboxSettingsDataPrivate::setValue(int key, const QVariant &settingValue)

{

    NM_FUNCTION;

    (*mSettings)[key] = settingValue;

}

/*!

 \fn getValue

 \param key - setting data to get.

 \param settingValue - On return holds as QVariant.

 \return true if succesfull, false otherwise.

 Get individual setting value.        

 */

bool NmApiMailboxSettingsDataPrivate::getValue(int key, QVariant &settingValue) const

{

    NM_FUNCTION;

    if (mSettings->contains(key)) {

        settingValue = (*mSettings)[key];

        return true;

    }

    return false;

}

/*!

 \fn validateString

 \param key - setting data to validate.

 \param val - value to validate.

 \param validated - if this key was validated by the method

 \return true if valid value, false otherwise.

 validates individual string type value.        

 */

bool NmApiMailboxSettingsDataPrivate::validateString(int key, QVariant& val, bool& validated) const

{

    NM_FUNCTION;

    bool ret = true;

    switch (key) {     

     case OutgoingPassword:

     case IncomingPassword:     

     case FolderPath: 

     case IncomingLoginName:

     case MailboxName:

     case MyName:

     case ReceptionActiveProfile:

     case IncomingMailServer:

     case OutgoingMailServer:

     case OutgoingLoginName:

     case EmailAddress:

     case ReplyAddress:

     case EmailAlias:               

     case IncomingMailUsesAuthentication:

     case OutgoingMailUsesAuthentication:

     case IncomingMailSecurityType:

     case OutgoingMailSecurityType:

     case EmailNotificationState:         

     case AlwaysOnlineState:{

         validated=true;

         if (val.type() != QVariant::String) {

             ret = false;

             break;

         }

         QString sz = val.toString();                   

         ret = validateStringValue(key, sz);

         break;

     }

     default: {

         validated = false;

         ret = false;

         break;

         }

    }    

    return ret;

}

/*!

 \fn validateStringValue

 \param key - setting data to validate.

 \param val - value to validate. 

 \return true if valid value, false otherwise.

 validates individual string type value.        

 */

bool NmApiMailboxSettingsDataPrivate::validateStringValue(int key, QString& val) const

{

    NM_FUNCTION;

    int ret = true;

    bool valid = true, validated = false;

    valid = validateStringGeneral(key ,val, validated);

    if (validated && !valid) {

            ret = false;

    }

    if( !validated ) {

        valid = validateEmailAddress(key ,val, validated);

        if (validated && !valid) {

            ret = false;

        }

    }

    if( !validated ) {

        valid = validateUsesAuthentication(key ,val, validated);

        if (validated && !valid) {

            ret = false;

        }

    }

    if( !validated ) {

        valid = validateSecurityType(key ,val, validated);

        if (validated && !valid) {

            ret = false;

        }

    }

    if( !validated ) {

        valid = validateAOLState(key ,val, validated);

        if (validated && !valid) {

            ret = false;

        }

    }        

    return ret;

}

/*!

 \fn validateStringGeneral

 \param key - setting data to validate.

 \param val - value to validate.

 \param handled - true if method value was handled by method.

 \return true if valid value, false otherwise.

 validates individual string type value.        

 */

bool NmApiMailboxSettingsDataPrivate::validateStringGeneral(int key, QString& /*val*/, bool& handled) const

{

    NM_FUNCTION;

    int ret = true;

    switch (key) {     

         case OutgoingPassword:

         case IncomingPassword:     

         case FolderPath:

         case IncomingLoginName:

         case MailboxName:

         case MyName:

         case ReceptionActiveProfile:

         case IncomingMailServer:

         case OutgoingMailServer:

         case OutgoingLoginName: {

             // Allready validated that values are string, 

             // otherwise method is not called

             handled = true;         

             break;

         }

         default: {

             handled = false;

             ret = false;

             break;

         }    

    } 

    return ret;

}

/*!

 \fn validateEmailAddress

 \param key - setting data to validate.

 \param val - value to validate.

 \param handled - true if value was validated by the method

 \return true if valid value, false otherwise.

 validates individual string type value.        

 */

bool NmApiMailboxSettingsDataPrivate::validateEmailAddress(int key, QString& val, bool& handled) const

{

    NM_FUNCTION;

    int ret = true;

    switch (key) {        

        case EmailAddress:

        case ReplyAddress: {

            handled = true;

            if (val.size() == 0) {             

                 ret = false;

                 break;

            }

            if (!(val.contains("@"))) {

               ret = false;

            }

            break;

        }

        case EmailAlias:  {

            handled = true;            

            break;

        }

        default: {

            handled = false;

            ret = false;

            break;

        }

    }

    return ret;

}

/*!

 \fn validateUsesAuthentication

 \param key - setting data to validate.

 \param val - value to validate.

 \param handled - true if value was validated by the method

 \return true if valid value, false otherwise.

 validates individual string type value.        

 */

bool NmApiMailboxSettingsDataPrivate::validateUsesAuthentication(int key, QString& val, bool& handled) const

{ 

    NM_FUNCTION;

    int ret = true;

    switch (key) { 

        case IncomingMailUsesAuthentication:

        case OutgoingMailUsesAuthentication: {

            handled = true;

            if (val.size() == 0) {

                ret = false;

                break;

            }

            if (!(val.contains("none") ||

              val.contains("UserAuthentication") ||

                  (key == OutgoingMailUsesAuthentication &&

                   val.contains("SameAsIncoming")) )) {

                ret = false;

            }

            break;

        }

        default: {

            handled = false;

            ret = false;

            break;

        }

    }

    return ret;

}

/*!

 \fn validateSecurityType

 \param key - setting data to validate.

 \param val - value to validate.

 \param validated - true if value was validated by the method

 \return true if valid value, false otherwise.

 validates individual string type value.        

 */

bool NmApiMailboxSettingsDataPrivate::validateSecurityType(int key, QString& val, bool& handled) const

{ 

    NM_FUNCTION;

    int ret = true;

    switch (key) {

         case IncomingMailSecurityType:

         case OutgoingMailSecurityType: {

            handled = true;

            if (val.size() == 0) {

                ret = false;

                break;

            }

            if (!(val.contains("StartTls") || 

                  val.contains("SSLTls") || 

                  val.contains("none"))) {

                ret = false;

            }

            break;

         }

         default: {

             handled = false;

             ret = false;

             break;

         }

     }

     return ret;

}

/*!

 \fn validateAOLState

 \param key - setting data to validate.

 \param val - value to validate.

 \param validated - true if value was validated by the method

 \return true if valid value, false otherwise.

 validates individual string type value.        

 */

bool NmApiMailboxSettingsDataPrivate::validateAOLState(int key, QString& val, bool& handled) const

{ 

    NM_FUNCTION;

    int ret = true;

    switch (key) {

        case EmailNotificationState:         

        case AlwaysOnlineState:{

         handled = true;

         if (val.size() == 0) {

              ret = false;

              break;

          }

          if (!( (val.contains("always") && key == AlwaysOnlineState) || 

                 (val.contains("automatic") && key == EmailNotificationState) || 

                  val.contains("homeOnly") || 

                  val.contains("off"))) {

              ret = false;

          }

          break;

        }

        default: {

            handled = false;

            ret = false;

            break;

        }

    }

    return ret;

}

/*!

 \fn validateInteger

 \param key - setting data to validate.

 \param val - value to validate.

 \param validated - true if value was validated by the method

 \return true if valid value, false otherwise.

 validates individual integer type value.        

 */

bool NmApiMailboxSettingsDataPrivate::validateInteger(int key, QVariant& val, bool& validated) const

{

    NM_FUNCTION;

    bool ret = true;

    switch (key) { 

        case DownloadPictures:

        case MessageDivider:

        case UserNameHidden:

        case FirstEmnReceived:

        case EmnReceivedNotSynced:

        case AoLastUpdateFailed:

        case AoUpdateSuccessfulWithCurSettings:

        case ReceptionUserDefinedProfile:

        case ReceptionInboxSyncWindow:

        case ReceptionGenericSyncWindowInMessages:

        case IncomingPort:

        case OutgoingPort:

        case ReceptionWeekDays:

        case ReceptionDayStartTime:

        case ReceptionDayEndTime:

        case ReceptionRefreshPeriodDayTime:

        case ReceptionRefreshPeriodOther: {

            validated = true;

            if (!(val.type() == QVariant::Int ||

                  val.type() == QVariant::UInt ||

                  val.type() == QVariant::LongLong  ||

                  val.type() == QVariant::ULongLong ||

                  val.type() == QVariant::Double)) {

                ret = false;

                break;

            }            

            int ival = val.toInt();

            ret = validateIntVal(key,ival);

            break;

        }

        default: {

            validated = false;

            ret = false;

            break;

        }

     }

     return ret;

}

/*!

 \fn validateIntVal

 \param key - setting data to validate.

 \param val - value to validate. 

 \return true if valid value, false otherwise.

 validates individual integer type value.        

 */

bool NmApiMailboxSettingsDataPrivate::validateIntVal(int key, int val) const

{

    NM_FUNCTION;

    int ret = true;

    bool valid = true, validated = false;

    valid = validateIntGeneral(key ,val, validated);

    if (validated && !valid) {

           ret = false;

    }

    if( !validated ) {

       valid = validateOnOffValue(key ,val, validated);

       if (validated && !valid) {

           ret = false;

       }

    }

    if( !validated ) {

       valid = validateWeekdayMask(key ,val, validated);

       if (validated && !valid) {

           ret = false;

       }

    }

    if( !validated ) {

       valid = validateHoursInDay(key ,val, validated);

       if (validated && !valid) {

           ret = false;

       }

    }

    return ret;

}

/*!

 \fn validateOnOffValue

 \param key - setting data to validate.

 \param val - value to validate.

 \param validated - true if value was validated by the method

 \return true if valid value, false otherwise.

 validates individual integer type value.        

 */

bool NmApiMailboxSettingsDataPrivate::validateOnOffValue(int key, int val, bool& handled) const

{

    NM_FUNCTION;

    bool ret = true;

    switch (key) {   

        // Integer: 0=Off, 1=On    

        case DownloadPictures:

        case MessageDivider:

        case UserNameHidden:

        // Integer: 0=false,1=true

        case FirstEmnReceived:

        case EmnReceivedNotSynced:

        case AoLastUpdateFailed:

        case AoUpdateSuccessfulWithCurSettings:

        // Integer: 0=Disabled, 1=Enabled

        case ReceptionUserDefinedProfile: {

            handled = true;

            if (!(0 <= val && val <= 1)) {

                ret = false;

            }

            break;

        }

        default: {

            handled = false;

            ret = false;

            break;

        }

    }

    return ret;

}

/*!

 \fn validateIntGeneral

 \param key - setting data to validate.

 \param val - value to validate.

 \param validated - true if value was validated by the method

 \return true if valid value, false otherwise.

 validates individual integer type value.