#include "windowrace.h"
#include "qvectorhelper.h"
#include "timemodel.h"
#include "ui_windowrace.h"
#include "unistd.h"
#include <QKeySequence>
#include <QObject>
#include <QShortcut>
#include <iostream>
#include <sstream>
#include <string>

using std::cout;
using std::endl;
using std::string;
using std::vector;

WindowRace::WindowRace(DataBase * db, QWidget * parent)
    : QMainWindow(parent), ui(new Ui::WindowRace) {
    ui->setupUi(this);
    this->ui->pBNextRace->setEnabled(false);
    this->finished = false;

    this->wRennlisteSeted = false;

    this->db = db;

    vector<vector<QString>> res;
    res = db->getData("select dauer from renndauer", 1);
    this->fahrzeit = res[0][0].toInt();

    string statement =
        "select minimumroundtime from rennen order by id DESC limit 1";
    res = db->getData(statement, 1);
    this->minimumTime = res[0][0].toInt();

    // fill minSecTimes vector
    statement = "select minsec1, minsec2, minsec3, mindestRundenDauer from "
                "renndauer order by id "
                "DESC limit 1";
    // cout << statement << endl;
    res = db->getData(statement, 4);
    this->minSecTime.append(res[0][0].toInt());
    this->minSecTime.append(res[0][1].toInt());
    this->minSecTime.append(res[0][2].toInt());
    this->minSecTime.append(res[0][3].toInt());

    QVectorHelper::minSec1 = this->minSecTime.at(0);
    QVectorHelper::minSec2 = this->minSecTime.at(1);
    QVectorHelper::minSec3 = this->minSecTime.at(2);
    QVectorHelper::minTrackTime = this->minSecTime.at(3);
    // cout << "Track time minimum:" << QVectorHelper::minTrackTime << endl;

    firstTimeDea = true;
    firstTimeShell = true;
    started = false;
    countdownValue = this->fahrzeit;
    countdown = new Countdown;

    startAmpelThread = new Ampel;
    ampelCounter = 0;

    ui->pBStart->setFocus();

    paused = false;

    Hardware = new HardwareSetup;
    Hardware->start();

    QObject::connect(Hardware, SIGNAL(Dea(int, int)), this,
                     SLOT(deaSlot(int, int)));
    QObject::connect(Hardware, SIGNAL(Shell(int, int)), this,
                     SLOT(shellSlot(int, int)));
    QObject::connect(ui->pBStart, SIGNAL(clicked()), this, SLOT(go()));
    QObject::connect(countdown, SIGNAL(CountdownUpdate()), this,
                     SLOT(countdownUpdate()));
    QObject::connect(startAmpelThread, SIGNAL(ampelUpdate()), this,
                     SLOT(ampelSlot()));
    QObject::connect(startAmpelThread, SIGNAL(ampelUpdate()), this,
                     SLOT(laufcheck()));
    QObject::connect(ui->pBBreak, SIGNAL(clicked()), this,
                     SLOT(breakCounter()));
    QObject::connect(this->ui->pBNextRace, SIGNAL(clicked()), this,
                     SLOT(prepareNextRace()));
    QObject::connect(this->ui->pBStop, SIGNAL(clicked()), this,
                     SLOT(stopClicked()));

    ui->lCountdown->setText(timeWrapper(countdownValue));

    // Ampelsetup
    ui->WAmpel15->hide();
    ui->WAmpel25->hide();
    ui->hW15->setVisible(true);
    ui->hW25->setVisible(true);
    ui->WAmpel14->hide();
    ui->WAmpel24->hide();
    ui->hW14->setVisible(true);
    ui->hW24->setVisible(true);
    ui->WAmpel13->hide();
    ui->WAmpel23->hide();
    ui->hW13->setVisible(true);
    ui->hW23->setVisible(true);
    ui->WAmpel12->hide();
    ui->WAmpel22->hide();
    ui->hW12->setVisible(true);
    ui->hw22->setVisible(true);
    ui->WAmpel11->hide();
    ui->WAmpel21->hide();
    ui->hW11->setVisible(true);
    ui->hW21->setVisible(true);

    vector<vector<QString>> fahrer, autos, rennid, tableData;
    statement = "select id_rennen from aktrennen group by id_rennen order by "
                "id_rennen DESC limit 1";
    rennid = this->db->getData(statement, 1);
    this->renn_id = rennid[0][0].toInt();
    statement = "select fahrershellid, autoshellid, fahrerdeaid, autodeaid "
                "from aktrennen where id_rennen like " +
                rennid[0][0].toStdString() + " limit 1";

    tableData = db->getData2(statement, 4);

    statement = "select name from fahrer where id like " +
                tableData[0][0].toStdString();
    fahrer = this->db->getData2(statement, 1);

    statement = "select name from AutoKonfiguration where id_auto like " +
                tableData[0][1].toStdString() + " order by seit DESC";
    autos = this->db->getData2(statement, 1);

    this->ui->gbShell->setTitle("Shell, " + fahrer[0][0] + ", " + autos[0][0]);

    statement = "select name from fahrer where id like " +
                tableData[0][2].toStdString();
    fahrer = this->db->getData2(statement, 1);

    statement = "select name from AutoKonfiguration where id_auto like " +
                tableData[0][3].toStdString() + " order by seit DESC";
    autos = this->db->getData2(statement, 1);

    this->ui->gbDea->setTitle("Dea, " + fahrer[0][0] + ", " + autos[0][0]);

    this->shellDriverId = tableData[0][0].toInt();
    this->shellCarId = tableData[0][1].toInt();
    this->deaDriverId = tableData[0][2].toInt();
    this->deaCarId = tableData[0][3].toInt();

    // progressbar
    this->ui->pbTime->setMaximum(this->fahrzeit);
    this->ui->pbTime->setMinimum(0);
    this->ui->pbTime->setTextVisible(false);
    this->ui->pbTime->setStyleSheet("QProgressBar::chunk { color: #05B8CC;}");
    this->ui->pbTime->setValue(0);

    QKeySequence ks(Qt::Key_Return); // btw, this is numpad enter
    QShortcut * keyReturn = new QShortcut(ks, this);
    QObject::connect(keyReturn, SIGNAL(activated()), this, SLOT(ReturnPress()));

    // QObject::connect(shortcut, SIGNAL(activated()), this, SLOT(close()));
}

void WindowRace::ReturnPress() {
    // cout << "Return pressed" << endl;
    if (this->ui->pBNextRace->isEnabled()) {
        this->prepareNextRace();
        if (this->wRennlisteSeted) {
            this->wRennliste->changeSelection();
        }
        else {
            cout << "Problem with racelist" << endl;
        }
    }
    else {
        if (started) {
            this->breakCounter();
        }
        else {
            this->go();
        }
    }
}

void WindowRace::prepareNextRace() {
    this->firstTimeShell = true;
    this->firstTimeDea = true;

    // this->ui->lWShellTime->clear();
    // this->ui->lWDeaTime->clear();

    this->ui->lBestZeitDea->setText("∞");
    this->ui->lBestZeitShell->setText("∞");
    this->ui->lCurRoundTimeShell->setText("∞");
    this->ui->lCurRoundDea->setText("∞");

    this->ui->lBridgeShell->setText("∞");
    this->ui->lStraightShell->setText("∞");
    this->ui->lCurvesShell->setText("∞");
    this->ui->lDeltaShellTop->setText("∞");

    this->ui->lBridgeDea->setText("∞");
    this->ui->lStraightDea->setText("∞");
    this->ui->lCurvesDea->setText("∞");
    this->ui->lDeltaDeaTop->setText("∞");

    this->VecShell.clear();
    this->VecDea.clear();

    // clear tableview shell
    timeModelShell = new TimeModel(VecShell, minSecTime);
    ui->lWShellTime->setModel(timeModelShell);

    // clear tableview dea
    timeModelDea = new TimeModel(VecDea, minSecTime);
    ui->lWDeaTime->setModel(timeModelDea);

    this->finished = false;
    this->paused = false;
    this->started = false;
    this->countdownValue = this->fahrzeit;
    this->ampelCounter = 0;
    this->startAmpelThread->terminate();
    this->countdown->terminate();
    this->ui->pBNextRace->setEnabled(false);
    this->ui->lCountdown->setText(timeWrapper(countdownValue));

    // progressbar
    this->ui->pbTime->setStyleSheet("QProgressBar::chunk { color: #05B8CC;}");
    this->ui->pbTime->setValue(0);

    // countdown
    this->ui->lCountdown->setStyleSheet("QLabel { color: black; }");

    // Ampel Setup
    ui->WAmpel15->hide();
    ui->WAmpel25->hide();
    ui->hW15->setVisible(true);
    ui->hW25->setVisible(true);
    ui->WAmpel14->hide();
    ui->WAmpel24->hide();
    ui->hW14->setVisible(true);
    ui->hW24->setVisible(true);
    ui->WAmpel13->hide();
    ui->WAmpel23->hide();
    ui->hW13->setVisible(true);
    ui->hW23->setVisible(true);
    ui->WAmpel12->hide();
    ui->WAmpel22->hide();
    ui->hW12->setVisible(true);
    ui->hw22->setVisible(true);
    ui->WAmpel11->hide();
    ui->WAmpel21->hide();
    ui->hW11->setVisible(true);
    ui->hW21->setVisible(true);
}
void WindowRace::setDriverAndCar(vector<QString> vec) {
    this->ui->gbShell->setTitle("Shell, " + vec[0] + ", " + vec[1]);
    this->ui->gbDea->setTitle("Dea, " + vec[2] + ", " + vec[3]);
}
void WindowRace::stopClicked() {
    this->prepareNextRace();
}

void WindowRace::setWindowRennliste(WindowRennliste * ptrInstance) {

    this->wRennliste = ptrInstance;
    this->wRennlisteSeted = true;
    QObject::connect(this->ui->pBNextRace, SIGNAL(clicked()), this->wRennliste,
                     SLOT(changeSelection()));
}
void WindowRace::setDriverAndCarId(vector<QString> vec) {
    this->shellDriverId = vec[0].toInt();
    this->shellCarId = vec[1].toInt();
    this->deaDriverId = vec[2].toInt();
    this->deaCarId = vec[3].toInt();
}
void WindowRace::closeEvent(QCloseEvent * event) {
    countdown->setStop();

    QMessageBox msgBox;
    msgBox.setText("Wirklich schliessen?");
    msgBox.setInformativeText("");
    msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
    msgBox.setDefaultButton(QMessageBox::No);
    int ret = msgBox.exec();

    switch (ret) {
    case QMessageBox::No:
        event->ignore();
        break;
    case QMessageBox::Yes:
        this->wRennliste->schliessen();
        this->Hardware->setStop();
        event->accept();
        break;
    default:
        // should never be reached
        break;
    }
}

void WindowRace::breakCounter() {
    if (!paused) {
        paused = true;
        ui->pBBreak->setText("Weiter");
    }
    else {
        ui->pBBreak->setText("Pause");
        paused = false;
    }
}

void WindowRace::laufcheck() {
    // std::cout << "thread lauft noch" << std::endl;
}

QString WindowRace::timeWrapper(long zahl) {

    long min = zahl / 60;
    int sec = zahl % 60;
    QString sec_q;
    if (sec < 10) {
        sec_q = "0" + QString::number(sec);
    }
    else {
        sec_q = QString::number(sec);
    }
    QString min_q = QString::number(min);
    return min_q + ":" + sec_q;
}

void WindowRace::countdownUpdate() {
    if (!paused) {
        countdownValue -= 1;
        if (countdownValue <= 15) {
            this->ui->lCountdown->setStyleSheet("QLabel { color: red; }");
            this->ui->pbTime->setStyleSheet(
                "QProgressBar::chunk { background-color: orange; }");
            // this->ui->pbTime->
        }
        if (countdownValue <= -1) {
            this->finished = true;
            this->wRennliste->setBesttime(QVectorHelper::getMin(VecShell),
                                          QVectorHelper::getMin(this->VecDea));
            this->ui->pBNextRace->setEnabled(true);
        }
        else {
            ui->lCountdown->setText(timeWrapper(countdownValue));
            this->ui->pbTime->setValue(this->fahrzeit -
                                       static_cast<int>(countdownValue));
        }
    }
}

WindowRace::~WindowRace() {
    this->startAmpelThread->setStop();
    this->countdown->setStop();
    this->Hardware->setStop();
    usleep(1000010); // eine Sekunde

    delete this->countdown;
    delete this->Hardware;
    delete this->startAmpelThread;

    // delete this->db;

    delete ui;
}
void WindowRace::shellSlot(int time, int sector) {
    if (started && !paused && !this->finished) {
        if (firstTimeShell) {
            firstTimeShell = false;
            // counterShell.start();
        }
        else {
            // long zeit = counterShell.getTime();
            QVector<int> test;
            switch (sector) {
            case 1:
                VecShell.append(QVector<int>());
                VecShell.last().append(time);

                // update tableview

                test.append(1);
                test.append(2);
                test.append(3);
                this->timeModelShell =
                    new TimeModel(VecShell, minSecTime, test, this);
                //                    this->ui->lWShellTime->setModel(this->timeModelShell);
                ui->lWShellTime->setModel(this->timeModelShell);

                this->ui->lBridgeShell->setText(QString::number(
                    static_cast<double>(QVectorHelper::getMinSec1(VecShell)) /
                    1000));
                break;

            case 2:
                if (VecShell.size() > 0) {
                    if (VecShell.last().size() == 1) {
                        VecShell.last().append(time);
                    }
                    // update tableview

                    test.append(1);
                    test.append(2);
                    test.append(3);
                    this->timeModelShell =
                        new TimeModel(VecShell, minSecTime, test, this);
                    //                        timeModelShell = new
                    //                        TimeModel(VecShell, this);
                    this->ui->lWShellTime->setModel(timeModelShell);
                    this->ui->lStraightShell->setText(QString::number(
                        static_cast<double>(
                            QVectorHelper::getMinSec2(VecShell)) /
                        1000));
                }
                break;
            case 3:
                if (VecShell.size() > 0) {
                    if (VecShell.last().size() == 2) {
                        VecShell.last().append(time);
                        VecShell.last().append(
                            QVectorHelper::getCurTime(VecShell.last()));

                        if (QVectorHelper::getCurTime(VecShell.last()) <=
                            QVectorHelper::getMin(VecShell)) {
                            ui->lBestZeitShell->setText(QString::number(
                                static_cast<double>(
                                    QVectorHelper::getMin(VecShell)) /
                                1000));
                        }
                        ui->lCurRoundTimeShell->setText(QString::number(
                            static_cast<double>(
                                QVectorHelper::getCurTime(VecShell.last())) /
                            1000));

                        // update tableview

                        test.append(1);
                        test.append(2);
                        test.append(3);
                        this->timeModelShell =
                            new TimeModel(VecShell, minSecTime, test, this);
                        //                            timeModelShell = new
                        //                            TimeModel(VecShell, this);
                        this->ui->lWShellTime->setModel(timeModelShell);

                        this->ui->lCurvesShell->setText(QString::number(
                            static_cast<double>(
                                QVectorHelper::getMinSec3(VecShell)) /
                            1000));
                        theoreticalMinShell = 9999;
                        theoreticalMinShell =
                            QVectorHelper::getMinSec1(VecShell) +
                            QVectorHelper::getMinSec2(VecShell) +
                            QVectorHelper::getMinSec3(VecShell);
                        deltaShell = QVectorHelper::getMin(VecShell) -
                                     theoreticalMinShell;
                        this->ui->lDeltaShellTop->setText(QString::number(
                            static_cast<double>(deltaShell) / 1000));

                        if (VecShell.size() > 0) {
                            int zeit =
                                QVectorHelper::getCurTime(VecShell.last());
                            QString statement =
                                "insert into Zeiten (id_rennen, id_fahrer, "
                                "id_auto, id_bahn, zeit) values (" +
                                QString::number(this->renn_id) + ", " +
                                QString::number(this->shellDriverId) + ", " +
                                QString::number(this->shellCarId) + ", 1, " +
                                QString::number(zeit) + ")";
                            // cout << statement.toStdString() << endl;

                            this->db->setData(statement.toStdString());
                        }
                    }
                }

                break;
            }
            if (sector == 3) {
            }

            ui->lWShellTime->scrollToBottom();
        }
    }
    ui->lWShellTime->scrollToBottom();
    ui->lWShellTime->horizontalHeader()->setSectionResizeMode(
        QHeaderView::Stretch);
}
void WindowRace::deaSlot(int time, int sector) {
    if (started && !paused && !this->finished) {
        if (firstTimeDea) {
            firstTimeDea = false;
            counterDea.start();
        }
        else {

            switch (sector) {
            case 1:
                VecDea.push_back(QVector<int>());
                VecDea.last().push_back(time);
                cout << "Dea Sektor 1" << endl;
                timeModelDea = new TimeModel(VecDea, minSecTime, this);
                this->ui->lWDeaTime->setModel(timeModelDea);

                this->ui->lBridgeDea->setText(QString::number(
                    static_cast<double>(QVectorHelper::getMinSec1(VecDea)) /
                    1000));

                break;
            case 2:
                if (VecDea.size() > 0) {
                    if (VecDea.last().size() == 1) {
                        cout << time << sector << endl;
                        VecDea[VecDea.size() - 1].push_back(time);
                        timeModelDea = new TimeModel(VecDea, minSecTime, this);
                        this->ui->lWDeaTime->setModel(timeModelDea);
                        this->ui->lStraightDea->setText(QString::number(
                            static_cast<double>(
                                QVectorHelper::getMinSec2(VecDea)) /
                            1000));
                    }
                    else {
                        // VecDea[VecDea.size()-1].append(9999);
                    }
                }
                break;
            case 3:
                if (VecDea.size() > 0) {
                    // cout << "Time sec 3: " << time << endl;
                    if (VecDea.last().size() == 2) {
                        //                            cout << time << sector <<
                        //                            endl;
                        VecDea.last().push_back(time);

                        // add sum to vector
                        VecDea.last().push_back(
                            QVectorHelper::getCurTime(VecDea.last()));

                        timeModelDea = new TimeModel(VecDea, minSecTime, this);
                        this->ui->lWDeaTime->setModel(timeModelDea);
                    }

                    // best time on widget
                    cout << "cur time: "
                         << QVectorHelper::getCurTime(VecDea.last()) << endl;
                    cout << "min time: " << QVectorHelper::getMin(VecDea)
                         << endl;
                    if (QVectorHelper::getCurTime(VecDea.last()) <=
                        QVectorHelper::getMin(VecDea)) {
                        ui->lBestZeitDea->setText(QString::number(
                            static_cast<double>(QVectorHelper::getMin(VecDea)) /
                            1000));
                    }
                    ui->lCurRoundDea->setText(QString::number(
                        static_cast<double>(
                            QVectorHelper::getCurTime(VecDea.last())) /
                        1000));
                }

                this->ui->lCurvesDea->setText(QString::number(
                    static_cast<double>(QVectorHelper::getMinSec3(VecDea)) /
                    1000));
                theoreticalMinDea = 9999;
                theoreticalMinDea = QVectorHelper::getMinSec1(VecDea) +
                                    QVectorHelper::getMinSec2(VecDea) +
                                    QVectorHelper::getMinSec3(VecDea);
                deltaDea = QVectorHelper::getMin(VecDea) - theoreticalMinDea;
                this->ui->lDeltaDeaTop->setText(
                    QString::number(static_cast<double>(deltaDea) / 1000));
                if (VecDea.size() > 0) {
                    int zeit = QVectorHelper::getCurTime(VecDea.last());
                    QString statement =
                        "insert into Zeiten (id_rennen, id_fahrer, "
                        "id_auto, id_bahn, zeit) values (" +
                        QString::number(this->renn_id) + ", " +
                        QString::number(this->deaDriverId) + ", " +
                        QString::number(this->deaCarId) + ", 2, " +
                        QString::number(zeit) + ")";
                    // cout << statement.toStdString() << endl;
                    this->db->setData(statement.toStdString());
                    ui->lWDeaTime->scrollToBottom();
                }
                break;
            }
        }
    }
    ui->lWDeaTime->scrollToBottom();
    ui->lWDeaTime->horizontalHeader()->setSectionResizeMode(
        QHeaderView::Stretch);
}

long WindowRace::getMinimum(std::vector<long> a) {
    long minimum = -1;
    for (unsigned int i = 0; i < a.size(); i++) {
        if (minimum < 0) {
            if (a[i] >= this->minimumTime) {
                minimum = a[i];
            }
        }
        else {
            if (a[i] < minimum && a[i] >= this->minimumTime) {
                minimum = a[i];
            }
        }
    }
    return minimum;
}
void WindowRace::ampelSlot() {
    if (ampelCounter == 5) {
        ui->WAmpel15->hide();
        ui->WAmpel25->hide();
        ui->hW15->setVisible(true);
        ui->hW25->setVisible(true);
        ui->WAmpel14->hide();
        ui->WAmpel24->hide();
        ui->hW14->setVisible(true);
        ui->hW24->setVisible(true);
        ui->WAmpel13->hide();
        ui->WAmpel23->hide();
        ui->hW13->setVisible(true);
        ui->hW23->setVisible(true);
        ui->WAmpel12->hide();
        ui->WAmpel22->hide();
        ui->hW12->setVisible(true);
        ui->hw22->setVisible(true);
        ui->WAmpel11->hide();
        ui->WAmpel21->hide();
        ui->hW11->setVisible(true);
        ui->hW21->setVisible(true);
        startAmpelThread->terminate();
        started = true;
        countdown->start();
    }
    if (ampelCounter == 4) {
        ampelCounter = 5;
        ui->WAmpel15->setVisible(true);
        ui->WAmpel25->setVisible(true);
        ui->hW15->hide();
        ui->hW25->hide();
    }
    if (ampelCounter == 3) {
        ampelCounter = 4;
        ui->WAmpel14->setVisible(true);
        ui->WAmpel24->setVisible(true);
        ui->hW14->hide();
        ui->hW24->hide();
    }
    if (ampelCounter == 2) {
        ampelCounter = 3;
        ui->WAmpel13->setVisible(true);
        ui->WAmpel23->setVisible(true);
        ui->hW13->hide();
        ui->hW23->hide();
    }
    if (ampelCounter == 1) {
        ampelCounter = 2;
        ui->WAmpel12->setVisible(true);
        ui->WAmpel22->setVisible(true);
        ui->hW12->hide();
        ui->hw22->hide();
    }
    if (ampelCounter == 0) {
        ampelCounter = 1;
        ui->WAmpel11->setVisible(true);
        ui->WAmpel21->setVisible(true);
        ui->hW11->hide();
        ui->hW21->hide();
    }
}

void WindowRace::go() {
    startAmpelThread->start();
}