#ifndef PIPROTOCOL_H
#define PIPROTOCOL_H

#include "piserial.h"
#include "piethernet.h"
#include "pitimer.h"

class PIProtocol
{
    enum Type {Serial, Ethernet};
public:
    PIProtocol(string devName, int speed, void * headerPtr, int headerSize, void * dataPtr, int dataSize); // for RS
    PIProtocol(string ip, int port, void * dataPtr, int dataSize); // for Ethernet
    ~PIProtocol();

    enum Quality {Unknown = 1, Failure = 2, Bad = 3, Average = 4, Good = 5};

    void startReceive(); // start receive
    void stopReceive(); // stop receive
    void startSend(float frequency = 20.f) {sendtimer->start(frequency > 0 ? 1000.f / frequency : 1000);} // start sending
    void stopSend() {sendtimer->stop();} // stop sending
    void setDevice(const string & dev_ip, int speed_port);
    void setSendData(void * dataPtr, int dataSize) {sendDataPtr = (unsigned char * )dataPtr; sendDataSize = dataSize;}
    void setReceiveData(void * dataPtr, int dataSize) {this->dataPtr = (unsigned char * )dataPtr; this->dataSize = dataSize;}
    void setSendAddress(string ip, int port) {if (type == PIProtocol::Ethernet) ether->setSendAddress(ip, port);} // for Ethernet
    void setParameters(Flags<PISerial::Parameters> parameters) {if (type == PIProtocol::Serial) serial->setParameters(parameters);} // for RS

    void setExpectedFrequency(float frequency); // for start diagnostic connection quality
    float * immediateFrequency_ptr() {return &immediateFreq;}
    float * integralFrequency_ptr() {return &integralFreq;}
    unsigned long long int * wrongCount_ptr() {return &wrong_count;}
    unsigned long long int * receiveCount_ptr() {return &receive_count;}
    unsigned long long int * sendCount_ptr() {return &send_count;}
    PIProtocol::Quality * quality_ptr() {return &net_diag;}
    string * deviceState_ptr() {return &devState;}
    string deviceName() {return devName;}

protected:
    virtual bool validate() {return true;} // function for validate algorithm and save data from dataPtr to external struct
    virtual unsigned int checksum(unsigned char * data, int size) // function for checksum
    {
        unsigned char c = 0;
        for (int i = 0; i < size; ++i)
            c += data[i];
        c = ~(c + 1);
        return c;
    }
    virtual bool aboutSend() {return true;} // executed before send data, if return 'false' then data is not sending

    void init();
    void send();
    void check_state();
    void calc_freq();
    void calc_diag();
    static bool received(void * t, char * data);
    static void diag_event(void * t);

    PISerial * serial;
    PIEthernet * ether;
    unsigned int dataSize, headerSize, sendDataSize;
    unsigned char * dataPtr, * headerPtr, * sendDataPtr;

private:
    static void run(void * e) {PIProtocol* p = (PIProtocol*)e; if (p->aboutSend()) p->send();}
    PITimer * timer, * sendtimer;
    PIProtocol::Type type;
    PIProtocol::Quality net_diag;
    deque<float> last_freq;
    deque<char> last_packets;
    string devState, devName;
    bool work;
    float exp_freq, immediateFreq, integralFreq, tf;
    int pckt_cnt, pckt_cnt_max, packets[2];
    char * packet;
    char cur_pckt;
    unsigned long long int wrong_count, receive_count, send_count;
};

#endif // PIPROTOCOL_H