/*
    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)
{
    // initialize TcpSocket for communication with the extentions
    this->socket = new QTcpSocket();

    // initialize Qdate
    this->date = new QDateTime;
    this->latest_button_pressed = 0;

    // set ip and port
    this->ip = ip;
    this->port = port;

    //standard state: disconnected
    this->setState("disconnected");
}

bool BuzzerConn::connect()
{
    // function to connect to buzzer

    qDebug() << "connecting...";

    setState("connecting");

    //setup loop to wait until the connection has finished
    QEventLoop loop;
    QTimer timer;

    timer.setSingleShot(true);
    // quit the loop when the timer times out
    loop.connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));
    //quit the loop when the connection was established
    loop.connect(this->socket, SIGNAL(connected()), &loop, SLOT(quit()));
    // start the timer before starting to connect
    timer.start(3000);
    //connect
    this->socket->connectToHost(this->ip, this->port);

    //wait for the connection to finish (programm gets stuck in here)
    loop.exec();

    //loop finished
    if(timer.remainingTime() == -1){
        //the time has been triggered -> timeout
        setState("disconnected");
        return(false);
    }

    // stop the timer as the connection has been established
    timer.stop();

    // get the timestamps ( last_pressed and current_timestamp ) from the extention
    QList<double> times = gettimes(2000, true);

    if(times[0] == 200.0){
        //if the request was successfull, set last_triggered and
        this->latest_button_pressed = times[2];
        for(int i=0;i<=100;i++){
            // middle the offset 100 times
            this->connection_progress = i;
            emit this->progressChanged();
            if(!calcoffset(this->gettimes(1000, false))){
                // if a request fails, cancle the connection process
                this->connection_progress = 100;
                setState("disconnected");
                return(false);
            }
        }
        // after middeling the offset for 100 times set the state to connected and quit
        setState("connected");
        return(true);
    }
    else{
        //if not, cancel
        setState("disconnected");
        return(false);
    }
}

bool BuzzerConn::calcoffset(QList<double> times)
{
    //function that recieves the current time of the extention,
    //puts it into the latest offsets list and
    //calculates the avarage offset

    //if there are not enoug items in the list (0=status of the request (200 = success ...); 1 = timestamp that has to be added to the list)
    if(times.length() != 2){
        return(false);
    }

    if(times[0] == 200.0){
        // if the given request was a successfull request, calculate the offset
        double offset = date->currentMSecsSinceEpoch() - times[1];
        //check if the list contains more than or 100 values
        if(this->latest_offsets.length()>=100){
            //if so, delete the first (oldest) one
            this->latest_offsets.removeFirst();
        }
        //append the new offset to the list
        this->latest_offsets.append(offset);
        //variable to store the avarage
        double mem = 0;
        for(int i=0;i<latest_offsets.length();i++){
            //go through the list and add all offsets
            mem += latest_offsets[i];
        }
        //calculate the avarage
        this->offset = mem / double(latest_offsets.length());

        //emit that the offset has changed
        emit offsetChanged();
        //qDebug("%20f", this->offset);
        return(true);
    }
    else {
        //if the given request was not valid, return false
        return(false);
    }
}

QList<double> BuzzerConn::gettimes(int timeout, bool bothTimes)
{
    // function to recieve the timestamps (last_triggered, current_timestamp) from the extentions

    //list to store the return code of the request and the timestamps
    QList<double> times;
    //variable to store answer of the extention
    signed long ret;
    //send request to extention
    ret = this->sendCommand("GET_TIMESTAMP", timeout);
    if(ret >= 0){
        // if it is higer than 0 (=success) append the return code
        times.append(double(200));
        //and the timestamp
        times.append(double(ret));

        if(bothTimes){
            //if both timstamps were requested do the same thing again for the other one (last_triggered)
            ret = this->sendCommand("GET_LASTPRESSED", timeout);

            if(ret >= 0){
                //if the reuest was successfull, append the value to the list
                times.append(double(ret));
            }
            else {
                // if not, change the return code
                times[0] = ret;
            }
        }
    }
    else {
        // if not, append the return code
        times.append(ret);
    }

    //return the list
    return(times);

}

double BuzzerConn::get(QString key)
{
    // function to get all kinds of data

    if(key == "offset"){
        // get the offset of the extention
        return(this->offset);
    }
    else if (key == "lastpressed") {
        // get the last_triggered timestamp of the extention
        return(this->latest_button_pressed);
    }
    else if( key == "currtime") {
        // get the current time
        return(this->date->currentMSecsSinceEpoch());
    }
    else if( key == "connection_progress") {
        //get the connection progress
        return(this->connection_progress);
    }
    else if( key == "connected") {
        // get the state of the connection
        if(this->state == "connected"){
            return(1);
        }
        return(0);
    }
    return(0);
}

bool BuzzerConn::refresh()
{
    // function that has to be called frequently to refresh the connection
    // check if the extention has been triggered
    // sends one command the pending command list
    // and calculates the offset once

    if(this->state != "connected"){
        // if the extention is not connected return
        return(false);
    }

    //send one of the pending commands
    if(pending_commands.length() > 0){
        //get the irst command in the list
        QString command = this->pending_commands.first();
        //send the command
        signed long retval = this->sendCommand(command, 2000);

        if(retval > 0){
            //if the request has been successfull, remove the command from the list
            this->pending_commands.removeFirst();
        }
    }

    // get the timestamps from the extention
    QList<double> ret = this->gettimes(2000);

    if(ret[0] >= 0){
        //if the request has been successfull check if the last_triggered timestamp has changed
        if(ret[2] > this->latest_button_pressed){
            // if it has, set it
            this->latest_button_pressed = ret[2];
            //and emit the trggered signal
            emit triggered();
        }
        // as the requst as been sucessfull, reset the error counter
        this->errors = 0;
        // calculate the offset on time and return
        return(this->calcoffset(ret));
    }
    else {
        // if not add one to the error conter
        this->errors ++;

        if(this->errors > errors_until_disconnect){
            // if the error counter is too high, disconnect
            this->socket->disconnectFromHost();
            this->setState("disconnected");
        }

        // return false
        return(false);
    }

}

signed long BuzzerConn::sendCommand(QString command, int timeout){
    //function to send a commnd to the extention

    //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 << quint16(0) << command;

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

    this->socket->write(arrBlock);

    //now wait for the extention to answer
    QEventLoop loop;
    QTimer timer;

    timer.setSingleShot(true);
    //quit the loop if the timer times out
    loop.connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));
    //or if the request is anwered
    loop.connect(socket, SIGNAL(readyRead()), &loop, SLOT(quit()));

    //start the timer
    timer.start(timeout);
    //start the loop
    loop.exec();

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


    //if the data is not 4 bytes long it is invalid -> clear and terminate
    if(this->socket->bytesAvailable() != 4){
        this->socket->readAll();
        return(-2);
    }
    long data = 0;
    // read four bytes and cast them as a double
    this->socket->read((char*)&data,4);

    //return the data
    return data;
}

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

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);
}