/****************************************************************************
**
** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (developer.feedback@nokia.com)
**
** This file is part of the HbPlugins module of the UI Extensions for Mobile.
**
** GNU Lesser General Public License Usage
** 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 developer.feedback@nokia.com.
**
****************************************************************************/
#include <QTextCharFormat>
#include <QTimer>
#include <hbinputsettingproxy.h>
#include <hbinputkeymapfactory.h>
#include <hbinputkeymap.h>
#include <hbinpututils.h>

#include "hbinputmodehandler.h"
#include "hbinputmodehandler_p.h"
#include "hbinputabstractbase.h"

HbInputModeHandlerPrivate::HbInputModeHandlerPrivate()
:mKeymap(0),
mInputMethod(0),
mTimer(0)
{
}

HbInputModeHandlerPrivate::~HbInputModeHandlerPrivate()
{
}

void HbInputModeHandlerPrivate::init()
{
    Q_Q(HbInputModeHandler);
    mTimer = new QTimer(q);
    q->connect(mTimer, SIGNAL(timeout()), q, SLOT(_q_timeout()));
    mTimer->setSingleShot(true);
}

// A virtual timeout function mode handlers should implement this slot.
void HbInputModeHandlerPrivate::_q_timeout()
{
}

QString HbInputModeHandlerPrivate::surroundingText()
{
    if (mInputMethod->focusObject()) {
        return mInputMethod->focusObject()->editorSurroundingText();
    }
    return QString();
}

int HbInputModeHandlerPrivate::cursorPosition()
{
    if (mInputMethod->focusObject()) {
       return mInputMethod->focusObject()->editorCursorPosition();
    }

    return -1;
}

bool HbInputModeHandlerPrivate::isPunctuationKey(const Qt::Key key, const HbKeyboardType keypad)
{
    // Currently, Punctuation key is present only for For ITUT Keypad (i.e. Key_1 is is the punctuation key)
    if ( (!HbInputUtils::isQwertyKeyboard(keypad)) && (Qt::Key_1 == key) ) {
        return true;
    }
    return false;
}

void HbInputModeHandlerPrivate::getAndFilterCharactersBoundToKey(QString &allowedChars, HbKeyboardType type, \
                                                                 int key, HbModifiers modifiers)
{
    allowedChars.clear();
    HbInputLanguage language = mInputMethod->inputState().language();
    
    if (!mKeymap) {
        mKeymap = HbKeymapFactory::instance()->keymap(language);
    }
    const HbMappedKey* mappedKey = mKeymap->keyForKeycode(type, key);
    if (!mappedKey) {
        return;
    }
    QString chars = mappedKey->characters(modifiers);
    // check whether current input language supports native digits. if yes, replace latin digits with native digits    
    for (int i = 0; i < chars.length(); i++) {
        if (chars.at(i) >= '0' && chars.at(i) <= '9') {
            chars = chars.replace(chars.at(i), HbInputUtils::findFirstNumberCharacterBoundToKey(mappedKey,
                language, HbInputUtils::inputDigitType(language)));
        }       
    }       
    // We need to see which of the characters in keyData are allowed to the editor.
    // this looks like expensive operation, need to find out a better way/place to do it.
    HbInputFocusObject *focusedObject = mInputMethod->focusObject();
    if(focusedObject) {
        focusedObject->filterStringWithEditorFilter(chars,allowedChars);
    } 
}


void HbInputModeHandlerPrivate::updateTextCase()
{
    HbInputState nextState = mInputMethod->inputState();
    HbTextCase nextCase = HbTextCaseNone;

    switch(nextState.textCase()) {
        case HbTextCaseLower:
            // In multiline editor, if enter char is input and then shift is pressed twice,
            // the case should be reverted to automatic.
            if (mInputMethod->automaticTextCaseNeeded()) {
                nextCase = HbTextCaseAutomatic;
            } else {
                nextCase = HbTextCaseUpper;
            }
            break;
        case HbTextCaseUpper:
        case HbTextCaseAutomatic:
            nextCase = HbTextCaseLower;
            break;
        default:
            break;
        }
        nextState.setTextCase(nextCase);
        mInputMethod->activateState(nextState);
}

bool HbInputModeHandlerPrivate::isEnterCharacter(QChar character)
{
    if (character == 0x21B2 || character == 0x21b3) {
        return true;
    }
    return false;
}
HbInputModeHandler::HbInputModeHandler(HbInputModeHandlerPrivate &dd, HbInputAbstractMethod* inputMethod)
    :d_ptr(&dd)
{
    Q_D(HbInputModeHandler);
    d->q_ptr = this;
    d->init();
    d->mInputMethod = inputMethod;
}

HbInputModeHandler::~HbInputModeHandler()
{
    delete d_ptr;
}

/*!
 Gateway for all the mode handlers.
*/
bool HbInputModeHandler::filterEvent(const QEvent * event)
{
    if (event) {
        if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
            const QKeyEvent *keyEvent = static_cast<const QKeyEvent *>(event);
            return filterEvent(keyEvent);
        }
    }
    return false;
}

/*!
 This function handles the most common key events.
*/
bool HbInputModeHandler::filterEvent(const QKeyEvent * event)
{
    Q_UNUSED(event);
    return false;
}

/*!
 Action hanlder. Currently it handles only keymapping loading.
*/
bool HbInputModeHandler::actionHandler(HbInputModeAction action)
{
    Q_D(HbInputModeHandler);
    switch (action) {
    case HbInputModeActionInit:
        if (d->mKeymap) {
            break;
        }
    case HbInputModeActionPrimaryLanguageChanged: {
        HbInputLanguage primaryLanguage = HbInputSettingProxy::instance()->globalInputLanguage();
        d->mKeymap = HbKeymapFactory::instance()->keymap(primaryLanguage);
        if (!d->mKeymap) {
            qDebug(" HbInputModeHandler::actionHandler --> Failed to get keymapData!!!");
            return false;
        }
        }
        break;
    case HbInputModeActionDeleteAndCommit: {
        HbInputFocusObject *focusObject = 0;
        focusObject = d->mInputMethod->focusObject();

        if (focusObject && focusObject->editorCursorPosition()) {
            QString empty;
            QList<QInputMethodEvent::Attribute> list;
            QInputMethodEvent event(QString(), list);
            event.setCommitString(empty, -1, 1);
            sendAndUpdate(event);
        }
        break;
        }
    default :
        return false;
    };

    return true;
}

/*!
Call-back implementation to indicate that a character was selected from the SCT. With this, the character is committed to the
editor and editor is again made to focus.
*/
void HbInputModeHandler::sctCharacterSelected(QString aChar)
{
    commitAndUpdate(aChar);
}

void HbInputModeHandler::smileySelected(QString smiley)
{
    Q_D(HbInputModeHandler);
    HbInputFocusObject *focusObject = 0;
    focusObject = d->mInputMethod->focusObject();
    if (!focusObject) {
        qDebug("HbInputModeHandler::smileySelected no focusObject ... failed!!");
        return ;
    }
    QStringList patterns = focusObject->editorInterface().smileyTheme().patterns(smiley);
    foreach( const QString string, patterns) {
        QString filtered;
        focusObject->filterStringWithEditorFilter(string, filtered);
        if (filtered == string) {
            focusObject->commitSmiley(smiley);
            break;
        }
    }
    d->mInputMethod->updateState();
}

void HbInputModeHandler::cursorPositionChanged(int oldPos, int newPos)
{
    Q_D(HbInputModeHandler);
    d->mInputMethod->updateState();
    Q_UNUSED(oldPos);
    Q_UNUSED(newPos);
}

/*!
 this function commits the first number found in the key.
*/
void HbInputModeHandler::commitFirstMappedNumber(int key, HbKeyboardType type)
{
    Q_D(HbInputModeHandler);

    HbInputLanguage language = d->mInputMethod->inputState().language();
    // This is long key press number shortcut functionality.
    if (!d->mKeymap) {
        d->mKeymap = HbKeymapFactory::instance()->keymap(language);
    }
    bool isNumericEditor = d->mInputMethod->focusObject()->editorInterface().isNumericEditor();
    HbInputDigitType digitType = HbInputUtils::inputDigitType(language);
    if (isNumericEditor) {
        QLocale::Language systemLanguage = QLocale::system().language();         
        if (language.language() != systemLanguage) {
            digitType = HbDigitTypeLatin;
        }
    }   
    QChar numChr = HbInputUtils::findFirstNumberCharacterBoundToKey(
        d->mKeymap->keyForKeycode(type, key), language, digitType);
    // when a number is to be entered, it should commit 
    // the previous string and then append the number to the string
    if (numChr != 0) {
        commitAndAppendString(numChr);
    }
}

/*!
Gets the character at index in a key and incriments the index by 1. Returns the Zeroth character if
this function finds the index to be out of range and incriments index to 1.
*/
QChar HbInputModeHandler::getNthCharacterInKey(int &index, int key, HbKeyboardType type)
{
    Q_D(HbInputModeHandler);
    HbModifiers modifiers = 0;
    int textCase = d->mInputMethod->inputState().textCase();
    if ( (type != HbKeyboardSctPortrait && type != HbKeyboardSctUrl && type != HbKeyboardSctEmail) && 
        (textCase == HbTextCaseUpper || textCase == HbTextCaseAutomatic)) {
        modifiers |= HbModifierShiftPressed;
    }

    QString allowedChars;
    getAndFilterCharactersBoundToKey(allowedChars,type,key,modifiers);

    QChar character = 0;
    if (!allowedChars.isNull()) {
        if (index >= allowedChars.length() || index < 0) {
            index = 0;
        }
        character = allowedChars.at(index);
        index++;
        if (index >= allowedChars.length() || index < 0) {
            index = 0;
        }
    }
    return character;
}

/*!
    This function gets all the characters bound to a key and filters those character based on the editor.
*/
void HbInputModeHandler::getAndFilterCharactersBoundToKey(QString &allowedChars, HbKeyboardType type, \
                                                          int key, HbModifiers modifiers)
{
    Q_D(HbInputModeHandler);
    d->getAndFilterCharactersBoundToKey(allowedChars,type,key,modifiers);
}

/*!
    A virtual function, this should be called from plugin when ever there is mouse event.
*/
void HbInputModeHandler::mouseHandler(int x, QMouseEvent* mouseEvent)
{
    Q_UNUSED(mouseEvent);
    Q_D(HbInputModeHandler);
    if(d->cursorPosition() != x) {
        actionHandler(HbInputModeActionCommit);
    }
}

/*!
    A virtual function, default implementation first commits any inline text by calling actionHandler with
    HbInputModeActionCommit. Then commits the string.
*/
void HbInputModeHandler::commitAndAppendString(const QString& string)
{
    // first commit the pre-edit string if any.
    actionHandler(HbInputModeActionCommit);
    commitAndUpdate(string);
}

/*!
Ignores currently active pre-edit text if any and directly commits the passed string in to the editor. This
function also updates the inputmethod state.
*/
void HbInputModeHandler::commitAndUpdate(const QString& string, int replaceFrom, int replaceLength, bool isAsync)
{
    Q_D(HbInputModeHandler);
    HbInputFocusObject *focusObject = 0;
    focusObject = d->mInputMethod->focusObject();
    if (!focusObject) {
        qDebug("HbInputModeHandler::commitAndUpdate no focusObject ... failed!!");
        return ;
    }

    QString filtered;
    focusObject->filterStringWithEditorFilter(string, filtered);

    // now commit the string which is passed in.
    QList<QInputMethodEvent::Attribute> list;

    if(isAsync) {
        QInputMethodEvent *event = new QInputMethodEvent(QString(), list);
        event->setCommitString(filtered, replaceFrom, replaceLength);
        focusObject->postEvent(*event);
    } else {
        QInputMethodEvent event;
        event.setCommitString(filtered, replaceFrom, replaceLength);
        focusObject->sendEvent(event);
    }
    d->mInputMethod->updateState();
}

/*!
Sends the passed event to the focused object and upates the inputmethod state.
*/
void HbInputModeHandler::sendAndUpdate(QEvent& event)
{
    Q_D(HbInputModeHandler);
    HbInputFocusObject *focusObject = 0;
    focusObject = d->mInputMethod->focusObject();
    if (!focusObject) {
        qDebug("HbInputModeHandler::sendAndUpdate no focusObject ... failed!!");
        return;
    }

    focusObject->sendEvent(event);
    d->mInputMethod->updateState();
}

void HbInputModeHandler::setKeymap(const HbKeymap* keymap)
{
    Q_D(HbInputModeHandler);
    d->mKeymap = keymap;
}

/*!
Toggles prediction after doing a check if the editor allows it.
*/
void HbInputModeHandler::togglePrediction()
{
    Q_D(HbInputModeHandler);
    bool currentStatus = HbInputSettingProxy::instance()->predictiveInputStatusForActiveKeyboard();
    HbInputFocusObject* focusedObject = 0;
    focusedObject = d->mInputMethod->focusObject();
    bool isPredictionAllowed = focusedObject->editorInterface().isPredictionAllowed();
    if (currentStatus) {
        HbInputSettingProxy::instance()->setPredictiveInputStatusForActiveKeyboard(false);
    } else if (isPredictionAllowed) {
        HbInputSettingProxy::instance()->setPredictiveInputStatusForActiveKeyboard(true);
    }
}

#include "moc_hbinputmodehandler.cpp"
// EOF