/*
 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 *
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description: QT C++ main window Class.
 *
 */

#include <QAction>
#include <QMenuBar>
#include <QMenu>
#include <QGridLayout>
#include <QTreeWidgetItem>
#include <QKeyEvent>
#include <QFile>
#include <QLatin1String>
#include <QApplication>
#include "mainwindow.h"
#include <symbianunittestversion.h>
#include "dialogaddtests.h"
#include "tabwidgettestrun.h"
#include "dialogsettings.h"
#include "dialogmsg.h"

static const QString APPNAME = "symbianunittestqt";
static const QString STYLESHEET = ":/qss/coffee.qss";
//Symbian EKeyLeftArrow = 0x807
static const int KeyLeftArrow = 63495;
//Symbian EKeyRightArrow = 0x808
static const int KeyRightArrow = 63496;
//Symbian EKeyUpArrow = 0x809
static const int KeyUpArrow = 63497;
//Symbian EKeyDownArrow = 0x80a
static const int KeyDownArrow = 63498;
//Symbian EKeyEnter = 0x10
static const int KeyEnter = 0x10;

MainWindow::MainWindow(QWidget* parent) :
    QMainWindow(parent)
    {
    setTitle();
    QWidget* centralWidget;
    centralWidget = new QWidget(this);
    centralWidget->setContextMenuPolicy(Qt::NoContextMenu);
    setCentralWidget(centralWidget);
    load();
    }

MainWindow::~MainWindow()
    {

    }

void MainWindow::SetStyle(const QString& styleFile)
    {
    QFile file(styleFile);
    bool rst = file.open(QFile::ReadOnly);    
    if(rst)
        {
        QString styleSheet = QLatin1String(file.readAll());    
        qApp->setStyleSheet(styleSheet);    
        }
    file.close();
    }

void MainWindow::popupDialogAddTests()
    {
    dlgAddTests->clear();
    dlgAddTests->showMaximized();
    }

void MainWindow::popupDialogSettings()
    {
    dlgSettings->restoreSettings();
    dlgSettings->showMaximized();
    }

void MainWindow::popupDialogAbout()
    {
    dlgAbout->showMsg(tr("%1 v%2.%3.%4").arg(APPNAME) .arg(
            SUT_MAJOR_VERSION) .arg(SUT_MINOR_VERSION).arg(SUT_BUILD_VERSION));
    }

void MainWindow::setTitle()
    {
    this->setWindowTitle(tr("%1 v%2.%3.%4").arg(APPNAME) .arg(
            SUT_MAJOR_VERSION) .arg(SUT_MINOR_VERSION).arg(SUT_BUILD_VERSION));
    }

void MainWindow::load()
    {
    createTabWidget();
    loadTabWidget();
    setupTabWidgetEventHandlers();
    createDialogs();
    setupDialogEventHandlers();
    createMenu();
    setupMenuEventHandlers();
    loadMenu();
    setupKeyEventHandlers();
    SetStyle(STYLESHEET);
    }

void MainWindow::createMenu()
    {
    atnAddTests = new QAction(tr("Add Tests"), this);
    menuMarkUnmark = new QMenu(tr("Mark / Unmark"), this);
    menuMarkUnmark->setEnabled(false);
    atnMark = new QAction(tr("Mark"), menuMarkUnmark);
    atnMarkAll = new QAction(tr("Mark All"), menuMarkUnmark);
    atnUnmark = new QAction(tr("Unmark"), menuMarkUnmark);
    atnUnmarkAll = new QAction(tr("Unmark All"), menuMarkUnmark);
    atnRun = new QAction(tr("Run"), this);
    atnRun->setEnabled(false);
    atnSettings = new QAction(tr("Settings"), this);
    atnAbout = new QAction(tr("About"), this);
    atnExit = new QAction(tr("Exit"), this);
    }

void MainWindow::setupMenuEventHandlers()
    {
    // add tests
    connect(atnAddTests, SIGNAL(triggered()), this,
            SLOT(popupDialogAddTests()));
    // Mark / Unmark single / all
    connect(atnMark, SIGNAL(triggered()), tabWdgtTestRun,
            SLOT(selectCurrentCase()));
    connect(atnMarkAll, SIGNAL(triggered()), tabWdgtTestRun,
            SLOT(selectAllCases()));
    connect(atnUnmark, SIGNAL(triggered()), tabWdgtTestRun,
            SLOT(deselectCurrentCase()));
    connect(atnUnmarkAll, SIGNAL(triggered()), tabWdgtTestRun,
            SLOT(deselectAllCases()));
    // Run tests
    connect(atnRun, SIGNAL(triggered()), tabWdgtTestRun, SLOT(runTests()));
    // set options to run cases
    connect(atnSettings, SIGNAL(triggered()), this,
            SLOT(popupDialogSettings()));

    connect(atnAbout, SIGNAL(triggered()), this, SLOT(popupDialogAbout()));
    connect(atnExit, SIGNAL(triggered()), this, SLOT(close()));
    }

void MainWindow::createTabWidget()
    {
    tabWdgtTestRun = new TabWidgetTestRun(this);
    }

void MainWindow::loadMenu()
    {
    menuBar()->clear();
    menuBar()->addAction(atnAddTests);
    menuMarkUnmark->addAction(atnMark);
    menuMarkUnmark->addAction(atnMarkAll);
    menuMarkUnmark->addAction(atnUnmark);
    menuMarkUnmark->addAction(atnUnmarkAll);
    menuBar()->addAction(menuMarkUnmark->menuAction());
    menuBar()->addAction(atnRun);
    menuBar()->addAction(atnSettings);
    menuBar()->addAction(atnAbout);
    menuBar()->addAction(atnExit);
    }

void MainWindow::loadTabWidget()
    {
    QGridLayout* tabLayout = new QGridLayout(this);
    tabLayout->setVerticalSpacing(2);
    tabLayout->setHorizontalSpacing(2);
    tabLayout->setSpacing(2);
    tabLayout->setMargin(2);
    tabLayout->addWidget(tabWdgtTestRun, 0, 0);
    centralWidget()->setLayout(tabLayout);
    }

void MainWindow::setupTabWidgetEventHandlers()
    {
    connect(tabWdgtTestRun, SIGNAL(testsAdded()), this,
            SLOT(enableMenuMarkUnmark()));
    connect(tabWdgtTestRun, SIGNAL(selectedTestsChanged(bool, bool, bool)), this,
            SLOT(setRunMarkUnmarkEnabled(bool, bool, bool)));
    // current tab changed
    connect(tabWdgtTestRun, SIGNAL(currentTabChangedToTests(bool)), this,
            SLOT(changCurrentTabToTests(bool)));
    connect(tabWdgtTestRun, SIGNAL(currentTabChangedToExecution()), this,
            SLOT(changCurrentTabToExecution()));
    }

void MainWindow::createDialogs()
    {
    dlgAddTests = new DialogAddTests(this);
    dlgSettings = new DialogSettings(this);
    dlgAbout = new DialogMsg(this);
    }

void MainWindow::setupDialogEventHandlers()
    {
    connect(dlgAddTests, SIGNAL(testsSaved(QStringList)), tabWdgtTestRun,
            SLOT(addTests(QStringList)));
    connect(dlgSettings, SIGNAL(settingsSaved(const Settings*)),
            tabWdgtTestRun, SLOT(saveSettings(const Settings*)));
    }

void MainWindow::changCurrentTabToTests(bool hasTests)
    {
    if (hasTests)
        {
        menuMarkUnmark->setEnabled(true);
        }
    }

void MainWindow::changCurrentTabToExecution()
    {
    menuMarkUnmark->setEnabled(false);
    }

void MainWindow::setRunMarkUnmarkEnabled(bool noneSelected, bool allSelected, bool curSelected)
    {
    atnRun->setEnabled(!noneSelected);
    atnUnmarkAll->setEnabled(!noneSelected);
    atnUnmark->setEnabled(curSelected);
    atnMark->setEnabled(!curSelected);
    atnMarkAll->setEnabled(noneSelected || !allSelected);
    }

void MainWindow::enableMenuMarkUnmark()
    {
    menuMarkUnmark->setEnabled(true);
    atnMarkAll->setEnabled(true);
    atnMark->setEnabled(true);
    atnUnmark->setEnabled(false);
    atnUnmarkAll->setEnabled(false);
    }

void MainWindow::keyPressEvent(QKeyEvent* event)
    {
    // Handle arrow keys and selection key events
    switch (event->nativeVirtualKey())
        {
        case KeyLeftArrow:
            {
            // TODO
            emit this->leftArrowPressed();
            break;
            }
        case KeyRightArrow:
            {
            // TODO
            emit this->rightArrowPressed();
            break;
            }
        case KeyUpArrow:
            {
            // TODO
            emit this->upArrowPressed();
            break;
            }
        case KeyDownArrow:
            {
            // TODO
            emit this->downArrowPressed();
            break;
            }
        case KeyEnter:
            {
            // TODO
            emit this->enterPressed();
            break;
            }
        default:
            {
            break;
            }
        }
    }

void MainWindow::setupKeyEventHandlers()
    {
    connect(this, SIGNAL(leftArrowPressed()), tabWdgtTestRun,
            SLOT(pressLeftArrow()));
    connect(this, SIGNAL(rightArrowPressed()), tabWdgtTestRun,
            SLOT(pressRightArrow()));
    connect(this, SIGNAL(upArrowPressed()), tabWdgtTestRun,
            SLOT(pressUpArrow()));
    connect(this, SIGNAL(downArrowPressed()), tabWdgtTestRun,
            SLOT(pressDownArrow()));
    connect(this, SIGNAL(enterPressed()), tabWdgtTestRun, SLOT(pressEnter()));
    }