/****************************************************************************
**
** 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 <hbinputkeymap.h>
#include <hbinputkeymapfactory.h>
#include <hbinputsettingproxy.h>

#include "hbinputabstractbase.h"
#include "hbinputbasichandler_p.h"
#include "hbinputmodehandler_p.h"
#include "hbhardwareinputbasicqwertyhandler.h"

class HbHardwareInputBasicQwertyHandlerPrivate: public HbInputBasicHandlerPrivate
{
    Q_DECLARE_PUBLIC(HbHardwareInputBasicQwertyHandler)
public:
    HbHardwareInputBasicQwertyHandlerPrivate();
    ~HbHardwareInputBasicQwertyHandlerPrivate();

    // button related operations.
    bool buttonPressed(const QKeyEvent *event);
    bool buttonReleased(const QKeyEvent *event);
    void _q_timeout();

public:
    HbFnState mFnState;
    int mButton;
    HbInputShiftKeyState mShiftKeyState;
};

HbHardwareInputBasicQwertyHandlerPrivate::HbHardwareInputBasicQwertyHandlerPrivate()
:mFnState(HbFnOff),
mButton(0),
mShiftKeyState(EKeyPressedNone)
{
}

HbHardwareInputBasicQwertyHandlerPrivate::~HbHardwareInputBasicQwertyHandlerPrivate()
{
}

bool HbHardwareInputBasicQwertyHandlerPrivate::buttonPressed(const QKeyEvent * event)
{
	mButton = event->key();
	if (!mTimer->isActive()){
		mTimer->start(HbLongPressTimerTimeout);
	}

	if (event->key() != Qt::Key_Delete && event->key() != Qt::Key_Backspace) {
		return true;
	} else {
		return false;
	}
}

bool HbHardwareInputBasicQwertyHandlerPrivate::buttonReleased(const QKeyEvent * event)
{
// Kept for handling button released specific logic
	
	Q_Q(HbHardwareInputBasicQwertyHandler);
	HbInputFocusObject *focusObject = 0;
    focusObject = mInputMethod->focusObject();
    if (!focusObject) {
        qDebug("HbHardwareInputBasicQwertyHandler::virtualButtonClicked : no focused editor widget!");
        return false;
    }
	
	// If the timer is not active and it is alpha mode, it is a long press
    // and handled in another function. So just return.
    if (mTimer->isActive()) {
        mTimer->stop();
    }
	int eventKey = event->key();

	//Handle long key press here
   
    switch(eventKey) {
    case Qt::Key_Alt:
		//handle function key (fn key) states here using fn & shift handler helper class
		break;
    case Qt::Key_Shift: {
        //If the shift key state is EShiftKeyPressed and a second shift key press is received before any other
        //key events, then current text case should not be changed.
        if (mShiftKeyState){
            mShiftKeyState = EKeyPressedNone;
        } else {
            mShiftKeyState = EShiftKeyPressed;
            int currentTextCase = focusObject->editorInterface().textCase();
            switch(currentTextCase) {
            case HbTextCaseLower:
                focusObject->editorInterface().setTextCase(HbTextCaseUpper);
                focusObject->syncEditorInterface();
                break;
            case HbTextCaseUpper:
            case HbTextCaseAutomatic:
                focusObject->editorInterface().setTextCase(HbTextCaseLower);
                focusObject->syncEditorInterface();
                break;
            default:
                break;
            }
        }
    }
        break;
    case Qt::Key_Control:{
		return true;
		}
		
		break;
	case Qt::Key_Backspace:
	case Qt::Key_Delete: {
		// let's pass the backspace event to the focussed editor.
		//return q->HbInputBasicHandler::filterEvent(event);
		break;
	}
	case Qt::Key_Return:
	case Qt::Key_Enter:
	case Qt::Key_Space: {
		QChar qc(eventKey);
		if(Qt::Key_Space == eventKey && (event->modifiers() & Qt::ControlModifier)){
			if (HbInputSettingProxy::instance()->predictiveInputStatus()) {
					HbInputSettingProxy::instance()->setPredictiveInputStatus(0);
				} else {
					HbInputSettingProxy::instance()->setPredictiveInputStatus(1);
				}
			break;
		}

		if (qc == Qt::Key_Enter || qc == Qt::Key_Return) {
			qc = QChar('\n');  // Editor expects normal line feed.
		}
		if(focusObject){
			q->commitAndUpdate(qc);	
		}
		break;
		}
    default: {
		if (q->HbInputBasicHandler::filterEvent(event)) {
				return true;
			}   
		QList<QInputMethodEvent::Attribute> list;
        QString newText;
        int currentTextCase = focusObject->editorInterface().textCase();
        // If function key is pressed, get the functionized 
        
        QString chars;

        const HbMappedKey* mappedKey = mKeymap->keyForKeycode(mInputMethod->inputState().keyboard(), eventKey);
        
        if (currentTextCase == HbTextCaseLower)
           chars = mappedKey->characters(HbModifierNone);
        else
           chars = mappedKey->characters(HbModifierShiftPressed);

        if(chars.length()){
            q->commitAndUpdate(chars);
        }

        // Reset the shift state.
        if (EShiftKeyPressed == mShiftKeyState) {
            mShiftKeyState = EKeyPressedNone;
            int textCase = HbTextCaseLower;
            HbModifier modifier = HbModifierNone;

            if (HbTextCaseLower == currentTextCase) {
                textCase = HbTextCaseUpper;
                modifier = HbModifierShiftPressed;
            }
            focusObject->editorInterface().setTextCase(textCase);
            focusObject->syncEditorInterface();
        }
        mInputMethod->updateState();
        }
        break;
    }	
	return true;
}

void HbHardwareInputBasicQwertyHandlerPrivate::_q_timeout()
{
    mTimer->stop();
	qDebug("Timer stoped");
	if (mButton == Qt::Key_Shift ){
        mShiftKeyState = EShiftKeyPressed;
	} else {		
		mFnState = HbFnNext;
	}
	return;
}

HbHardwareInputBasicQwertyHandler::HbHardwareInputBasicQwertyHandler(HbInputAbstractMethod* inputMethod)
:HbInputBasicHandler(* new HbHardwareInputBasicQwertyHandlerPrivate, inputMethod)
{
    Q_D(HbHardwareInputBasicQwertyHandler);
    d->q_ptr = this;
}


/*!
This function lists different input modes.
*/
void HbHardwareInputBasicQwertyHandler::listInputModes(QVector<HbInputModeProperties>& modes) const
{
    HbInputModeProperties binding;
	binding.iMode = HbInputModeDefault;
	QList<HbKeyboardType> availableKeyBoards;
	HbInputSettingProxy::instance()->availableHwKeyboard(availableKeyBoards);
	foreach(HbKeyboardType keyboardType, availableKeyBoards) {
		(keyboardType&HbQwertyKeyboardMask) ? binding.iKeyboard = keyboardType : binding.iKeyboard = HbKeyboardNone;
		if (binding.iKeyboard != HbKeyboardNone) {
			QList<HbInputLanguage> languages = HbKeymapFactory::availableLanguages();
			foreach(HbInputLanguage lang, languages) {
				binding.iLanguage = lang;        
				modes.push_front(binding);
			}
		}
	}
}

HbHardwareInputBasicQwertyHandler::~HbHardwareInputBasicQwertyHandler()
{
}

/*!
filterEvent function key handling.
*/
bool HbHardwareInputBasicQwertyHandler::filterEvent(const QKeyEvent* event)
{
    Q_D(HbHardwareInputBasicQwertyHandler);

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

/*!
returns true if in inline edit.
*/
bool HbHardwareInputBasicQwertyHandler::isComposing() const
{   
    Q_D(const HbHardwareInputBasicQwertyHandler);
    return d->mTimer->isActive();
}

/*!
Action handler
*/
bool HbHardwareInputBasicQwertyHandler::actionHandler(HbInputModeAction action)
{
    Q_D(HbHardwareInputBasicQwertyHandler);
    bool ret = true;
    switch (action) {
    case HbInputModeActionReset:
        if (d->mTimer->isActive()) {
            d->mTimer->stop();
			qDebug("Timer stoped");
        }
        break;
    default: {
        ret = HbInputBasicHandler::actionHandler(action);
        }
    }
    return ret;
}

/*!
this SLOT is called by input plugin when there is a character selected from character preview pane.
*/
void HbHardwareInputBasicQwertyHandler::charFromPreviewSelected(QString characters)
{
    Q_D(HbHardwareInputBasicQwertyHandler);
    if(characters.size() > 0) {
        sctCharacterSelected(characters[0]);
        d->mInputMethod->updateState();
    }
}

void HbHardwareInputBasicQwertyHandler::sctCharacterSelected(QChar character)
{
    HbInputModeHandler::sctCharacterSelected(character);
}