/*
 * HiperfaceNetworkDriver.h
 *
 *  Created on: 4 февр. 2020 г.
 *      Author: user
 */

#ifndef UMLIBRARY_DRIVER_HIPERFACENETWORKDRIVER_HH_
#define UMLIBRARY_DRIVER_HIPERFACENETWORKDRIVER_HH_

#include <stdint.h>

#include "../common/CircularBuffer.hpp"

#include "../peripheral/IUartPort.hh"

#include "../systemic/Timer.hh"

#include "IDiscreteOutput.hh"

#include "HipMessage.hh"

namespace driver {

//!Драйвер сети датчиков Hiperface подключенных по последовательному порту.
class HiperfaceNetworkDriver {
private:
    driver::IDiscreteOutput & flow_control;
    peripheral::IUartPort & connection;

    bool connection_error   = false;
    bool warning            = false;

    //todo ввести буфер сообщений на отправку

    //буфер для приема и передачи сообщений
    //todo объеденить Message и MessageBuff в MessageProcessor
    template<std::size_t data_size>
    class MessageBuff {
    private:
        char data[data_size];
        std::size_t used_size = 0;

    public:
        std::size_t size() const                { return used_size; }
        std::size_t capacity() const            { return data_size; }
        const char * getDataToRead() const      { return data; }

        char * getBuff(std::size_t size_to_use) { return (size_to_use > data_size) ?  nullptr : (used_size = size_to_use, data); }

    };

    static const unsigned int data_size = 16;
    MessageBuff<data_size> data_buff;

    Message message;
    MessageControl * process_message = nullptr;

    void setResult( MessageControl * process_message, const HipResult result );

    systemic::Timer timer;

    enum BaudRate { br600, br1200, br2400, br4800, br9600, br19200, br38400 };

    static unsigned long getAfterMessageTimeout(BaudRate baudrate);
    static unsigned long getMessageTimeout(BaudRate baudrate, const MessageControl * message_control);

    static const BaudRate default_baudrate = br9600;

    BaudRate baudrate = default_baudrate;

    static const unsigned short data_send_timeout_ms = 5;

    enum States {
        not_processing,
        waiting_transfer_completion,
        waiting_timeout,
        waiting_after_response,
        read_error_code,
    };

    States state = not_processing;

    struct HipStatus {
        unsigned char status;

        driver::MessageControl message_control = {
           .address = 0,
           .code = 0x50,
           .send_data_size = 0,
           .send_data = nullptr,
           .rec_data_size = 1,
           .rec_data = &status,
           .timeout_ms = 5,
           .ans_ready_flag = false,
           .result = driver::OK
        };
    } status_request;

    HipResult error_code = driver::OK;


public:
    //...
    bool send( MessageControl * message );
    void reset();

    void process();

    bool isWarning() const                  { return warning; }
    bool isFailure() const                  { return error_code; }
    bool isCriticalError() const            { return error_code == driver::hip_error; }
    bool isConnectionError() const          { return connection_error; }

    void setBaudRate(BaudRate new_baudrate) { baudrate = new_baudrate; }

    float getHipErrorCode() const           { return static_cast<float>( status_request.status ); }
    float getErrorCode() const              { return static_cast<float>( error_code ); }

    HiperfaceNetworkDriver( driver::IDiscreteOutput & flow_control, peripheral::IUartPort & connection );

};

} /* namespace driver */

#endif /* UMLIBRARY_DRIVER_HIPERFACENETWORKDRIVER_HH_ */