app/sources/buzzerconn.cpp

/*
    Speed Climbing Stopwatch - Simple Stopwatch for Climbers
    Copyright (C) 2018  Itsblue Development - Dorian Zeder

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published
    by the Free Software Foundation, version 3 of the License.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

#include "headers/buzzerconn.h"

BuzzerConn::BuzzerConn(QObject *parent, QString ip, int port) : QObject(parent)
{
    this->networkManager = new QNetworkAccessManager();
    this->reloadNetworkManager = new QNetworkAccessManager();

    this->socket = new QTcpSocket();

    this->date = new QDateTime;
    this->latest_button_pressed = 0;
    this->connected = false;

    this->ip = ip;
    this->port = port;

    this->setState("disconnected");
    // "http://192.168.4.1"
}

bool BuzzerConn::connect()
{
    qDebug() << "connecting...";

    setState("connecting");

    //wait until the request has finished
    QEventLoop loop;
    QTimer timer;

    timer.setSingleShot(true);
    loop.connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));
    loop.connect(this->socket, SIGNAL(connected()), &loop, SLOT(quit()));

    timer.start(3000);
    this->socket->connectToHost(this->ip, this->port);
    loop.exec();
    timer.stop();

    if(timer.remainingTime() == 0){
        //the time has been triggered -> timeout
        return(false);
    }


    QList<double> times = gettimes(2000);
    qDebug() << times[0];
    if(times[0] == 200.0){
        this->latest_button_pressed = times[2];
        for(int i=0;i<=100;i++){
            this->connection_progress = i;
            emit this->progressChanged();
            if(!calcoffset(this->gettimes(1000))){
                this->connection_progress = 100;
                this->connected = false;
                setState("disconnected");
                return(false);
            }
        }
        this->connected = true;
        setState("connected");
        return(true);
    }
    else{
        this->connected = false;
        setState("disconnected");
        return(false);
    }
}

bool BuzzerConn::calcoffset(QList<double> times)
{
    if(times.length() != 3){
        return(false);
    }
    if(times[0] == 200.0){
        this->latest_button_pressed = times[2];
        double offset = date->currentMSecsSinceEpoch() - times[1];
        if(this->latest_offsets.length()>=100){
            this->latest_offsets.removeFirst();
        }
        this->latest_offsets.append(offset);

        double mem = 0;
        for(int i=0;i<latest_offsets.length();i++){
            mem += latest_offsets[i];
        }
        this->offset = mem / double(latest_offsets.length());
        offsetChanged();
        //qDebug("%20f", this->offset);
        return(true);
    }
    else {
        //this->connected = false;
        return(false);
    }
}

QList<double> BuzzerConn::gettimes(int timeout)
{
    //    QList<double> times;
    //    ReturnData_t ret = senddata(this->networkManager, QUrl(this->ip), timeout);
    //    times.append(double(ret.status_code));

    //    if(ret.status_code == 200){
    //        ret.text.replace("\n","");
    //        ret.text.replace("\r","");
    //        QStringList times_cache = ret.text.split("<br>");
    //        times.append(times_cache[0].toDouble());
    //        times.append(times_cache[1].toDouble());

    //        return(times);
    //    }
    //    else{
    //        return(times);
    //    }

    QList<double> times;
    signed long ret;
    ret = this->sendCommand("GET_TIMESTAMP", timeout);
    if(ret >= 0){
        times.append(double(200));
        times.append(double(ret));
        ret = this->sendCommand("GET_LASTPRESSED", timeout);
        if(ret >= 0){
            times.append(double(ret));
            return(times);
        }
        else {
            times[0] = ret;
        }

    }
    else {
        times.append(ret);
    }
    return(times);

}

bool BuzzerConn::buzzer_triggered()
{

    if(!this->connected){
        return(false);
    }

    if(pending_commands.length() > 0){
        QString command = this->pending_commands.first();

        signed long retval = this->sendCommand(command, 800);
        if(retval > 0){
            this->pending_commands.removeFirst();
        }
    }

    QList<double> times = this->gettimes(1000);
    if(times[0] == 200.0){
        if(times[2] > this->latest_button_pressed){
            this->latest_button_pressed = times[2];

            return(true);
        }
        else {
            return(false);
        }
    }
    else{
        //this->connected = false;
        return(false);
    }
}

bool BuzzerConn::start()
{
    if(!this->connected){
        return(false);
    }
    QList<double> times = this->gettimes(1000);
    if(times[0] == 200.0 && this->connected){
        this->latest_button_pressed = times[2];
        return(true);
    }
    else{
        this->connected = false;
        return(false);
    }
}

double BuzzerConn::get(QString key)
{
    if(key == "offset"){
        return(this->offset);
    }
    else if (key == "lastpressed") {
        return(this->latest_button_pressed);
    }
    else if( key == "currtime") {
        return(this->date->currentMSecsSinceEpoch());
    }
    else if( key == "connection_progress") {
        return(this->connection_progress);
    }
    else if( key == "connected") {
        if(this->connected){
            return(1);
        }
        return(0);
    }
    return(0);
}

void BuzzerConn::setIP(const QString &ipAdress){
    this->ip = ipAdress;
}

QString BuzzerConn::getIP() const
{
    return(this->ip);
}

QString BuzzerConn::getState() const
{
    return(this->state);
}

void BuzzerConn::setState(QString newState){
    this->state = newState;
    emit stateChanged();
}

int BuzzerConn::getProgress() const
{
    return(connection_progress);
}

double BuzzerConn::getOffset() const
{
    return(this->offset);
}

double BuzzerConn::getLastTriggered() const
{
    return(this->latest_button_pressed);
}

QString BuzzerConn::test()
{
    ReturnData_t ret = this->senddata(this->networkManager, QUrl("http://www.google.de"), 500);
    return(ret.text);
}

bool BuzzerConn::refresh()
{
    if(!this->connected){
        return(false);
    }

    if(pending_commands.length() > 0){
        QString command = this->pending_commands.first();

        signed long retval = this->sendCommand(command, 2000);
        if(retval > 0){
            this->pending_commands.removeFirst();
        }
    }

    //refresh the times
    QList<double> ret = this->gettimes(2000);
    if(ret[0] >= 0){
        if(ret[2] > this->latest_button_pressed){
            this->latest_button_pressed = ret[2];
            emit triggered();
        }
        this->errors = 0;
        return(this->calcoffset(ret));
    }
    else {
        this->errors ++;
        if(this->errors > errors_until_disconnect){
            this->socket->disconnectFromHost();
            this->connected = false;
        }
        return(false);
    }

}

ReturnData_t BuzzerConn::senddata(QNetworkAccessManager * NetMan, QUrl serviceUrl, int timeout)
{

    ReturnData_t ret; //this is a custom type to store the returned data
    // Call the webservice

    QNetworkRequest request(serviceUrl);
    request.setHeader(QNetworkRequest::ContentTypeHeader,
                      "application/x-www-form-urlencoded");

    //send a POST request with the given url and data to the server
    QUrlQuery pdata;
    QNetworkReply* reply;

    //wait until the request has finished
    QEventLoop loop;
    QTimer timer;

    timer.setSingleShot(true);
    loop.connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));
    loop.connect(NetMan, SIGNAL(finished(QNetworkReply*)), SLOT(quit()));

    timer.start(timeout);
    reply = NetMan->post(request, pdata.toString(QUrl::FullyEncoded).toUtf8());
    loop.exec();
    timer.stop();

    //get the status code
    QVariant status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);

    ret.status_code = status_code.toInt();
    if(ret.status_code == 0){ //if the statuscode is zero, the connecion to the server was not possible
        ret.status_code = 444;
    }
    //get the full text response
    ret.text = QString::fromUtf8(reply->readAll());

    //return the data
    return(ret);
}

signed long BuzzerConn::sendCommand(QString command, int timeout){

    //if there is any data in the storage, clear it
    if(this->socket->bytesAvailable() > 0){
        this->socket->readAll();
    }

    //send request to the socket server
    QByteArray arrBlock;
    QDataStream out(&arrBlock, QIODevice::WriteOnly);
    //out.setVersion(QDataStream::Qt_5_10);
    out << quint16(0) << command;

    out.device()->seek(0);
    out << quint16(arrBlock.size() - sizeof(quint16));

    this->socket->write(arrBlock);

    //now wait for the server of the sensor to answer
    QEventLoop loop;
    QTimer timer;

    timer.setSingleShot(true);
    loop.connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));
    loop.connect(socket, SIGNAL(readyRead()), &loop, SLOT(quit()));
    timer.start(timeout);
    loop.exec();

    //loop finished
    timer.stop();
    if(timer.remainingTime() == 0){
        //the time has been triggered -> timeout
        return(-1);
    }

    //if the data is not 4 bites long if is invalid -> clear and terminate
    if(this->socket->bytesAvailable() != 4){
        this->socket->readAll();
        return(-2);
    }
    long data = 0;
    this->socket->read((char*)&data,4);

    //qDebug() << data;
    //qDebug() << this->socket->bytesAvailable();

    return data;
}

void BuzzerConn::appendCommand(QString command){
    this->pending_commands.append(command);
}