//##################################################################################################
//
//   Custom Visualization Core library
//   Copyright (C) 2011-2013 Ceetron AS
//
//   This library may be used under the terms of either the GNU General Public License or
//   the GNU Lesser General Public License as follows:
//
//   GNU General Public License Usage
//   This library is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
//   This library 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 General Public License at <<http://www.gnu.org/licenses/gpl.html>>
//   for more details.
//
//   GNU Lesser General Public License Usage
//   This library 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; either version 2.1 of the License, or
//   (at your option) any later version.
//
//   This library 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 at <<http://www.gnu.org/licenses/lgpl-2.1.html>>
//   for more details.
//
//##################################################################################################


#include "cafUiProcess.h"
#include <QTimer>


namespace caf
{

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
UiProcess::UiProcess(QObject* parent)
    : QProcess(parent)
{
    connect(this, SIGNAL(started()),                            SLOT(slotProcStarted()));
    connect(this, SIGNAL(error(QProcess::ProcessError)),        SLOT(slotProcError(QProcess::ProcessError)));
    connect(this, SIGNAL(finished(int, QProcess::ExitStatus)),  SLOT(slotProcFinished(int, QProcess::ExitStatus)));
    connect(this, SIGNAL(stateChanged(QProcess::ProcessState)), SLOT(slotProcStateChanged(QProcess::ProcessState)));
    connect(this, SIGNAL(readyReadStandardError()),             SLOT(slotUpdateStatusMessage()));
    connect(this, SIGNAL(readyReadStandardOutput()),            SLOT(slotUpdateStatusMessage()));

    // Use a one sec timer to make sure the status message is updated at least every second
    QTimer* timer = new QTimer(this);
    connect(timer, SIGNAL(timeout()), this, SLOT(slotUpdateStatusMessage()));
    timer->start(1000);
}


//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void UiProcess::doEmitStatusMsg(const QString& msg, int statusMsgType)
{
    QString simpleMsg = msg;
    QString formattedMsg = simpleMsg;

    if        (statusMsgType == PROCESS_STATE_RUNNING)    formattedMsg = QString("<font color='green'>%1</font>").arg(simpleMsg);
    else if (statusMsgType == PROCESS_STATE_ERROR)        formattedMsg = QString("<font color='red'>%1</font>").arg(simpleMsg);

    emit signalStatusMsg(simpleMsg, statusMsgType);
    emit signalFormattedStatusMsg(formattedMsg);
}


//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void UiProcess::slotProcStarted()
{
    m_timer.start();

    doEmitStatusMsg("Started", PROCESS_STATE_NORMAL);
}


//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void UiProcess::slotProcError(QProcess::ProcessError error)
{
    QString msg = "UNKNOWN";

    switch (error)
    {
        case QProcess::FailedToStart:    msg = "Failed to start";    break;
        case QProcess::Crashed:            msg = "Crashed";            break;
        case QProcess::Timedout:        msg = "Timed out";            break;
        case QProcess::WriteError:        msg = "Write error";        break;
        case QProcess::ReadError:        msg = "Read error";        break;
        case QProcess::UnknownError:    msg = "Unknown error";        break;
    }
    
    doEmitStatusMsg(msg, PROCESS_STATE_ERROR);
}


//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void UiProcess::slotProcFinished(int exitCode, QProcess::ExitStatus exitStatus)
{
    if (exitStatus == QProcess::CrashExit)
    {
        doEmitStatusMsg("Crashed or aborted", PROCESS_STATE_ERROR);
    }

    else if (exitStatus == QProcess::NormalExit)
    {
        if (exitCode == 0)
        {
            doEmitStatusMsg("Finished OK", PROCESS_STATE_NORMAL);
        }
        else
        {
            QString msg = QString("Error exit (code %1)").arg(exitCode);
            doEmitStatusMsg(msg, PROCESS_STATE_ERROR);
        }
    }
}


//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void UiProcess::slotProcStateChanged(QProcess::ProcessState newState)
{
    int statusMsgType = PROCESS_STATE_ERROR;
    QString msg = "UNKNOWN";

    switch (newState)
    {
        case QProcess::NotRunning:  msg = "Not running";    statusMsgType = PROCESS_STATE_NORMAL;   break;
        case QProcess::Starting:    msg = "Starting...";    statusMsgType = PROCESS_STATE_NORMAL;   break;
        case QProcess::Running:     msg = "Running";        statusMsgType = PROCESS_STATE_RUNNING;  break;
    }

    doEmitStatusMsg(msg, statusMsgType);
}


//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void UiProcess::slotUpdateStatusMessage()
{
    if (state() == QProcess::Running)
    {
        // Use this as a sign that the process is alive and kicking
        // Emit a message with the current run time to signify progress
        double timeRunning = m_timer.elapsed() / 1000.0;

        QString msg = QString("Running (%1 s)").arg(timeRunning, 0, 'f', 1);
    
        doEmitStatusMsg(msg, PROCESS_STATE_RUNNING);
    }
}


} // namespace caf