#include <QDebug>
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "symbolConfig.h"
#include <QMessageBox>
#include <QGraphicsPixmapItem>
#include "graphicspixmapitem.h"
#include "grahicstextitem.h"
#include <QTimer>
#include <QPaintEvent>
#ifdef Q_OS_UNIX
#include <unistd.h>
#include <syslog.h>
#endif
#include <QFileInfo>
#include <QPainter>
#include <QFileSystemWatcher>
#include <QDir>
#include <QFileInfo>
#include <QDateTime>
#include <QApplication>
#include <QElapsedTimer>
#include <QInputDialog>
#include <Logger.h>
#include "numpad.h"
#include "keypad.h"
#include "INIManager.h"

const double S_MAX_X = 2.05;
const double S_MAX_Y = 0.65;
const double V_MAX_X = 2.1;
const double V_MAX_Y = 5.2;
const double A_MAX_X = 50.0;
const double A_MAX_Y = 155.0;

MainWindow::MainWindow(QWidget *parent):
    QMainWindow(parent),
#ifdef Q_WS_QWS
    m_plcHandler(),
#else
    m_plcHandler("172.16.4.146"),
#endif
    m_watcher(new QFileSystemWatcher(this)),
    m_actPosX(0),
    m_actPosY(0),
    m_actVelocityX(0),
    m_actVelocityY(0),
    m_actTemperaturGeraetX(0),
    m_actTemperaturGeraetY(0),
    m_actTemperaturMotorX(0),
    m_actTemperaturMotorY(0),
    m_spielHoehe(0),
    m_spielWeite(0),
    m_grundstellungX(0.05),
    m_grundstellungY(0.05),
    m_automatikAktiv(false),
    m_startPosAktiv(false),
    m_ballPosAktiv(false),
    m_spielAktiv(false),
    m_spielRestart(false),
    m_automtikIndex(0),
    m_data_X(new FahrprofilData),
    m_data_Y(new FahrprofilData),
    m_widgetData(),
    ipo(new Interpolator(0, 0, m_data_X.data(), m_data_Y.data(), m_widgetData)),
    m_startPosX(0),
    m_startPosY(0),
    m_error(false),
    m_sw_end_pos_x(0),
    m_sw_end_neg_x(0),
    m_sw_end_pos_y(0),
    m_sw_end_neg_y(0),
    m_grundPositionDefault_x(0),
    m_grundPositionDefault_y(0),
    m_looserModeAktiv(false)
{
    ui.setupUi(this);
    ui.stackedWidget->setCurrentIndex(PageAutomatik);
    initTabelle();
    ui.tableWidget->resizeColumnsToContents();
    connect(ui.widget_2, SIGNAL(startPositionChanged(QPointF)), this, SLOT(startPositionChanged(QPointF)));
    connect(ui.widget_2, SIGNAL(startSpiel(double,double)), this, SLOT(startSpiel(double,double)));
    connect(ui.widget_2, SIGNAL(error(bool)), this, SLOT(setStartSpielDisabled(bool)));
#ifdef Q_OS_UNIX
    QFileInfo fi("/doc/cst/SPS_Profile");
    if(fi.isDir() && fi.owner() != "service"){
        chown("/doc/cst/SPS_Profile", 501, 501);
    }

    syslog(LOG_ERR|LOG_USER, "oops - %m\n");
#endif
    initPLC();
    LOG_INFO_1() << "App started: " << QDateTime::currentDateTime().toString("dd.MM.yyyy hh:mm:ss");
#ifdef Q_OS_UNIX

    //Check ob Verzeichnis "/tmp/mnt" schon da ist
    QDir dir("/tmp");
    if(dir.entryList(QStringList("mnt"), QDir::Dirs|QDir::NoDotAndDotDot).contains("mnt")){
        m_watcher->addPath("/tmp/mnt");
        directoryChanged("/tmp/mnt");
    }else{
        m_watcher->addPath("/tmp");
    }

    connect(m_watcher, SIGNAL(directoryChanged(QString)), this, SLOT(directoryChanged(QString)));

#endif

//    ui.webView->settings()->globalSettings()->setAttribute(QWebSettings::PluginsEnabled, true);
//    ui.webView->settings()->globalSettings()->setAttribute(QWebSettings::JavascriptEnabled, true);

    // Eventfilter fuer alle Widgets installieren
    QList<QWidget *> widgets = findChildren<QWidget *>();
    for (int i=0; i<widgets.size(); ++i){
        widgets.at(i)->installEventFilter(this);
    }

}

void MainWindow::changeEvent(QEvent *e)
{
    QMainWindow::changeEvent(e);
    switch (e->type()) {
    case QEvent::LanguageChange:
        ui.retranslateUi(this);
        break;
    default:
        break;
    }
}

void MainWindow::initPLC()
{
    //Initialize tasks
    initTasks();

    //PLCHandler get the error messages
    connect(&m_plcHandler,  SIGNAL(errorMsg(const QString&)),
            this,           SLOT(errorMsg(const QString&)));

    //PLCHandler get the qtplchandler state messages (run/stop)
    connect(&m_plcHandler,  SIGNAL(state(const QString&)),
            this,           SLOT(stateMsg(const QString&)));

    //PLCHandler get the cyclic dada
    connect(&m_plcHandler,  SIGNAL(cyclicData(const QList <PLC_VARIABLE>&, const QList<int>&)),
            this,           SLOT(cyclicData(const QList <PLC_VARIABLE>&, const QList<int>&)));

    //PLCHandler get the plchandler state (connected/symbols loaded aso.)
    connect(&m_plcHandler,  SIGNAL(state(const long)),
            this,           SLOT(state(const long)));

    //PLCHandler get the plchandler state (connected/symbols loaded a.s.o.)
    connect(&m_plcHandler,  SIGNAL(state(const long)),
            this,           SLOT(stateIntern(long)));

    //receive the PLC status (RUN/STOP a.s.o.)
    connect(&m_plcHandler,  SIGNAL(plcState(const QT_PLC_STATUS&)),
            this,           SLOT(plcStatus(const QT_PLC_STATUS&)));

    //Connect to PLC
    if (!m_plcHandler.connectPlc())
        QMessageBox::critical(this,
                              "Error",
                              tr("Can not connect to the plc: %1")
                              .arg(m_plcHandler.getLastError()));
}

void MainWindow::initSPS_Data()
{
    //Init Ablauf Daten
//    m_AblaufDaten.append(InterpolatorData(ui.le_hoehe_1->text().toDouble(),
//                                          ui.le_hoehe->text().toDouble(),
//                                          ui.le_Steigung->text().toDouble(),
//                                          ui.le_SteigungZurueck->text().toDouble(),
//                                          ui.le_Anzahl->text().toInt(),
//                                          ui.le_AnzahlZurueck->text().toInt(),
//                                          m_grundstellungX+ui.le_weite->text().toDouble(),
//                                          A_MAX_Y,
//                                          A_MAX_X,
//                                          ui.le_PauseRueck->text().toDouble(),
//                                          ui.le_Zwischenpause->text().toDouble(),
//                                          ui.le_PauseStart->text().toDouble()));
//    m_AblaufDaten.append(InterpolatorData(0.5,  0.5,    0,      0,      2,  2,  m_grundstellungX+1.7, A_MAX_Y, A_MAX_X, 2.0, 0.75, ui.le_PauseStart->text().toDouble()));
//    m_AblaufDaten.append(InterpolatorData(0.5,  0.5,    0.05,   0.05,   3,  3,  m_grundstellungX+1.7, A_MAX_Y, A_MAX_X, 2.0, 0.75, ui.le_PauseStart->text().toDouble()));
//    m_AblaufDaten.append(InterpolatorData(0.1,  0.5,    0.035,   0,      12, 2,  m_grundstellungX+1.7, A_MAX_Y, A_MAX_X, 2.0, 0.75, ui.le_PauseStart->text().toDouble()));
//    m_AblaufDaten.append(InterpolatorData(0.2,  0.3,    0.1,    0.05,   2,  2,  m_grundstellungX+1.7, A_MAX_Y, A_MAX_X, 2.0, 0.75, ui.le_PauseStart->text().toDouble()));
//    m_AblaufDaten.append(InterpolatorData(0.4,  0.3,    0,      0.1,    3,  2,  m_grundstellungX+1.7, A_MAX_Y, A_MAX_X, 2.0, 0.75, ui.le_PauseStart->text().toDouble()));
//    m_AblaufDaten.append(InterpolatorData(0.5,  0.5,    0,      0,      3,  2,  m_grundstellungX+1.7, A_MAX_Y, A_MAX_X, 2.0, 0.75, ui.le_PauseStart->text().toDouble()));
//    m_AblaufDaten.append(InterpolatorData(0.2,  0.3,    0.1,    0.05,   2,  2,  m_grundstellungX+1.7, A_MAX_Y, A_MAX_X, 2.0, 0.75, ui.le_PauseStart->text().toDouble()));
//    m_AblaufDaten.append(InterpolatorData(0.4,  0.5,    0,      0,      2,  3,  m_grundstellungX+1.7, A_MAX_Y, A_MAX_X, 2.0, 0.75, ui.le_PauseStart->text().toDouble()));
//    m_AblaufDaten.append(InterpolatorData(0.1,  0.1,    0,      0,      14, 2, m_grundstellungX+1.7, A_MAX_Y, A_MAX_X, 2.0, 0.75, ui.le_PauseStart->text().toDouble()));

//    saveTabelle();
    m_plcHandler.readPlcValue(g_stMachineParameter_arAxisParameter_1__lreSoftwareEndschalterPos_mm, m_sw_end_pos_x);
    m_plcHandler.readPlcValue(g_stMachineParameter_arAxisParameter_1__lreSoftwareEndschalterNeg_mm, m_sw_end_neg_x);
    m_plcHandler.readPlcValue(g_stMachineParameter_arAxisParameter_2__lreSoftwareEndschalterPos_mm, m_sw_end_pos_y);
    m_plcHandler.readPlcValue(g_stMachineParameter_arAxisParameter_2__lreSoftwareEndschalterNeg_mm, m_sw_end_neg_y);
    m_plcHandler.readPlcValue(g_stMachineParameter_arAxisParameter_1__lreGrundstellung_mm, m_grundPositionDefault_x);
    m_plcHandler.readPlcValue(g_stMachineParameter_arAxisParameter_2__lreGrundstellung_mm, m_grundPositionDefault_y);
    m_grundPositionDefault_x *= 0.001;
    m_grundPositionDefault_y *= 0.001;
    m_sw_end_pos_x *=0.001;
    m_sw_end_neg_x *=0.001;
    m_sw_end_pos_y *=0.001;
    m_sw_end_neg_y *=0.001;

    qDebug() << trUtf8("m_sw_end_pos_x: %1, m_sw_end_neg_x: %2, m_sw_end_pos_y: %3, m_sw_end_neg_y: %4")
                .arg(m_sw_end_pos_x)
                .arg(m_sw_end_neg_x)
                .arg(m_sw_end_pos_y)
                .arg(m_sw_end_neg_y)
                ;
    ui.widget_2->setSoftwareEndschalter(m_sw_end_pos_x, m_sw_end_neg_x, m_sw_end_pos_y, m_sw_end_neg_y);
    on_stackedWidget_currentChanged(ui.stackedWidget->currentIndex());
}

void MainWindow::initTabelle()
{
    m_AblaufDaten.clear();
    for(int i=0; i<10; ++i){
        m_AblaufDaten.append(INIMANAGER.interpolatorData(i));
        ui.tableWidget->item(IPO_StartPositionX, i)->setData(Qt::DisplayRole, QString::number(m_AblaufDaten[i].startPosition_x, 'f', 3));
        ui.tableWidget->item(IPO_StartPositionY, i)->setData(Qt::DisplayRole, QString::number(m_AblaufDaten[i].startPosition_y, 'f', 3));
        ui.tableWidget->item(IPO_Hoehe1, i)->setData(Qt::DisplayRole, QString::number(m_AblaufDaten[i].h1, 'f', 3));
        ui.tableWidget->item(IPO_Hoehe2, i)->setData(Qt::DisplayRole, QString::number(m_AblaufDaten[i].h2, 'f', 3));
        ui.tableWidget->item(IPO_Weite, i)->setData(Qt::DisplayRole, QString::number(m_AblaufDaten[i].s_max, 'f', 3));
        ui.tableWidget->item(IPO_Anzahl1, i)->setData(Qt::DisplayRole, QString::number(m_AblaufDaten[i].n1, 'f', 0));
        ui.tableWidget->item(IPO_Anzahl2, i)->setData(Qt::DisplayRole, QString::number(m_AblaufDaten[i].n2, 'f', 0));
        ui.tableWidget->item(IPO_Zwischenpause, i)->setData(Qt::DisplayRole, QString::number(m_AblaufDaten[i].zwischenpause, 'f', 3));
        ui.tableWidget->item(IPO_PauseZurueck, i)->setData(Qt::DisplayRole, QString::number(m_AblaufDaten[i].pause, 'f', 3));
        ui.tableWidget->item(IPO_PauseVor, i)->setData(Qt::DisplayRole, QString::number(m_AblaufDaten[i].pauseVor, 'f', 3));
        ui.tableWidget->item(IPO_Steigung1, i)->setData(Qt::DisplayRole, QString::number(m_AblaufDaten[i].offset_y, 'f', 3));
        ui.tableWidget->item(IPO_Steigung2, i)->setData(Qt::DisplayRole, QString::number(m_AblaufDaten[i].offset_y2, 'f', 3));
        ui.tableWidget->item(IPO_BeschleunigungX, i)->setData(Qt::DisplayRole, QString::number(m_AblaufDaten[i].a_xmax, 'f', 3));
        ui.tableWidget->item(IPO_BeschleunigungY, i)->setData(Qt::DisplayRole, QString::number(m_AblaufDaten[i].a_ymax, 'f', 3));
    }
}

void MainWindow::saveTabelle()
{
    for(int i=0; i<10; ++i){
        INIMANAGER.setInterpolatorData(i, m_AblaufDaten[i]);
    }
}

bool MainWindow::checkDaten()
{
    double max_s_x=0;
    double max_s_y=0;
    double max_v_x=0;
    double max_v_y=0;
    for(int i=0; i<m_data_X->uiAnzahlEintraege; ++i){
        if(max_s_x<m_data_X->position[i])
            max_s_x=m_data_X->position[i];
        if(max_v_x<m_data_X->geschwindigkeit[i])
            max_v_x=m_data_X->geschwindigkeit[i];
        if(max_s_y<m_data_Y->position[i])
            max_s_y=m_data_Y->position[i];
        if(max_v_y<m_data_Y->geschwindigkeit[i])
            max_v_y=m_data_Y->geschwindigkeit[i];
    }

    QString text;
    if((max_s_x>S_MAX_X)){
        text=trUtf8("Der maximale Verfahrweg in der X-Achse wird überschritten");
    }
    if((max_s_y>S_MAX_Y)){
        text=trUtf8("Der maximale Verfahrweg in der Z-Achse wird überschritten");
    }
    if((max_v_x>V_MAX_X)){
        text=trUtf8("Die maximale Verfahrgeschwindigkeit in der X-Achse wird überschritten");
    }
    if((max_v_y>V_MAX_Y)){
        text=trUtf8("Die maximale Verfahrgeschwindigkeit in der Z-Achse wird überschritten");
    }
    if(     (max_s_x>S_MAX_X)
        ||  (max_s_y>S_MAX_Y)
        ||  (max_v_x>V_MAX_X)
        ||  (max_v_x>V_MAX_X))
    {
        on_btn_Stop_clicked();
        ui.widget_2->setError(true);
        QMessageBox::critical(this, trUtf8("Fehler"), text);
        m_error=true;
        return false;
    }
    m_error=false;
    return true;
}

void MainWindow::createData()
{
    if(m_automtikIndex<m_AblaufDaten.size()){
        if(!m_plcHandler.writePlcValue(g_uiVerzoegerungszeitAblaufende_ms, m_AblaufDaten[m_automtikIndex].pauseVor*1000))
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_uiVerzoegerungszeitAblaufende_ms);

        double startpos_x=m_AblaufDaten[m_automtikIndex].startPosition_x;
        if(startpos_x<m_sw_end_neg_x)
            startpos_x=m_sw_end_neg_x+0.01;

        if(startpos_x>m_sw_end_pos_x)
            startpos_x=m_sw_end_pos_x-0.01;

        double startpos_y=m_AblaufDaten[m_automtikIndex].startPosition_y;
        if(startpos_y<m_sw_end_neg_y)
            startpos_y=m_sw_end_neg_y+0.01;

        if(startpos_y>m_sw_end_pos_y)
            startpos_y=m_sw_end_pos_y-0.01;


        if(m_AblaufDaten[m_automtikIndex].s_max>0.0001 && startpos_x>=m_AblaufDaten[m_automtikIndex].s_max){
            qDebug() << "if(m_AblaufDaten[m_automtikIndex].s_max>0.0001 && startpos_x>=m_AblaufDaten[m_automtikIndex].s_max)";
            on_btn_Stop_clicked();
            return;
        }


        if(!m_plcHandler.writePlcValue(g_stMachineParameter_arAxisParameter_1__lreGrundstellung_mm, startpos_x*1000)){
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_stMachineParameter_arAxisParameter_1__lreGrundstellung_mm);
            return;
        }

        if(!m_plcHandler.writePlcValue(g_stMachineParameter_arAxisParameter_2__lreGrundstellung_mm, startpos_y*1000)){
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_stMachineParameter_arAxisParameter_2__lreGrundstellung_mm);
            return;
        }


        qDebug() << trUtf8("Startpos X: %1, Startpos Y: %2").arg(startpos_x).arg(startpos_y);
        ipo->setPositionxY(startpos_x, startpos_y);
        ipo->calc(m_AblaufDaten[m_automtikIndex]);
        ui.widget->replot(m_widgetData);
        if(m_automtikIndex>0)
            ui.tableWidget->selectColumn(m_automtikIndex-1);
        else
            ui.tableWidget->selectColumn(0);
        if(!checkDaten()){
            on_btn_Stop_clicked();
            return;
        }
#ifdef Q_OS_WIN
    m_plcHandler.downloadFile("out_x.bin", "/tmp/out_x.bin");
    m_plcHandler.downloadFile("out_y.bin", "/tmp/out_y.bin");
#endif
        qDebug() << "Index: " << m_automtikIndex;
        m_automtikIndex++;
        if(m_automtikIndex>=m_AblaufDaten.size()){
            m_automtikIndex=0;
        }

    }

    if(!m_plcHandler.writePlcValue(g_boStart, true))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boStart);
}


//Eventfiler, here you can set the key-/numpad dialog
bool MainWindow::eventFilter(QObject *object, QEvent *event)
{
    Q_UNUSED(object);
    if (event->type() == QEvent::MouseButtonPress)
    {
        if(object == ui.le_startPosX){
            Numpad dlg("Startposition X", "0", "2.0", ui.le_startPosX->text());
            if(dlg.exec()==QDialog::Accepted){
                ui.le_startPosX->setText(dlg.value());
            }
        }
        if(object == ui.le_startPosY){
            Numpad dlg("Startposition Y", "0", "0.5", ui.le_startPosY->text());
            if(dlg.exec()==QDialog::Accepted){
                ui.le_startPosY->setText(dlg.value());
            }
        }

        if(object == ui.le_OverrideY){
            Numpad dlg(trUtf8("Pause Rück"), "0.01", "2.0", ui.le_OverrideY->text());
            if(dlg.exec()==QDialog::Accepted){
                ui.le_OverrideY->setText(dlg.value());
                ipo->setOverrideY(dlg.valueDouble());
            }
        }

    }
    return false;
}


//Here you get the error
void MainWindow::errorMsg(const QString &error)
{
    Q_UNUSED(error);
}

// here you get the qtplchandler state messages (run/stop) as string
void MainWindow::stateMsg(const QString &state)
{
    Q_UNUSED(state);
}

//here you get the plchandler state (connected/symbols loaded aso.)
void MainWindow::state(const long state)
{
    switch (state)
    {
    case STATE_RUNNING:
        LOG_INFO_1() << "PLC is running...";
        break;
    case STATE_PLC_NOT_CONNECTED:
        break;
    }
}

void MainWindow::plcStatus(const QT_PLC_STATUS &plcStatus)
{
    Q_UNUSED(plcStatus);
}

void MainWindow::startPositionChanged(QPointF pos)
{
    m_startPos=pos;
    m_startPosAktiv=true;

    m_startPosX=pos.x();
    m_startPosY=pos.y();

    ipo->setPositionxY(m_startPosX, m_startPosY);
    ipo->calcCheck(m_spielHoehe, m_startPosX+m_spielWeite, A_MAX_Y, A_MAX_X);
    double s_beschl_x = ipo->beschleunigunsWegX();
    double s_beschl_y = ipo->beschleunigunsWegY();

    m_startPosX -=s_beschl_x;
    m_startPosY -=s_beschl_y;

//    if(m_startPosX<m_grundstellungX || m_startPosY<m_grundstellungY){
//        ui.btn_StartSpiel->setDisabled(true);
//        ui.btn_StartBallPos_3->setDisabled(true);
//        ui.btn_Zurueck->setDisabled(true);
//        ui.btn_VisuHand->setDisabled(true);
//        return;
//    }

    if(!m_plcHandler.writePlcValue(g_lreStartPosition_X, m_startPosX))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_lreStartPosition_X);
    if(!m_plcHandler.writePlcValue(g_lreStartPosition_Y, m_startPosY))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_lreStartPosition_Y);
    if(!m_plcHandler.writePlcValue(g_boStartPos, true))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boStartPos);

    ipo->setPositionxY(m_startPosX, m_startPosY);
    ipo->calc(m_spielHoehe, 0, 0, 0, 0, 0, m_startPosX+m_spielWeite, A_MAX_Y, A_MAX_X, 0, 0);
    if(!checkDaten()){
        return;
    }

    ui.btn_StartSpiel->setDisabled(m_startPosAktiv);
    ui.btn_Looser->setDisabled(m_startPosAktiv);
    ui.btn_StartBallPos_3->setDisabled(m_startPosAktiv);
    ui.btn_Zurueck->setDisabled(m_startPosAktiv);
    ui.btn_VisuHand->setDisabled(m_startPosAktiv);
    ui.widget_2->setDisabled(m_startPosAktiv);
}

void MainWindow::startSpiel(double h, double s_max)
{
    m_spielHoehe=h;
    m_spielWeite=s_max;
}

void MainWindow::setStartSpielDisabled(bool /*error*/)
{
    //m_error=error;
}


void MainWindow::directoryChanged(QString directory)
{
    QDir dir(directory);
    if(dir.entryList(QStringList("mnt"), QDir::Dirs|QDir::NoDotAndDotDot).contains("mnt")){
        m_watcher->removePath("/tmp");
        m_watcher->addPath("/tmp/mnt");
        QDir mnt("/tmp/mnt");
        if(mnt.entryList(QDir::Dirs|QDir::NoDotAndDotDot).isEmpty()){
            qDebug() << "kein USB Stick vorhanden";
        }else{
            qDebug() << "USB Stick ist vorhanden";
        }
    }
    if(directory == "/tmp/mnt"){
        if(dir.entryList(QDir::Dirs|QDir::NoDotAndDotDot).isEmpty()){
            qDebug() << "kein USB Stick vorhanden";
        }else{
            qDebug() << "USB Stick ist vorhanden";
        }
    }
}



void MainWindow::on_g_boEC_Ready_changed(const QVariant &value)
{
    qDebug() << "Bus state changed: " << value.toBool();
}


void MainWindow::on_g_boQRF_changed(const QVariant &value)
{
    ui.btn_Start->setEnabled(value.toBool());
    ui.btn_Stop->setEnabled(value.toBool());
    ui.btn_StartBallPos->setEnabled(value.toBool());
    ui.btn_StartBallPos_2->setEnabled(value.toBool());
    ui.btn_Ein_Aus->setChecked(value.toBool());
    ui.btn_Ein_Aus_2->setChecked(value.toBool());
    ui.btn_Ein_Aus_3->setChecked(value.toBool());
    ui.btn_StartBallPos_3->setEnabled(value.toBool());
    ui.widget_2->setEnabled(value.toBool());
    ui.btn_Looser->setEnabled(value.toBool());

    if(m_grundPositionDefault_x>0.0001 && !value.toBool()){
        if(!m_plcHandler.writePlcValue(g_stMachineParameter_arAxisParameter_1__lreGrundstellung_mm, m_grundPositionDefault_x*1000)){
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_stMachineParameter_arAxisParameter_1__lreGrundstellung_mm);
        }
    }
    if(m_grundPositionDefault_y>0.0001 && !value.toBool()){
        if(!m_plcHandler.writePlcValue(g_stMachineParameter_arAxisParameter_2__lreGrundstellung_mm, m_grundPositionDefault_y*1000)){
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_stMachineParameter_arAxisParameter_2__lreGrundstellung_mm);
        }
    }

}


void MainWindow::on_g_lreAktPos_X_mm_changed(const QVariant &value)
{
    m_actPosX=value.toDouble()/1000.0;
    ui.le_aktPosX->setText(QString::number(m_actPosX, 'f', 3));
}


void MainWindow::on_g_lreAktPos_Y_mm_changed(const QVariant &value)
{
    m_actPosY=value.toDouble()/1000.0;
    ui.le_aktPosY->setText(QString::number(m_actPosY, 'f', 3));
}


void MainWindow::on_g_lreGeschwindigkeit_X_changed(const QVariant &value)
{
    m_actVelocityX=value.toDouble()/1000.0;
    ui.le_aktGeschwindigkeit_X->setText(QString::number(m_actVelocityX, 'f', 1));
}


void MainWindow::on_g_lreGeschwindigkeit_Y_changed(const QVariant &value)
{
    m_actVelocityY=value.toDouble()/1000.0;
    ui.le_aktGeschwindigkeit_Y->setText(QString::number(m_actVelocityY, 'f', 1));
}


void MainWindow::on_g_lreTempGeraet_X_changed(const QVariant &value)
{
    m_actTemperaturGeraetX=value.toDouble();
    ui.le_Temperatur_iX->setText(QString::number(value.toDouble(), 'f', 1));
}


void MainWindow::on_g_lreTempGeraet_Y_changed(const QVariant &value)
{
    m_actTemperaturGeraetY=value.toDouble();
    ui.le_Temperatur_iC->setText(QString::number(value.toDouble(), 'f', 1));
}


void MainWindow::on_g_lreTempMotor_X_changed(const QVariant &value)
{
    m_actTemperaturMotorX=value.toDouble();
}


void MainWindow::on_g_lreTempMotor_Y_changed(const QVariant &value)
{
    m_actTemperaturMotorY=value.toDouble();
}


void MainWindow::on_btn_Ein_Aus_clicked(bool checked)
{
    checked ? ui.btn_Ein_Aus->setText(trUtf8("Aus")): ui.btn_Ein_Aus->setText(trUtf8("Ein"));
    if(!m_plcHandler.writePlcValue(g_boSetRF, checked))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boSetRF);
}

void MainWindow::on_btn_Spiel_clicked()
{
    ui.stackedWidget->setCurrentIndex(PageGame);
}

void MainWindow::on_btn_Zurueck_clicked()
{
    ui.stackedWidget->setCurrentIndex(PageAutomatik);
}

void MainWindow::on_btn_StartSpiel_clicked()
{

}

void MainWindow::on_btn_Hilfe_clicked(bool checked)
{
    ui.widget_2->setHilfe(checked);
}

void MainWindow::on_btn_Start_clicked()
{
    if(ui.btn_StartBallPos->isChecked() || ui.btn_StartBallPos_2->isChecked() || ui.btn_StartBallPos_3->isChecked()){
        return;
    }

    m_automatikAktiv=true;
    ui.btn_Spiel->setDisabled(m_automatikAktiv);
    ui.btn_VisuHand_2->setDisabled(m_automatikAktiv);
    ui.btn_StartBallPos->setDisabled(m_automatikAktiv);
    ui.btn_StartBallPos_2->setDisabled(m_automatikAktiv);
    ui.btn_StartBallPos_3->setDisabled(m_automatikAktiv);

    m_automtikIndex=0;
    createData();

    if(!m_plcHandler.writePlcValue(g_boStart, true))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boStart);

}

void MainWindow::on_btn_Stop_clicked()
{
    ui.btn_StartTabelle->setChecked(false);
    m_automatikAktiv=false;
    ui.btn_Spiel->setDisabled(m_automatikAktiv);
    ui.btn_VisuHand_2->setDisabled(m_automatikAktiv);
    ui.btn_StartBallPos->setDisabled(m_automatikAktiv);
    ui.btn_StartBallPos_2->setDisabled(m_automatikAktiv);
    ui.btn_StartBallPos_3->setDisabled(m_automatikAktiv);
    ui.btn_Looser->setDisabled(m_automatikAktiv);

    m_automtikIndex=0;
    ui.tableWidget->clearSelection();
    if(!m_plcHandler.writePlcValue(g_boStart, false))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boStart);

    if(!m_plcHandler.writePlcValue(g_stMachineParameter_arAxisParameter_1__lreGrundstellung_mm, m_grundPositionDefault_x*1000)){
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_stMachineParameter_arAxisParameter_1__lreGrundstellung_mm);
    }
    if(!m_plcHandler.writePlcValue(g_stMachineParameter_arAxisParameter_2__lreGrundstellung_mm, m_grundPositionDefault_y*1000)){
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_stMachineParameter_arAxisParameter_2__lreGrundstellung_mm);
    }
}

void MainWindow::on_btn_StartSpiel_pressed()
{

#ifdef Q_OS_WIN
    m_plcHandler.downloadFile("out_x.bin", "/tmp/out_x.bin");
    m_plcHandler.downloadFile("out_y.bin", "/tmp/out_y.bin");
#endif
    if(fabs(m_actPosX-m_startPosX)>0.001 && fabs(m_actPosY-m_startPosY)>0.001 && !m_spielRestart && ui.widget_2->isValid()){
        ui.btn_StartSpiel->setDisabled(true);
        ui.btn_Looser->setDisabled(true);
        ui.btn_StartBallPos_3->setDisabled(true);
        ui.widget_2->setDisabled(true);
        startPositionChanged(m_startPos);
        m_spielRestart=true;
        ui.btn_Zurueck->setDisabled(true);
        ui.btn_VisuHand->setDisabled(true);
        m_spielAktiv=true;
        return;
    }

    if(!m_error && ui.widget_2->isValid()){
        ui.btn_StartSpiel->setDisabled(true);
        ui.btn_Looser->setDisabled(true);
        ui.btn_Zurueck->setDisabled(true);
        ui.btn_VisuHand->setDisabled(true);
        ui.btn_StartBallPos_3->setDisabled(true);
        ui.widget_2->setDisabled(true);
        if(!m_plcHandler.writePlcValue(g_boStart, true))
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boStart);

        m_spielAktiv=true;
    }
}

void MainWindow::on_btn_StartSpiel_released()
{
    if(!m_plcHandler.writePlcValue(g_boStart, false))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben: %2").arg(g_boStart).arg(m_plcHandler.getLastError());
}

void MainWindow::on_stackedWidget_currentChanged(int arg1)
{
    if(m_plcHandler.getState() != STATE_RUNNING){
        return;
    }

    if(m_automatikAktiv && arg1 != PageAutomatik){
        ui.stackedWidget->setCurrentIndex(PageAutomatik);
        return;
    }

    if(m_spielAktiv && arg1 != PageGame){
        ui.stackedWidget->setCurrentIndex(PageGame);
        return;
    }

//    if(arg1 == PageGame){
//        on_btn_Stop_clicked();
//    }

    switch(arg1){
    case PageGame:
        if(!m_plcHandler.writePlcValue(g_uiMode, 2))
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben: %2").arg(g_uiMode).arg(m_plcHandler.getLastError());
        break;
    case PageAutomatik:
        if(!m_plcHandler.writePlcValue(g_uiMode, 1))
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben: %2").arg(g_uiMode).arg(m_plcHandler.getLastError());
        break;
    case PageHand:
        if(!m_plcHandler.writePlcValue(g_uiMode, 1))
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben: %2").arg(g_uiMode).arg(m_plcHandler.getLastError());
        break;
    default:
        if(!m_plcHandler.writePlcValue(g_uiMode, 0))
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben: %2").arg(g_uiMode).arg(m_plcHandler.getLastError());
        break;

    }
}

void MainWindow::on_btn_StartPos_pressed()
{
    if(ui.le_startPosX->text().isEmpty() || ui.le_startPosY->text().isEmpty())
        return;

    if(!m_plcHandler.writePlcValue(g_lreStartPosition_X, ui.le_startPosX->text().toDouble()))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_lreStartPosition_X);
    if(!m_plcHandler.writePlcValue(g_lreStartPosition_Y, ui.le_startPosY->text().toDouble()))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_lreStartPosition_Y);
    if(!m_plcHandler.writePlcValue(g_boStartPos, true))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boStartPos);

}

void MainWindow::on_btn_StartPos_released()
{
    if(!m_plcHandler.writePlcValue(g_boStartPos, false))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boStartPos);
}



void MainWindow::on_btn_Test_pressed()
{
//    if(ui.le_hoehe->text().isEmpty() || ui.le_weite->text().isEmpty())
//        return;

//    ipo->setPositionxY(m_actPosX, m_actPosY);
//    ipo->calc(ui.le_hoehe_1->text().toDouble(),
//              ui.le_hoehe->text().toDouble(),
//              0.0,
//              0.0,
//              1,
//              1,
//              m_grundstellungX+ui.le_weite->text().toDouble(),
//              A_MAX_Y,
//              A_MAX_X,
//              ui.le_PauseRueck->text().toDouble(),
//              ui.le_Zwischenpause->text().toDouble()
//              );
//    if(!checkDaten()){
//        return;
//    }
//#ifdef Q_OS_WIN
//        m_plcHandler.downloadFile("out_x.bin", "/tmp/out_x.bin");
//        m_plcHandler.downloadFile("out_y.bin", "/tmp/out_y.bin");
//#endif

//    if(!m_plcHandler.writePlcValue(g_boStart, true))
//        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boStart);
}

void MainWindow::on_btn_Test_released()
{
    if(!m_plcHandler.writePlcValue(g_boStart, false))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben: %2").arg(g_boStart).arg(m_plcHandler.getLastError());

}

void MainWindow::on_g_stMachineParameter_arAxisParameter_1__lreGrundstellung_mm_changed(const QVariant &value)
{
    if(m_grundstellungX<0){
        m_grundstellungX=value.toDouble()/1000.0;
        //initTabelle();
    }

    m_grundstellungX=value.toDouble()/1000.0;
    ui.le_GrundPosX->setText(QString::number(m_grundstellungX, 'f', 3));
    qDebug() << "m_grundstellungX: " << m_grundstellungX;

}


void MainWindow::on_g_stMachineParameter_arAxisParameter_2__lreGrundstellung_mm_changed(const QVariant &value)
{
    if((value.toDouble()/1000.0-m_grundstellungY)<0.0001){
        INIMANAGER.setGrundpositionY(m_grundstellungY);
    }

    m_grundstellungY=value.toDouble()/1000.0;
    ui.le_GrundPosY->setText(QString::number(m_grundstellungY, 'f', 3));
    qDebug() << " m_grundstellungY: " << m_grundstellungY;
}


void MainWindow::on_btn_VisuHand_clicked()
{
    Keypad dlg(trUtf8("Passwort"), "", QLineEdit::Password);
    if(dlg.exec() == QDialog::Accepted){
        QString passwort = dlg.value();
        if(passwort == "1"){
//        if(passwort == "amk5005191"){
            ui.stackedWidget->setCurrentIndex(PageHand);
        }
    }
}

void MainWindow::on_btn_Ein_Aus_2_clicked(bool checked)
{
    on_btn_Ein_Aus_clicked(checked);
}

void MainWindow::on_btn_Ein_Aus_3_clicked(bool checked)
{
    on_btn_Ein_Aus_clicked(checked);
}

void MainWindow::on_btn_JogPlusX_pressed()
{
    if(!m_plcHandler.writePlcValue(g_boJogPlus_X, true))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boJogPlus_X);
}

void MainWindow::on_btn_JogPlusX_released()
{
    if(!m_plcHandler.writePlcValue(g_boJogPlus_X, false))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boJogPlus_X);
}

void MainWindow::on_btn_JogMinusX_pressed()
{
    if(!m_plcHandler.writePlcValue(g_boJogMinus_X, true))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boJogMinus_X);
}

void MainWindow::on_btn_JogMinusX_released()
{
    if(!m_plcHandler.writePlcValue(g_boJogMinus_X, false))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boJogMinus_X);
}

void MainWindow::on_btn_JogPlusY_pressed()
{
    if(!m_plcHandler.writePlcValue(g_boJogPlus_Y, true))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boJogPlus_Y);
}

void MainWindow::on_btn_JogPlusY_released()
{
    if(!m_plcHandler.writePlcValue(g_boJogPlus_Y, false))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boJogPlus_Y);

}

void MainWindow::on_btn_JogMinusY_pressed()
{
    if(!m_plcHandler.writePlcValue(g_boJogMinus_Y, true))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boJogMinus_Y);
}

void MainWindow::on_btn_JogMinusY_released()
{
    if(!m_plcHandler.writePlcValue(g_boJogMinus_Y, false))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boJogMinus_Y);
}

void MainWindow::on_btn_Referenz_pressed()
{
    if(!m_plcHandler.writePlcValue(g_boReferenzpunktfahrt, true))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boReferenzpunktfahrt);
}

void MainWindow::on_btn_Referenz_released()
{
    if(!m_plcHandler.writePlcValue(g_boReferenzpunktfahrt, false))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boReferenzpunktfahrt);
}

void MainWindow::on_btn_StartTabelle_pressed()
{
//    if(!m_plcHandler.writePlcValue(g_boStart, true))
//        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boStart);
}

void MainWindow::on_btn_StartTabelle_released()
{
//    if(!m_plcHandler.writePlcValue(g_boStart, false))
//        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boStart);
}

void MainWindow::on_btn_Reset_pressed()
{
    if(!m_plcHandler.writePlcValue(g_boError_Reset, true))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boError_Reset);

    if(!m_plcHandler.writePlcValue(g_boFlagTabelleGelesen, false)){
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boFlagTabelleGelesen);
    }

    on_btn_Stop_clicked();

    ui.widget_2->setEnabled(true);
    ui.btn_VisuAutomatik->setEnabled(true);
    ui.btn_Zurueck->setEnabled(true);
    ui.btn_VisuHand->setEnabled(true);
    ui.btn_VisuHand_2->setEnabled(true);
    m_spielAktiv=false;
    m_automatikAktiv=false;
    m_looserModeAktiv=false;
}

void MainWindow::on_btn_Reset_released()
{
    if(!m_plcHandler.writePlcValue(g_boError_Reset, false))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boError_Reset);
}

void MainWindow::on_btn_VisuAutomatik_clicked()
{
    ui.stackedWidget->setCurrentIndex(PageAutomatik);
}

void MainWindow::on_btn_VisuSpiel_clicked()
{
    ui.stackedWidget->setCurrentIndex(PageGame);
}


void MainWindow::on_btn_StartGrundPos_pressed()
{
    if(!m_plcHandler.writePlcValue(g_boGrundstellung, true))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boGrundstellung);
}

void MainWindow::on_btn_StartGrundPos_released()
{
    if(!m_plcHandler.writePlcValue(g_boGrundstellung, false))
        LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boGrundstellung);
}

void MainWindow::on_PLC_PRG_enAktiverModus_changed(const QVariant &value)
{
    switch(value.toInt()){
    case KEIN_MODUS:
        ui.le_aktModus->setText("KEIN_MODUS");
        break;
    case MASCHINE_INIT:
        ui.le_aktModus->setText("MASCHINE_INIT");
        break;
    case REFERENZPUNKTFAHRT_AKTIV:
        ui.le_aktModus->setText("REFERENZPUNKTFAHRT_AKTIV");
        break;
    case REFERENZPUNKTFAHRT_DONE:
        ui.le_aktModus->setText("REFERENZPUNKTFAHRT_DONE");
        break;
    case TABELLE_AKTIV:
        ui.le_aktModus->setText("TABELLE_AKTIV");
        break;
    case TIPPEN_AKTIV:
        ui.le_aktModus->setText("TIPPEN_AKTIV");
        break;
    case GRUNDSTELLUNG_AKTIV:
        ui.le_aktModus->setText("GRUNDSTELLUNG_AKTIV");
        break;
    case GRUNDSTELLUNG_DONE:
        ui.le_aktModus->setText("GRUNDSTELLUNG_DONE");
        break;
    case SW_ENDSCHALTER_AKTIV:
        ui.le_aktModus->setText("SW_ENDSCHALTER_AKTIV");
        break;
    case FEHLER_TABELLE:
        ui.le_aktModus->setText("FEHLER_TABELLE");
        break;
    case BERECHNE_STARTPOS:
        ui.le_aktModus->setText("BERECHNE_STARTPOS");
        break;
    case STARTPOS_AKTIV:
        ui.le_aktModus->setText("STARTPOS_AKTIV");
        break;
    case STARTPOS_DONE:
        ui.le_aktModus->setText("STARTPOS_DONE");
        break;
    case BALLABHOLEN_AKTIV:
        ui.le_aktModus->setText("BALLABHOLEN_AKTIV");
        break;
    case BALLABHOLEN_DONE:
        ui.le_aktModus->setText("BALLABHOLEN_DONE");
        break;
    case BALLABHOLEN_FEHLER:
        ui.le_aktModus->setText("BALLABHOLEN_FEHLER");
        break;
    case LIGHTSHOW_AKTIV:
        ui.le_aktModus->setText("LIGHTSHOW_AKTIV");
        break;
    case LIGHTSHOW_DONE:
        ui.le_aktModus->setText("LIGHTSHOW_DONE");
        break;
    }

}


void MainWindow::on_PLC_PRG_enStatePosTabelle_changed(const QVariant &value)
{
    switch(value.toInt()){
    case KEINE_MELDUNG:
        ui.le_ModTabelle->setText("KEINE_MELDUNG");
        break;
    case TABELLE_LESEN:
        ui.le_ModTabelle->setText("TABELLE_LESEN");
        break;
    case TABELLE_OK:
        ui.le_ModTabelle->setText("TABELLE_OK");
        break;
    case FEHLER_TABELLE_LESEN:
        ui.le_ModTabelle->setText("FEHLER_TABELLE_LESEN");
        break;
    case TABELLENWERTE_UNGUELTIG:
        ui.le_ModTabelle->setText("TABELLENWERTE_UNGUELTIG");
        break;
    case WARTEN_AUF_START:
        ui.le_ModTabelle->setText("WARTEN_AUF_START");
        break;
    case TABELLE_RUN:
        ui.le_ModTabelle->setText("TABELLE_RUN");
        break;
    case STARTPUNKT_TABELLE_NICHT_NULL:
        ui.le_ModTabelle->setText("STARTPUNKT_TABELLE_NICHT_NULL");
        break;
    case KEINE_REGLERFREIGABE:
        ui.le_ModTabelle->setText("KEINE_REGLERFREIGABE");
        break;
    case REFERENZPUNKT_NICHT_BEKANNT:
        ui.le_ModTabelle->setText("REFERENZPUNKT_NICHT_BEKANNT");
        break;
    case GRUNDSTELLUNG_FEHLER:
        ui.le_ModTabelle->setText("GRUNDSTELLUNG_AKTIV");
        break;
    case STARTPOSITION_FEHLER:
        ui.le_ModTabelle->setText("STARTPOSITION_FEHLER");
        break;
    case ABBRUCH:
        ui.le_ModTabelle->setText("ABBRUCH");
        break;
    case VERWEILZEIT:
        ui.le_ModTabelle->setText("VERWEILZEIT");
        break;
    case FERTIG:
        ui.le_ModTabelle->setText("FERTIG");
        break;
    }

}


void MainWindow::on_btn_VisuHand_2_clicked()
{
    on_btn_VisuHand_clicked();
}

void MainWindow::on_g_boFlagTabelleGelesen_changed(const QVariant &value)
{
    if(value.toBool()){
        if(!m_plcHandler.writePlcValue(g_boFlagTabelleGelesen, false)){
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boFlagTabelleGelesen);
        }
        qDebug() << "g_boFlagTabelleGelesen: " << m_automtikIndex << " m_grundstellungX: " << m_grundstellungX<< " m_grundstellungY: " << m_grundstellungY;
        if(m_automatikAktiv){
            createData();
        }
    }
}

void MainWindow::on_g_stMachineParameter_arAxisParameter_1__lrePositionBallAbholen_mm_changed(const QVariant &value)
{
    ui.le_BallPosX->setText(QString::number(value.toDouble()/1000.0, 'f', 3));
}


void MainWindow::on_g_stMachineParameter_arAxisParameter_2__lrePositionBallAbholen_mm_changed(const QVariant &value)
{
    ui.le_BallPosY->setText(QString::number(value.toDouble()/1000.0, 'f', 3));
}


void MainWindow::on_tableWidget_clicked(const QModelIndex &index)
{
    switch(index.row()){
    case IPO_StartPositionX:
    {
        Numpad dlg(trUtf8("Startposition X"), QString::number(m_sw_end_neg_x, 'f', 3), QString::number(m_sw_end_pos_x, 'f', 3), index.data().toString());
        if(dlg.exec() == QDialog::Accepted){
            m_AblaufDaten[index.column()].startPosition_x=dlg.valueDouble();
            ui.tableWidget->item(index.row(), index.column())->setData(Qt::DisplayRole, QString::number(dlg.valueDouble(), 'f', 3));
        }
        break;
    }
    case IPO_StartPositionY:
    {
        Numpad dlg(trUtf8("Startposition Z"), QString::number(m_sw_end_neg_y, 'f', 3), QString::number(m_sw_end_pos_y, 'f', 3), index.data().toString());
        if(dlg.exec() == QDialog::Accepted){
            m_AblaufDaten[index.column()].startPosition_y=dlg.valueDouble();
            ui.tableWidget->item(index.row(), index.column())->setData(Qt::DisplayRole, QString::number(dlg.valueDouble(), 'f', 3));
        }
        break;
    }
    case IPO_Hoehe1:
    {
        Numpad dlg(trUtf8("Höhe vorwärts"), "0.0", "1.5", index.data().toString());
        if(dlg.exec() == QDialog::Accepted){
            m_AblaufDaten[index.column()].h1=dlg.valueDouble();
            ui.tableWidget->item(index.row(), index.column())->setData(Qt::DisplayRole, QString::number(dlg.valueDouble(), 'f', 3));
        }
        break;
    }
    case IPO_Hoehe2:
    {
        Numpad dlg(trUtf8("Höhe rückwärts"), "0.0", "1.5", index.data().toString());
        if(dlg.exec() == QDialog::Accepted){
            m_AblaufDaten[index.column()].h2=dlg.valueDouble();
            ui.tableWidget->item(index.row(), index.column())->setData(Qt::DisplayRole, QString::number(dlg.valueDouble(), 'f', 3));
        }
        break;
    }
    case IPO_Weite:
    {
        Numpad dlg(trUtf8("Weite"), "0.0", "2.0", index.data().toString());
        if(dlg.exec() == QDialog::Accepted){
            m_AblaufDaten[index.column()].s_max=dlg.valueDouble();
            ui.tableWidget->item(index.row(), index.column())->setData(Qt::DisplayRole, QString::number(dlg.valueDouble(), 'f', 3));
        }
        break;
    }
    case IPO_Anzahl1:
    {
        Numpad dlg(trUtf8("Anzahl vorwärts"), "1", "15", index.data().toString());
        if(dlg.exec() == QDialog::Accepted){
            m_AblaufDaten[index.column()].n1=dlg.valueInt();
            ui.tableWidget->item(index.row(), index.column())->setData(Qt::DisplayRole, QString::number(dlg.valueDouble(), 'f', 0));
        }
        break;
    }
    case IPO_Anzahl2:
    {
        Numpad dlg(trUtf8("Anzahl rückwärts"), "1", "15", index.data().toString());
        if(dlg.exec() == QDialog::Accepted){
            m_AblaufDaten[index.column()].n2=dlg.valueInt();
            ui.tableWidget->item(index.row(), index.column())->setData(Qt::DisplayRole, QString::number(dlg.valueDouble(), 'f', 0));
        }
        break;
    }
    case IPO_Zwischenpause:
    {
        Numpad dlg(trUtf8("Zwischenpause"), "0.0", "5.0", index.data().toString());
        if(dlg.exec() == QDialog::Accepted){
            m_AblaufDaten[index.column()].zwischenpause=dlg.valueDouble();
            ui.tableWidget->item(index.row(), index.column())->setData(Qt::DisplayRole, QString::number(dlg.valueDouble(), 'f', 3));
        }
        break;
    }
    case IPO_PauseZurueck:
    {
        Numpad dlg(trUtf8("Pause zurück"), "0.0", "5.0", index.data().toString());
        if(dlg.exec() == QDialog::Accepted){
            m_AblaufDaten[index.column()].pause=dlg.valueDouble();
            ui.tableWidget->item(index.row(), index.column())->setData(Qt::DisplayRole, QString::number(dlg.valueDouble(), 'f', 3));
        }
        break;
    }
    case IPO_PauseVor:
    {
        Numpad dlg(trUtf8("Pause Start"), "0.0", "5.0", index.data().toString());
        if(dlg.exec() == QDialog::Accepted){
            m_AblaufDaten[index.column()].pauseVor=dlg.valueDouble();
            ui.tableWidget->item(index.row(), index.column())->setData(Qt::DisplayRole, QString::number(dlg.valueDouble(), 'f', 3));
        }
        break;
    }
    case IPO_Steigung1:
    {
        Numpad dlg(trUtf8("Steigung vorwärts"), "0.0", "0.1", index.data().toString());
        if(dlg.exec() == QDialog::Accepted){
            m_AblaufDaten[index.column()].offset_y=dlg.valueDouble();
            ui.tableWidget->item(index.row(), index.column())->setData(Qt::DisplayRole, QString::number(dlg.valueDouble(), 'f', 3));
        }
        break;
    }
    case IPO_Steigung2:
    {
        Numpad dlg(trUtf8("Steigung rückwärts"), "0.0", "0.1", index.data().toString());
        if(dlg.exec() == QDialog::Accepted){
            m_AblaufDaten[index.column()].offset_y2=dlg.valueDouble();
            ui.tableWidget->item(index.row(), index.column())->setData(Qt::DisplayRole, QString::number(dlg.valueDouble(), 'f', 3));
        }
        break;
    }
    case IPO_BeschleunigungX:
    {
        Numpad dlg(trUtf8("Beschleunigung X"), "10.0", "50.0", index.data().toString());
        if(dlg.exec() == QDialog::Accepted){
            m_AblaufDaten[index.column()].a_xmax=dlg.valueDouble();
            ui.tableWidget->item(index.row(), index.column())->setData(Qt::DisplayRole, QString::number(dlg.valueDouble(), 'f', 3));
        }
        break;
    }
    case IPO_BeschleunigungY:
    {
        Numpad dlg(trUtf8("Beschleunigung Y"), "15.0", "155.0", index.data().toString());
        if(dlg.exec() == QDialog::Accepted){
            m_AblaufDaten[index.column()].a_ymax=dlg.valueDouble();
            ui.tableWidget->item(index.row(), index.column())->setData(Qt::DisplayRole, QString::number(dlg.valueDouble(), 'f', 3));
        }
        break;
    }
    }
//    INIMANAGER.setInterpolatorData(index.column(), m_AblaufDaten[index.column()], m_grundstellungX);
}

void MainWindow::on_btn_SaveTabelle_clicked()
{
    Keypad dlg(trUtf8("Passwort"), "", QLineEdit::Password);
    if(dlg.exec() == QDialog::Accepted){
        QString passwort = dlg.value();
        if(passwort == "1234"){
//        if(passwort == "amk5005191"){
            saveTabelle();
        }
    }
}

void MainWindow::on_btn_StartTabelle_clicked(bool checked)
{
    if(checked){
        on_btn_Start_clicked();
    }else{
        on_btn_Stop_clicked();
    }

}

void MainWindow::on_btn_StartTabelle_toggled(bool checked)
{
    if(checked){
        ui.btn_StartTabelle->setText(trUtf8("Stopp Tabelle"));
    }else{
        ui.btn_StartTabelle->setText(trUtf8("Start Tabelle"));
    }
}

void MainWindow::on_g_boBallPositionDone_changed(const QVariant &value)
{

    if(value.toBool() && m_ballPosAktiv){
        if(!m_plcHandler.writePlcValue(g_boBallPositionDone, false))
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boStartPos);


        m_spielAktiv=false;
        ui.btn_Zurueck->setDisabled(false);
        ui.btn_VisuHand->setDisabled(false);
        ui.btn_StartSpiel->setDisabled(false);
        ui.btn_Looser->setDisabled(false);
        ui.widget_2->setDisabled(false);
    }else if (!value.toBool() && m_ballPosAktiv){
        m_ballPosAktiv=false;
        ui.btn_Zurueck->setDisabled(false);
        ui.btn_VisuHand->setDisabled(false);
        ui.btn_StartSpiel->setDisabled(false);
        ui.widget_2->setDisabled(false);
        ui.btn_Looser->setDisabled(false);
    }
}


void MainWindow::on_g_boStartPositionDone_changed(const QVariant &value)
{
    if(value.toBool() && m_startPosAktiv && !m_spielRestart){
        if(!m_plcHandler.writePlcValue(g_boStartPos, false))
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boStartPos);

    }else if (!value.toBool() && m_startPosAktiv && !m_spielRestart && !m_spielAktiv && !m_startPos.isNull()){
        m_startPosAktiv=false;
        ui.btn_StartSpiel->setDisabled(false);
        ui.widget_2->setDisabled(false);
        ui.btn_Zurueck->setDisabled(false);
        ui.btn_VisuHand->setDisabled(false);
        ui.btn_StartBallPos->setEnabled(true);
        ui.btn_Looser->setDisabled(false);
        ui.btn_StartBallPos_2->setEnabled(true);
        ui.btn_StartBallPos_3->setEnabled(true);
    }else if(value.toBool() && m_spielRestart && m_startPosAktiv){
        m_spielRestart=false;
        if(!m_plcHandler.writePlcValue(g_boStartPos, false))
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boStartPos);
        if(!m_error && (ui.widget_2->isValid() || m_looserModeAktiv)){
            m_looserModeAktiv=false;
            if(!m_plcHandler.writePlcValue(g_boStart, true))
                LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boStart);
        }

    }
}


void MainWindow::on_g_boBallAbholenAktiv_changed(const QVariant &value)
{
//    if(m_spielRestart)
//        return;

    m_ballPosAktiv=value.toBool();
    ui.btn_StartBallPos->setChecked(m_ballPosAktiv);
    ui.btn_StartBallPos_2->setChecked(m_ballPosAktiv);
    ui.btn_StartBallPos_3->setChecked(m_ballPosAktiv);
}


void MainWindow::on_g_boAblaufAktiv_changed(const QVariant &value)
{
    if(value.toBool() && m_spielAktiv){
        if(!m_plcHandler.writePlcValue(g_boStart, false))
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boStart);

        ui.btn_StartBallPos->setDisabled(false);
        ui.btn_StartBallPos_2->setDisabled(false);
        ui.btn_StartBallPos_3->setDisabled(false);
        m_spielAktiv=false;
    }
}


void MainWindow::on_btn_Reset_3_pressed()
{
    on_btn_Reset_pressed();
}

void MainWindow::on_btn_Reset_3_released()
{
    on_btn_Reset_released();
}

void MainWindow::on_btn_Reset_2_pressed()
{
    on_btn_Reset_pressed();
}

void MainWindow::on_btn_Reset_2_released()
{
    on_btn_Reset_released();
}

void MainWindow::on_g_boErrorTabelle_changed(const QVariant &value)
{
    if(value.toBool()){
        ui.widget_2->setEnabled(true);
    }
}


void MainWindow::on_btn_StartBallPos_clicked(bool checked)
{
    if(checked){
        ui.widget_2->setDisabled(true);
        ui.btn_StartSpiel->setDisabled(true);
        ui.btn_Looser->setDisabled(true);
        if(m_grundPositionDefault_x>0.0001){
            if(!m_plcHandler.writePlcValue(g_stMachineParameter_arAxisParameter_1__lreGrundstellung_mm, m_grundPositionDefault_x*1000)){
                LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_stMachineParameter_arAxisParameter_1__lreGrundstellung_mm);
            }
        }
        if(m_grundPositionDefault_y>0.0001){
            if(!m_plcHandler.writePlcValue(g_stMachineParameter_arAxisParameter_2__lreGrundstellung_mm, m_grundPositionDefault_y*1000)){
                LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_stMachineParameter_arAxisParameter_2__lreGrundstellung_mm);
            }
        }
        if(!m_plcHandler.writePlcValue(g_boBallAbholen, true))
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boBallAbholen);
    }else{
        if(!m_plcHandler.writePlcValue(g_boBallAbholen, false))
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boBallAbholen);
    }
}

void MainWindow::on_btn_StartBallPos_2_clicked(bool checked)
{
    on_btn_StartBallPos_clicked(checked);
}

void MainWindow::on_btn_StartBallPos_3_clicked(bool checked)
{
    on_btn_StartBallPos_clicked(checked);
}

void MainWindow::on_g_stMachineParameter_boInitMachineData_changed(const QVariant &value)
{
    if(value.toBool()){
        LOG_INFO_1() << "SPS Initialisierung fertig";
        initSPS_Data();
    }
}


void MainWindow::on_btn_ReloadTabelle_clicked()
{
    initTabelle();
}

void MainWindow::on_PLC_PRG_boErrorTabelleLesen_changed(const QVariant &value)
{
    if(value.toBool()){
        if(!m_plcHandler.writePlcValue(g_boFlagTabelleGelesen, false)){
            LOG_ERROR_1() << trUtf8("Kann Variable: \"%1\" nicht schreiben").arg(g_boFlagTabelleGelesen);
        }
    }
}

//do not edit this method, it will overwritten automatically
void MainWindow::cyclicData(const QList<PLC_VARIABLE> &data, const QList<int> &index)
{
    for (int i=0; i<index.size(); ++i){
        QString name=data.at(index.at(i)).name;
        QVariant value=data.at(index.at(i)).value;
        if (name==g_boEC_Ready){
            on_g_boEC_Ready_changed(value);
        }
        if (name==g_boQRF){
            on_g_boQRF_changed(value);
        }
        if (name==g_lreAktPos_X_mm){
            on_g_lreAktPos_X_mm_changed(value);
        }
        if (name==g_lreAktPos_Y_mm){
            on_g_lreAktPos_Y_mm_changed(value);
        }
        if (name==g_lreGeschwindigkeit_X){
            on_g_lreGeschwindigkeit_X_changed(value);
        }
        if (name==g_lreGeschwindigkeit_Y){
            on_g_lreGeschwindigkeit_Y_changed(value);
        }
        if (name==g_lreTempGeraet_X){
            on_g_lreTempGeraet_X_changed(value);
        }
        if (name==g_lreTempGeraet_Y){
            on_g_lreTempGeraet_Y_changed(value);
        }
        if (name==g_lreTempMotor_X){
            on_g_lreTempMotor_X_changed(value);
        }
        if (name==g_lreTempMotor_Y){
            on_g_lreTempMotor_Y_changed(value);
        }
        if (name==g_stMachineParameter_boInitMachineData){
            on_g_stMachineParameter_boInitMachineData_changed(value);
        }
        if (name==g_stMachineParameter_arAxisParameter_1__lreGrundstellung_mm){
            on_g_stMachineParameter_arAxisParameter_1__lreGrundstellung_mm_changed(value);
        }
        if (name==g_stMachineParameter_arAxisParameter_2__lreGrundstellung_mm){
            on_g_stMachineParameter_arAxisParameter_2__lreGrundstellung_mm_changed(value);
        }
        if (name==PLC_PRG_enAktiverModus){
            on_PLC_PRG_enAktiverModus_changed(value);
        }
        if (name==PLC_PRG_enStatePosTabelle){
            on_PLC_PRG_enStatePosTabelle_changed(value);
        }
        if (name==g_boFlagTabelleGelesen){
            on_g_boFlagTabelleGelesen_changed(value);
        }
        if (name==g_stMachineParameter_arAxisParameter_1__lrePositionBallAbholen_mm){
            on_g_stMachineParameter_arAxisParameter_1__lrePositionBallAbholen_mm_changed(value);
        }
        if (name==g_stMachineParameter_arAxisParameter_2__lrePositionBallAbholen_mm){
            on_g_stMachineParameter_arAxisParameter_2__lrePositionBallAbholen_mm_changed(value);
        }
        if (name==g_boBallPositionDone){
            on_g_boBallPositionDone_changed(value);
        }
        if (name==g_boStartPositionDone){
            on_g_boStartPositionDone_changed(value);
        }
        if (name==g_boBallAbholenAktiv){
            on_g_boBallAbholenAktiv_changed(value);
        }
        if (name==g_boAblaufAktiv){
            on_g_boAblaufAktiv_changed(value);
        }
        if (name==g_boErrorTabelle){
            on_g_boErrorTabelle_changed(value);
        }
        if (name==PLC_PRG_boErrorTabelleLesen){
            on_PLC_PRG_boErrorTabelleLesen_changed(value);
        }
    }
}

//do not edit this method, it will overwritten automatically
void MainWindow::stateIntern(const long state)
{
    switch (state){
    case STATE_RUNNING:
        m_plcHandler.setCyclicList(Task_200ms, 200);
            break;
    case STATE_PLC_NOT_CONNECTED:
            break;
    }
}

//do not edit this method, it will overwritten automatically
void MainWindow::initTasks()
{
    Task_200ms
            << g_boEC_Ready
            << g_boQRF
            << g_lreAktPos_X_mm
            << g_lreAktPos_Y_mm
            << g_lreGeschwindigkeit_X
            << g_lreGeschwindigkeit_Y
            << g_lreTempGeraet_X
            << g_lreTempGeraet_Y
            << g_lreTempMotor_X
            << g_lreTempMotor_Y
            << g_stMachineParameter_boInitMachineData
            << g_stMachineParameter_arAxisParameter_1__lreGrundstellung_mm
            << g_stMachineParameter_arAxisParameter_2__lreGrundstellung_mm
            << PLC_PRG_enAktiverModus
            << PLC_PRG_enStatePosTabelle
            << g_boFlagTabelleGelesen
            << g_stMachineParameter_arAxisParameter_1__lrePositionBallAbholen_mm
            << g_stMachineParameter_arAxisParameter_2__lrePositionBallAbholen_mm
            << g_boBallPositionDone
            << g_boStartPositionDone
            << g_boBallAbholenAktiv
            << g_boAblaufAktiv
            << g_boErrorTabelle
            << PLC_PRG_boErrorTabelleLesen;
}


void MainWindow::on_btn_Looser_clicked()
{
    ui.widget_2->invalidate();
    ui.btn_StartSpiel->setDisabled(true);
    ui.btn_Looser->setDisabled(true);
    ui.btn_StartBallPos_3->setDisabled(true);
    ui.widget_2->setDisabled(true);
    m_spielHoehe=INIMANAGER.spielHoehe();
    m_spielWeite=INIMANAGER.spielWeite();
    m_spielRestart=true;
    startPositionChanged(QPointF(INIMANAGER.startPositionLooser_X(), INIMANAGER.startPositionLooser_Y()));
    ui.btn_Zurueck->setDisabled(true);
    ui.btn_VisuHand->setDisabled(true);
    m_spielAktiv=true;
    m_looserModeAktiv=true;
}
