/****************************************************************************
**
** 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 <QTimer>
#include <hbinputmethod.h>
#include <hbinputkeymapfactory.h>
#include <hbinputpredictionengine.h>
#include <hbinputbutton.h>
#include <QTextCharFormat>
#include <HbColorScheme>
#include "hbinputpredictionqwertyhandler.h"
#include "hbinputpredictionhandler_p.h"
#include "hbinputabstractbase.h"

class HbInputPredictionQwertyHandlerPrivate: public HbInputPredictionHandlerPrivate
{
    Q_DECLARE_PUBLIC(HbInputPredictionQwertyHandler)
public:
    HbInputPredictionQwertyHandlerPrivate();
    ~HbInputPredictionQwertyHandlerPrivate();
    void deleteOneCharacter();

public:
    bool buttonPressed(const QKeyEvent *event);
    bool buttonReleased(const QKeyEvent *event);
    void init();
    void updateEditor();
    void commitSecondaryWord();
    QString getCommitString();
    void showExactWordPopupIfNeeded();

public:
    int mButton;    
    HbFnState mFnState;
    bool mExactPopupLaunched;    
    bool mShowExactWordInTooltip;
    int mPrimaryCandidateIndex;
    int mSecondaryCandidateIndex;
    int mTypingCorrectionLevel;
    HbTypingCorrectionLevel mCorrectionLevel;
};

HbInputPredictionQwertyHandlerPrivate::HbInputPredictionQwertyHandlerPrivate()
:mButton(0),    
    mFnState(HbFnOff),
    mExactPopupLaunched(false)
{
}

HbInputPredictionQwertyHandlerPrivate::~HbInputPredictionQwertyHandlerPrivate()
{
}

void HbInputPredictionQwertyHandlerPrivate::init()
{
}

bool HbInputPredictionQwertyHandlerPrivate::buttonReleased(const QKeyEvent *event)
{
    Q_Q(HbInputPredictionQwertyHandler);
    HbInputFocusObject *focusObject = 0;
    focusObject = mInputMethod->focusObject();
    if (!focusObject) {
        qDebug("HbVirtualQwerty::virtualButtonClicked : no focused editor widget!");
        return false;
    }


    int key = event->key();
    
    bool ret = true;
    switch(key) {    
    case Qt::Key_Alt:  //Fn
        if (mFnState == HbFnOff) {
                mFnState = HbFnNext;
            } else if (mFnState == HbFnNext) {
                mFnState = HbFnOn;
            } else {
                mFnState = HbFnOff;
            }
        break;
    case HbInputButton::ButtonKeyCodeShift: {
            HbTextCase currentTextCase = (HbTextCase)focusObject->editorInterface().textCase();
            HbInputLanguage language = mInputMethod->inputState().language();

            // Update the Case Information in HbInputState, it internally updates in HbEditorInterface as well
            switch(currentTextCase) {
            case HbTextCaseLower:
                // For Case-insensitive languages, Shift Key is used to switch between character sets (i.e lower case characters and shifted characters)
                if(!language.isCaseSensitiveLanguage()){
                    currentTextCase = HbTextCaseUpper; 
                }
                else {
                    currentTextCase = HbTextCaseAutomatic;
                }
                break;              
            case HbTextCaseUpper:   
                currentTextCase = HbTextCaseLower;              
                break;
            case HbTextCaseAutomatic:
                currentTextCase = HbTextCaseUpper;                              
                break;
            default:
                break;
            }
            HbInputState state = mInputMethod->inputState();
            state.setTextCase(currentTextCase);         
            mInputMethod->activateState(state);
        }
        break;
    case HbInputButton::ButtonKeyCodeSymbol: { // Ctrl/Chr
    case HbInputButton::ButtonKeyCodeAlphabet:
        mInputMethod->switchSpecialCharacterTable();
        }       
        break;
    case HbInputButton::ButtonKeyCodeSettings:
        mInputMethod->closeExactWordPopup();
        break;
    default: {
            HbTextCase currentTextCase = focusObject->editorInterface().textCase();
            Qt::KeyboardModifiers modifiers = Qt::NoModifier;
            if (mFnState == HbFnNext) {
                modifiers |= Qt::AltModifier;
                mFnState = HbFnOff;
            } else if (mFnState == HbFnOn) {
                modifiers |= Qt::AltModifier;
            }
            // If shift is pressed, the shifted characters have to be input.
            if ( HbTextCaseUpper == currentTextCase || HbTextCaseAutomatic == currentTextCase ) {
                modifiers |= Qt::ShiftModifier;
            }


            // let's pass it to the base class.
            ret = q->HbInputPredictionHandler::filterEvent(event);

            mInputMethod->updateState();
        }
        break;
    };
    return ret;
}

bool HbInputPredictionQwertyHandlerPrivate::buttonPressed(const QKeyEvent *event)
{
    if (event->isAutoRepeat() && mButton == event->key()) {
        if (mButton == HbInputButton::ButtonKeyCodeSymbol) {
            mInputMethod->selectSpecialCharacterTableMode();
            mButton = 0;        
            return true;
        }
    }
        
    mButton = event->key();
    return false;
}


HbInputPredictionQwertyHandler::HbInputPredictionQwertyHandler(HbInputAbstractMethod *inputMethod)
    :HbInputPredictionHandler(* new HbInputPredictionQwertyHandlerPrivate, inputMethod)
{
    Q_D(HbInputPredictionQwertyHandler);
    d->q_ptr = this;
    d->init();
}

HbInputPredictionQwertyHandler::~HbInputPredictionQwertyHandler()
{
}

/*!
Action Handler.
*/
bool HbInputPredictionQwertyHandler::actionHandler(HbInputModeAction action)
{
    Q_D(HbInputPredictionQwertyHandler);
    bool ret = true;
    switch (action) {
        case HbInputModeActionCancelButtonPress:
            break;
        case HbInputModeActionFocusRecieved:
            HbInputPredictionHandler::actionHandler(HbInputModeActionSetCandidateList);
            HbInputPredictionHandler::actionHandler(HbInputModeActionSetKeypad);
            break;
        case HbInputModeActionFocusLost:
            HbInputPredictionHandler::actionHandler(HbInputModeActionFocusLost);

            //TODO
            /*
            if (d->mExactPopupLaunched) {
                sendCommitString(d->mCandidates->at(1));
            } else {
                sendCommitString(d->mCandidates->at(0));
            }
            */
            // close exactword popup.
            d->mInputMethod->closeExactWordPopup();
            break;
        default: 
            ret = HbInputPredictionHandler::actionHandler(action);
    }
    return ret;
}

/*!
filterEvent for key event.
*/
bool HbInputPredictionQwertyHandler::filterEvent(const QKeyEvent * event)
{
    Q_D(HbInputPredictionQwertyHandler);

    if (event->type() == QEvent::KeyRelease) {
        return d->buttonReleased(event);
    } else {
        return d->buttonPressed(event);
    }
}

/*!
Commits the word and closes the exact popup if it is visible.
*/
void HbInputPredictionQwertyHandler::commitAndUpdate(const QString& string, int replaceFrom, int replaceLength)
{
    Q_D(HbInputPredictionQwertyHandler);
    HbInputModeHandler::commitAndUpdate(string, replaceFrom, replaceLength);
    d->mInputMethod->closeExactWordPopup();
    d->mExactPopupLaunched = false;  
}

/*!
    this function deletes one character and updates the engine and editor.
*/
void HbInputPredictionQwertyHandler::deleteOneCharacter()
{
    Q_D(HbInputPredictionHandler);
    d->deleteOneCharacter();
}

/*!
 this function is called by HbPredictionHandler when HbPredictionHandler encounters a exact word.
*/
void HbInputPredictionQwertyHandler::processExactWord(QString exactWord)
{
    Q_D(HbInputPredictionQwertyHandler);
    if (exactWord.size()) {
        d->mInputMethod->launchExactWordPopup(exactWord);
        d->mExactPopupLaunched = true;
    } else {
        d->mInputMethod->closeExactWordPopup();
        d->mExactPopupLaunched = false;
    }
}

/*!
 this slot should be called when exact word popup is closed.
*/
void HbInputPredictionQwertyHandler::exactWordPopupClosed()
{
    commitExactWord();
}

void HbInputPredictionQwertyHandler::exactWordSelected()
{
    Q_D(HbInputPredictionQwertyHandler);    
    d->commitSecondaryWord();
}

void HbInputPredictionQwertyHandler::sctCharacterSelected(QString character)
{   
    HbInputPredictionHandler::sctCharacterSelected(character);
}

void HbInputPredictionQwertyHandler::smileySelected(QString smiley)
{
    HbInputPredictionHandler::smileySelected(smiley);
}

/*!
Returns true if preidciton engine is available and initialized.
*/
bool HbInputPredictionQwertyHandler::isActive() const
{ 
    Q_D(const HbInputPredictionQwertyHandler);
    return d->mEngine != 0;
}

void HbInputPredictionQwertyHandlerPrivate::deleteOneCharacter()
{
    if (!mEngine && !mInputMethod->focusObject()) {
        return;
    }
    mShowTail = true;
    mShowTooltip = true;
    // A backspace in predictive means updating the engine for the delete key press
    // and get the new candidate list from the engine.
    if ( mEngine->inputLength() >= 1 ) {
        //Only autocomplition part should be deleted when autocompliton part is enable and user pressed a delete key
        //To prevent showing autocompletion part while deleting the characters using backspace key
        mShowTail = false;
        mShowTooltip = false;
        //The assumption here is that with deletion of a character we always
        //can go on with prediction. This is because when we delete a key press
        //we actually reduce ambiguity in the engine and hence we should have
        //some word getting predicted as a result to that.
        mCanContinuePrediction = true;

        int tailLength =  mInputMethod->focusObject()->preEditString().length() - mEngine->inputLength();
        if( true == mExactPopupLaunched ) {
            mEngine->deleteKeyPress();
            mEngine->updateCandidates(mBestGuessLocation);
        }

        mBestGuessLocation = 0;
        if(mCandidates->count() && (mCandidates->count()>mBestGuessLocation) && tailLength <= 0 && false == mExactPopupLaunched) {
            QString currentWord = mCandidates->at(mBestGuessLocation);
            if(currentWord.length()) {
                currentWord.chop(1);
                mEngine->deleteKeyPress();
                //We are not supposed to re-construct the candidate list as deletion
                //does not cause reprediction. Also, candidate list construction is the
                //heaviest operation out of all engine operations.
                (*mCandidates)[mBestGuessLocation] = currentWord;
            } else {
                commit(QString(""),false);
            }

        } else if(!mCandidates->count() && mEngine->inputLength() >= 1) {
            //If Input length greater or equal to one then Append the current word to candidate 
            mCandidates->append(mEngine->currentWord());
        }
        // update the editor with the new preedit text.
        updateEditor();
        return;
    } else {
        // we come here if their is no data in engine.
        // once the word is committed, we can not bring it back to inline edit.
        // so if the engine does not have any data, we just send backspace event to the editor.
        Q_Q(HbInputPredictionQwertyHandler);
        QKeyEvent event = QKeyEvent(QEvent::KeyPress, Qt::Key_Backspace, Qt::NoModifier);       
        q->sendAndUpdate(event);
        event = QKeyEvent(QEvent::KeyRelease, Qt::Key_Backspace, Qt::NoModifier);
        q->sendAndUpdate(event);
        return;
    }
}

void HbInputPredictionQwertyHandler::setPrimaryCandidateMode(HbPrimaryCandidateMode mode)
{
    Q_D(HbInputPredictionQwertyHandler);
    if(mode == HbPrimaryCandidateModeExactTyping) {
        d->mShowExactWordInTooltip = false;
    } else {
        d->mShowExactWordInTooltip = true;
    }
    // we need to close the exact word popup when this happens.
    d->mInputMethod->closeExactWordPopup();
    d->mExactPopupLaunched = false;
}

void HbInputPredictionQwertyHandlerPrivate::updateEditor()
{
    Q_Q(HbInputPredictionQwertyHandler);
    if (!mEngine) {
        return;
    }
    HbInputFocusObject *focusedObject = 0;
    QList<QInputMethodEvent::Attribute> list;
    focusedObject = mInputMethod->focusObject();
    QTextCharFormat underlined;    
    underlined.setFontUnderline(true);

    Q_ASSERT(focusedObject);
    if (mEngine->inputLength() == 0) {
        QInputMethodEvent event(QString(), list);
        q->sendAndUpdate(event);
    } else {
        if (mCandidates->count() > 0) {
            // index of the candidate that is shown on the typing line
            mPrimaryCandidateIndex = mBestGuessLocation;
            // index of the candidate that is shown in the tooltip (if any)
            mSecondaryCandidateIndex = 0;    
            QString bestGuessWord = mCandidates->at(mBestGuessLocation);
            QString exactTypedWord = mCandidates->at(0);
            bool hasAutocompletionPart = (bestGuessWord.length() > exactTypedWord.length()) && (bestGuessWord.left(exactTypedWord.length()) == exactTypedWord);            
            // when we are showing the autocompletion part we generally do not show the tooltip,
            // both primary and secondary candidates are the same.
            if(hasAutocompletionPart && mAutocompletionEnabled && mShowTail) {
                mPrimaryCandidateIndex = mSecondaryCandidateIndex = mBestGuessLocation;                
            }
            // in case of exact tying, exact typed word in the primary candidate
            // and the best predicted word is the secondary candidate
            if(!mShowExactWordInTooltip && !(hasAutocompletionPart && mAutocompletionEnabled)) {
                mPrimaryCandidateIndex = 0;
                mSecondaryCandidateIndex = mBestGuessLocation;
            }
            if (hasAutocompletionPart && mShowTail && mAutocompletionEnabled) {
                // showing the word with auto completion
                int taillength = bestGuessWord.length() - exactTypedWord.length();
                // TODO: Color from skin should be used
                QColor col = HbColorScheme::color("qtc_input_hint_normal");
                QBrush brush(col);
                // underline formatting is applied to only the input length part of the word
                QInputMethodEvent::Attribute textstyle(QInputMethodEvent::TextFormat, 0, mEngine->inputLength(), underlined);
                list.append(textstyle);

                QTextCharFormat gray;
                gray.setForeground(brush);
                if((focusedObject->object())->inherits("QGraphicsWebView") || (focusedObject->object())->inherits("QWebView")) {
                    //QGraphicsWebView does not handle partial input length formatting well. Causes crash, a temporary fix provided,
                    //This makes the whole text field grey insted of just the auto-completion part. Anyways, it does not cause crash.
                    //This should be treated as a work around till QGraphicsWebView is fixed.
                    list.append(QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat, 0, QInputMethodEvent::TextFormat, gray));
                } else {
                    list.append(QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat, mEngine->inputLength(), taillength, gray));
                }               
                list.append(QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, mEngine->inputLength(), 0, 0));
                // the best guess word is sent to the editor
                QInputMethodEvent event(bestGuessWord, list);
                focusedObject->sendEvent(event);
            } else {
                QInputMethodEvent::Attribute textstyle(QInputMethodEvent::TextFormat, 0, mCandidates->at(mPrimaryCandidateIndex).length(), underlined);
                list.append(textstyle);
                list.append(QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, mCandidates->at(mPrimaryCandidateIndex).length(), 0, 0));
                QInputMethodEvent event(mCandidates->at(mPrimaryCandidateIndex), list);
                focusedObject->sendEvent(event);
            }

            if (mShowTooltip && mPrimaryCandidateIndex != mSecondaryCandidateIndex) {                
                q->processExactWord(mCandidates->at(mSecondaryCandidateIndex));
            } else {
                QString empty;
                q->processExactWord(empty);
            }
        } else {
            QInputMethodEvent event(QString(""), list);
            focusedObject->sendEvent(event);
        }
    }
}

void HbInputPredictionQwertyHandlerPrivate::commitSecondaryWord()
{
    if(mCandidates->count()>mSecondaryCandidateIndex) {
        QString commitString = mCandidates->at(mSecondaryCandidateIndex);
        commit(commitString, true, false);
    }
}

void HbInputPredictionQwertyHandlerPrivate::showExactWordPopupIfNeeded()
{
    Q_Q(HbInputPredictionHandler);
    if (mShowTooltip && mCandidates && mCandidates->count() > mSecondaryCandidateIndex && mPrimaryCandidateIndex != mSecondaryCandidateIndex) {                
        q->processExactWord(mCandidates->at(mSecondaryCandidateIndex));
    } else {
        QString empty;
        q->processExactWord(empty);
    }
}

QString HbInputPredictionQwertyHandlerPrivate::getCommitString()
{
    QString commitString;
    if(mCandidates->count() <= mPrimaryCandidateIndex) {
        commitString = mCandidates->at(0);
    } else {
        commitString = mCandidates->at(mPrimaryCandidateIndex);
    }
    return commitString;
}

void HbInputPredictionQwertyHandler::setTypingCorrectionLevel(HbTypingCorrectionLevel correctionLevel)
{
    Q_D(HbInputPredictionQwertyHandler);
    HbPredictionEngine::HbErrorCorrectionLevel errorCorrectionLevel = HbPredictionEngine::HbErrorCorrectionLevelMedium;
    if(d->mCorrectionLevel == correctionLevel) {
        return;
    }
    d->mCorrectionLevel = correctionLevel;
    switch(correctionLevel) {
        case HbTypingCorrectionLevelLow:
            errorCorrectionLevel = HbPredictionEngine::HbErrorCorrectionLevelLow;
            break;
        case HbTypingCorrectionLevelMedium:
            errorCorrectionLevel = HbPredictionEngine::HbErrorCorrectionLevelMedium;
            break;
        case HbTypingCorrectionLevelHigh:
            errorCorrectionLevel = HbPredictionEngine::HbErrorCorrectionLevelHigh;
            break;
        default:
            break;
    }
    if(d->mEngine) {
        d->mEngine->setErrorCorrectionLevel(errorCorrectionLevel);
    }
}

//EOF