#include <QTimer>

#include <hbmessagebox.h>

#include <HbNotificationDialog>

#include <commonphoneparser.h>      // Common phone number validity checker

#include <xqconversions.h>

#include "debugtraces.h"

#include "msgmonitor.h"

#include "unieditorgenutils.h"

const QString replacementStr("; ");

#define LOC_SMS_RECIPIENT_LIMIT_REACHED hbTrId("txt_messaging_dialog_number_of_recipients_exceeded")

#define LOC_MMS_RECIPIENT_LIMIT_REACHED hbTrId("txt_messaging_dpopinfo_unable_to_add_more_recipien")

#define LOC_DIALOG_OK hbTrId("txt_common_button_ok")

#define LOC_BUTTON_CANCEL hbTrId("txt_common_button_cancel")

#define LOC_INVALID_RECIPIENT hbTrId("txt_messaging_dialog_invalid_recipient_found")

MsgUnifiedEditorBaseWidget(parent),

mSkipMaxRecipientQuery(false),

mAboutToExceedMaxSmsRecipients(false),

mAboutToExceedMaxMmsRecipients(false),

mExceedsMaxMmsRecipientsBy(0)

    this->setContentsMargins(0,0,0,0);

            this, SLOT(onContentsChanged(const QString&)));

	//TODO: Should remove this code depending on orbit's reply whether it is needed

	//to unregister the same plugin registered on two different widgets twice.

    //style()->unregisterPlugin(mPluginPath);

        return;

    args << QString(tr("Phonebook"));

   CntServicesContactList contactList =

           qVariantValue<CntServicesContactList>(value);

    int count = contactList.count();

    ConvergedMessageAddressList addrlist;

    for(int i = 0; i < count; i++ )

        ConvergedMessageAddress* address =

                new ConvergedMessageAddress();

        address->setAddress(contactList[i].mPhoneNumber);

        address->setAlias(contactList[i].mDisplayName);

        addrlist << address;

    setAddresses(addrlist);

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

// MsgUnifiedEditorAddress::addresses

// @see header

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

ConvergedMessageAddressList MsgUnifiedEditorAddress::addresses(

        bool removeDuplicates)

#ifdef _DEBUG_TRACES_

    qCritical() << "MsgUnifiedEditorAddress::addresses start";

    if(removeDuplicates)

        QStringList uniqueAddr;

        uniqueAddr = uniqueAddressList();

        foreach(QString addr, uniqueAddr)

            ConvergedMessageAddress* address = new ConvergedMessageAddress;

            address->setAddress(addr);

            addresses.append(address);

        }

    else

    {

        QMap<QString, QString>::iterator i = mAddressMap.begin();

        while (i != mAddressMap.end())

        {

            ConvergedMessageAddress* address = new ConvergedMessageAddress;

            address->setAddress(i.key());

            address->setAlias(i.value());

            addresses.append(address);

            i++;

        }

    }

#ifdef _DEBUG_TRACES_

    qCritical() << "MsgUnifiedEditorAddress::addresses end";

    // ensure flags are reset before starting the addr addition

    mAboutToExceedMaxSmsRecipients = false;

    mAboutToExceedMaxMmsRecipients = false;

    mExceedsMaxMmsRecipientsBy = 0;

    // first, we check if MMS max-recipient count will exceed

    int count = addrlist.count();

	int futureCount = count + MsgMonitor::msgAddressCount();

	if(futureCount > MsgMonitor::maxMmsRecipients())

	{

	    mAboutToExceedMaxMmsRecipients = true;

	    mExceedsMaxMmsRecipientsBy =

	            futureCount - MsgMonitor::maxMmsRecipients();

	}

	// else, check if SMS max-recipient count will exceed

	else if(!mSkipMaxRecipientQuery)

	{

	    futureCount = count + addressCount();

	    if( (addressCount() <= MsgMonitor::maxSmsRecipients()) &&

	        (futureCount > MsgMonitor::maxSmsRecipients()) )

	    {

	        mAboutToExceedMaxSmsRecipients = true;

	    }

	}

        mAddressMap.insertMulti(addrlist[i]->address(), addrlist[i]->alias());

            mAddressEdit->setText(addrlist[i]->address(), false);

    // addition operation complete, reset flags

    mAboutToExceedMaxSmsRecipients = false;

    mAboutToExceedMaxMmsRecipients = false;

    mExceedsMaxMmsRecipientsBy = 0;

{

    // The key is owned by PhoneApp

    TRAP_IGNORE(

        CRepository* repository = CRepository::NewLC(KCRUidTelConfiguration);

        if ( repository->Get(KTelMatchDigits, matchDigitCount) == KErrNone )

            // Min is 7

            matchDigitCount = Max(matchDigitCount, KDefaultGsmNumberMatchLength);

        CleanupStack::PopAndDestroy(); // repository

    );

}

void MsgUnifiedEditorAddress::onContentsChanged(const QString& text)

    // Max MMS recipient count check

    if( mAboutToExceedMaxMmsRecipients ||

        (MsgMonitor::msgAddressCount() >= MsgMonitor::maxMmsRecipients()) )

        if(mAboutToExceedMaxMmsRecipients)

        {// show discreet note only once

            --mExceedsMaxMmsRecipientsBy;

            if(!mExceedsMaxMmsRecipientsBy)

            {

                HbNotificationDialog::launchDialog(

                        LOC_MMS_RECIPIENT_LIMIT_REACHED);

            }

            resetToPrevious();

        }

        else

        {

            // update monitor data

            emit contentChanged();

            if(MsgMonitor::msgAddressCount() > MsgMonitor::maxMmsRecipients())

            {

                HbNotificationDialog::launchDialog(

                        LOC_MMS_RECIPIENT_LIMIT_REACHED);

                resetToPrevious();

                // reset monitor data

                emit contentChanged();

            }

            else

            {

                mPrevBuffer = text;

            }

        }

        return;

    }

    // Max SMS recipient count check

    if( !mSkipMaxRecipientQuery &&

        (MsgMonitor::messageType() == ConvergedMessage::Sms) &&

        (mAddressEdit->addresses().count() > MsgMonitor::maxSmsRecipients()) )

    {

        // when we show this dialog, we don't want the intermediate states

        // to be signalled to us

                this, SLOT(onContentsChanged(const QString&)));

        QTimer::singleShot(50, this, SLOT(handleRecipientLimitReached()));

    }

    else

    {

        if(!mAboutToExceedMaxSmsRecipients)

        {// remember addresses before the block insertion started

            mPrevBuffer = text;

        }

void MsgUnifiedEditorAddress::handleRecipientLimitReached()

    HbMessageBox* dlg = new HbMessageBox(HbMessageBox::MessageTypeQuestion);

    dlg->setAttribute(Qt::WA_DeleteOnClose);

    dlg->setFocusPolicy(Qt::NoFocus);

    dlg->setTimeout(HbPopup::NoTimeout);

    dlg->setText(LOC_SMS_RECIPIENT_LIMIT_REACHED);

    HbAction* okAction = new HbAction(LOC_DIALOG_OK,dlg);

    dlg->addAction(okAction);

    HbAction* cancelAction = new HbAction(LOC_BUTTON_CANCEL,dlg);

    dlg->addAction(cancelAction);

    dlg->open(this,SLOT(onMaxRecipientsReached(HbAction*)));

    // reconnect to get back updates

    connect(mAddressEdit, SIGNAL(contentsChanged(const QString&)),

            this, SLOT(onContentsChanged(const QString&)));

    emit contentChanged();

    QStringList mapAddrList = mAddressMap.values();

    mapAddrList << mAddressMap.keys();

        userInputAddrList.removeOne(addr);

        mAddressMap.insertMulti(addr, QString());

            if(0 == mapAddrList[j].right(matchDigitCount).compare(mapAddrList[i].right(matchDigitCount)))

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

// MsgUnifiedEditorAddress::skipMaxRecipientQuery

// @see header

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

void MsgUnifiedEditorAddress::skipMaxRecipientQuery(bool skip)

{

    mSkipMaxRecipientQuery = skip;

}

void MsgUnifiedEditorAddress::setFocus()

{

    mAddressEdit->setFocus(Qt::MouseFocusReason);

}

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

// MsgUnifiedEditorAddress::resetToPrevious

// @see header

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

void MsgUnifiedEditorAddress::resetToPrevious()

{

    // when we do this reset operation, we don't want the intermediate states

    // to be signalled to us

    disconnect(mAddressEdit, SIGNAL(contentsChanged(const QString&)),

            this, SLOT(onContentsChanged(const QString&)));

    mAddressEdit->clearContent();

    QStringList list = mPrevBuffer.split(replacementStr,

            QString::SkipEmptyParts);

    int count = list.count();

    QStringList valList = mAddressMap.values();

    for(int i=0; i<count; i++)

    {

        QString addr = list.at(i);

        if(valList.contains(addr))

        {

            mAddressEdit->setText(addr);

        }

        else

        {

            mAddressEdit->setText(addr, false);

        }

    }

    syncDeletionsToMap();

    connect(mAddressEdit, SIGNAL(contentsChanged(const QString&)),

            this, SLOT(onContentsChanged(const QString&)));

}

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

// MsgUnifiedEditorAddress::onMaxRecipientsReached

// @see header

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

void MsgUnifiedEditorAddress::onMaxRecipientsReached(HbAction* action)

{

    HbMessageBox *dlg = qobject_cast<HbMessageBox*> (sender());

    if (action == dlg->actions().at(0)) {

        // accept new content, update prev-buffer

        mPrevBuffer = mAddressEdit->content();

    }

    else {

        // reject the new content, keep the old

        resetToPrevious();

    }

}

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

// MsgUnifiedEditorAddress::validateContacts

// @see header

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

bool MsgUnifiedEditorAddress::validateContacts()

{

    UniEditorGenUtils* genUtils = new UniEditorGenUtils;

    // sync-up map to account for user-actions on address-field

    syncDeletionsToMap();

    syncAdditionsToMap();

    // get the list of contacts in address-field

    QStringList fieldAddresses(mAddressEdit->addresses());

    bool allValid = true;

    foreach(QString addr, fieldAddresses)

    {

        // run address validation only if address is unmapped

        // (i.e. user-inserted)

        if(mAddressMap.contains(addr))

        {

            // 1. perform number validation

            allValid = CommonPhoneParser::IsValidPhoneNumber(

                    *XQConversions::qStringToS60Desc(addr),

                    CommonPhoneParser::ESMSNumber );

            // 2. if number validity fails, then perform email addr validation

            if( !allValid &&

                (MsgMonitor::messageType() == ConvergedMessage::Mms) )

            { // additional check for MMS only

                allValid = genUtils->IsValidEmailAddress(

                        *XQConversions::qStringToS60Desc(addr) );

            }

            if(!allValid)

            {

                mAddressEdit->highlightInvalidString(addr);

                QString invalidAddrStr =

                        QString(LOC_INVALID_RECIPIENT).arg(addr);

                HbMessageBox* dlg = new HbMessageBox(invalidAddrStr,

                        HbMessageBox::MessageTypeInformation);

                dlg->setDismissPolicy(HbPopup::TapInside);

                dlg->setTimeout(HbPopup::NoTimeout);