/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, version 2.1 of the License.

* 

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not, 

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:

*

*/

#include <QDebug>

#include <QApplication>

#include <QKeyEvent>

#include <QLabel>

#include <QVBoxLayout>

#include <QStackedWidget>

#include <QImageReader>

#include <QDebug>

#include <QTimer>

#include <QPushButton>

#include <QLineEdit>

#include <QDebug>

#include <QString>

#include <QCheckBox>

#include <QPlainTextEdit>

#include <QString>

#include <QMenu>

#include <QMenuBar>

#include <QAction>

#include <QEvent>

#include "keycapturetestapp.h"

#include "txlogger.h"

KeyCaptureTestApp::KeyCaptureTestApp( QWidget *parent) : QMainWindow(parent)

{

    TX_ENTRY

//    qApp->installEventFilter(this);

//    QCoreApplication::instance()->installEventFilter(this);

	setWindowTitle(tr("KeyCaptureTestApp"));

    mKeyCapture = new XqKeyCapture();

    mKeysMap.insert("Up", Qt::Key_Up);

    mKeysMap.insert("Down", Qt::Key_Down);

    mKeysMap.insert("Manu", Qt::Key_Launch0);

    mKeysMenu = new QMenu(this);

    foreach (QString value, mKeysMap.keys())

        mKeysMenu->addAction(value)->setData( QVariant(value) );

    mLongFlagsMap.insert("LongNormal", XqKeyCapture::LongNormal);

    mLongFlagsMap.insert("LongRepeatEvents", XqKeyCapture::LongRepeatEvents);

    mLongFlagsMap.insert("LongShortEventImmediately", XqKeyCapture::LongShortEventImmediately);

    mLongFlagsMap.insert("LongWaitNotApplicable", XqKeyCapture::LongWaitNotApplicable);

    mLongFlagsMap.insert("LongWaitShort", XqKeyCapture::LongWaitShort);

    mLongFlagsMenu = new QMenu(this);

    foreach (QString value, mLongFlagsMap.keys())

        mLongFlagsMenu->addAction(value)->setData( QVariant(value) );

	QMenu *captureMenu = menuBar()->addMenu(QString("Capture"));

    connect(captureMenu, SIGNAL(triggered(QAction*)), this, SLOT(triggered(QAction*)));

	captureMenu->addAction(QString("Key"))->setData( QVariant(1) );

	captureMenu->addAction(QString("Long Key"))->setData( QVariant(2) );

	captureMenu->addAction(QString("Up and Down Key"))->setData( QVariant(3) );

	QMenu *cancelCaptureMenu = menuBar()->addMenu(QString("Cancel Capture"));

    connect(cancelCaptureMenu, SIGNAL(triggered(QAction*)), this, SLOT(triggered(QAction*)));

	cancelCaptureMenu->addAction(QString("Cancel Key"))->setData( QVariant(4) );

	cancelCaptureMenu->addAction(QString("Cancel Long Key"))->setData( QVariant(5) );

	cancelCaptureMenu->addAction(QString("Cancel Up and Down Key"))->setData( QVariant(6) );

    connect(menuBar()->addAction(QString("Clear Log")), SIGNAL(triggered()), this, SLOT(cleanLog()));

    connect(menuBar()->addAction(QString("Exit")), SIGNAL(triggered()), qApp, SLOT(quit()));

    QWidget *window = new QWidget;

    QVBoxLayout* layout = new QVBoxLayout;

	mTextArea = new QPlainTextEdit("Log area\n");

	layout->addWidget(mTextArea);

    window->setLayout(layout);

    setCentralWidget(window);

    window->show();;

    TX_EXIT

}

KeyCaptureTestApp::~KeyCaptureTestApp()

{

}

void KeyCaptureTestApp::triggered(QAction* aAction)

{

    CaptureRequest request;

    if (!request.setType(aAction)){

        return;

    }

    if (!request.setKey(mKeysMenu->exec(), &mKeysMap)){

        return;

    }

//TODO: add modifiersMap selection menu;

//TODO: add modifier selection menu;

    if ( request.mRequestType == CaptureRequest::RequestTypeLongKey || request.mRequestType == CaptureRequest::RequestTypeCancelLongKey){

        if (!request.setLongFlags(mLongFlagsMenu->exec(), &mLongFlagsMap)){

            return;

        }

    }

    procesAction(request);

}

void KeyCaptureTestApp::cleanLog()

{

    mTextArea->setPlainText("");

}

void KeyCaptureTestApp::procesAction(CaptureRequest request)

{

    TX_ENTRY

    switch (request.mRequestType){

        case CaptureRequest::RequestTypeKey :

            mKeyCapture->captureKey(request.mKey, request.mModifiersMap, request.mModifier );

            addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString()));

            break;

        case CaptureRequest::RequestTypeLongKey :

            mKeyCapture->captureLongKey(request.mKey, request.mModifiersMap, request.mModifier, request.mLongFlags);

            addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString()));

            break;

        case CaptureRequest::RequestTypeKeyUpAndDowns :

            mKeyCapture->captureKeyUpAndDowns(request.mKey, request.mModifiersMap, request.mModifier );

            addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString()));

            break;

        case CaptureRequest::RequestTypeCancelKey :

            mKeyCapture->cancelCaptureKey(request.mKey, request.mModifiersMap, request.mModifier );

            addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString()));

            break;

        case CaptureRequest::RequestTypeCancelLongKey :

            mKeyCapture->cancelCaptureLongKey(request.mKey, request.mModifiersMap, request.mModifier, request.mLongFlags);

            addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString()));

            break;

        case CaptureRequest::RequestTypeCancelKeyUpAndDowns :

            mKeyCapture->cancelCaptureKeyUpAndDowns(request.mKey, request.mModifiersMap, request.mModifier );

            addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString()));

            break;

        default:

            break;

    }

    TX_EXIT    

}

void KeyCaptureTestApp::addTextLine(QString aText)

{

    TX_LOG_ARGS( QString("aText=%1").arg(aText));

	if ( !aText.endsWith("\n"))

		aText = aText + "\n";

	QString msg = mTextArea->toPlainText();

	msg = aText + msg;

	mTextArea->setPlainText(msg);

}

bool KeyCaptureTestApp::event(QEvent *ev)

{

    processEvent(ev);

    return QMainWindow::event(ev);

}

bool KeyCaptureTestApp::eventFilter(QObject *o, QEvent *ev)

{

    processEvent(ev);

    return QMainWindow::eventFilter(o, ev);

}

void KeyCaptureTestApp::processEvent(QEvent *ev)

{

    if (ev){

       if (ev->type() == QEvent::KeyPress){

           QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);

           addTextLine(QString("KeyPress:%1\n").arg(keyEvent->key(), 0, 16) );

       }else if (ev->type() == QEvent::KeyRelease){

           QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);

           addTextLine(QString("KeyRelease:%1\n").arg(keyEvent->key(), 0, 16) );

       }

    }

}

CaptureRequest::CaptureRequest()

{

    mRequestType = RequestTypeUndefined;

    mKey = Qt::Key_unknown;    

    mModifiersMap = Qt::NoModifier;

    mModifier = Qt::NoModifier;

    mLongFlags = XqKeyCapture::LongNormal; 

}

CaptureRequest::~CaptureRequest()

{

}

QString CaptureRequest::toString()

{

    QString res = "Request ";

    switch (mRequestType){

        case CaptureRequest::RequestTypeKey :

            res +="Key(";

            break;

        case CaptureRequest::RequestTypeLongKey :

            res +="LongKey(";            

            break;

        case CaptureRequest::RequestTypeKeyUpAndDowns :

            res +="UpAndDowns(";  

            break;

        case CaptureRequest::RequestTypeCancelKey :

            res +="CancelKey(";

            break;

        case CaptureRequest::RequestTypeCancelLongKey :

            res +="CancelLongKey(";

            break;

        case CaptureRequest::RequestTypeCancelKeyUpAndDowns :

            res +="CancelUpAndDowns(";

            break;

        default:

            res +="Unknown";

            break;

    }

    if ( mRequestType == RequestTypeUndefined)

        return res;

    res +=QString("%1").arg(mKey, 0, 16);

    //TODO::put to res mModifiersMap    

    //TODO::put to res mModifier

    if ( mRequestType == RequestTypeLongKey || mRequestType == RequestTypeCancelLongKey)

        res +=QString(",%1)").arg(mLongFlags, 0, 16);

    else

        res +=")";

    return res;

}

bool CaptureRequest::setType(QAction* action)

{

    if (!action)

        return false;

    bool ok;

    int act = action->data().toInt(&ok);

    if (ok){

        switch (act){

            case 1 : mRequestType = RequestTypeKey; break;

            case 2 : mRequestType = RequestTypeLongKey; break;

            case 3 : mRequestType = RequestTypeKeyUpAndDowns; break;

            case 4 : mRequestType = RequestTypeCancelKey; break;

            case 5 : mRequestType = RequestTypeCancelLongKey; break;

            case 6 : mRequestType = RequestTypeCancelKeyUpAndDowns; break;

        }

        return mRequestType!=RequestTypeUndefined;

    }else{

        return false;

    }

}

bool CaptureRequest::setKey(QAction* action, QMap<QString, Qt::Key> *map)

{

    if (!action || !map || map->count()==0)

        return false;

    QString key = action->data().toString();

    if ( !key.isNull() && map->contains(key)){

        mKey = map->value(key);

        return true;

    }

    return false;

}

bool CaptureRequest::setLongFlags(QAction* action, QMap<QString, XqKeyCapture::LongFlags> *map)

{

    if (!action || !map || map->count()==0)

        return false;

    QString flag = action->data().toString();

    if ( !flag.isNull() && map->contains(flag)){

        mLongFlags = map->value(flag);

        return true;

    }

    return false;

}