//
// Created by titov on 25.11.2021.
//

#include "BissCChannel.hh"
#include "../format/BinaryHelpers.hh"

#include <algorithm>

communication::bissc::BissCChannel::BissCChannel(std::pmr::memory_resource * memory_resource,
                                                 std::size_t channel_bitsize, std::size_t crc_bitsize,
                                                 uint16_t (*crc_calculation)(const char *, std::size_t),
                                                 std::size_t fault_offset,
                                                 std::size_t warning_offset) :
                                                 format::BinaryDataPublisher(memory_resource),
                                                 fault(false), warning(false), crc_error(false),
                                                 crc_check(crc_calculation),
                                                 crc_mask( ~(static_cast<uint16_t>(-1) << crc_bitsize) ),
                                                 data_mask( ~(static_cast<uint64_t>(-1) << static_cast<uint64_t>( channel_bitsize - crc_bitsize ) ) ),
                                                 crc_bitsize( crc_bitsize ),
                                                 warning_offset(warning_offset), fault_offset(fault_offset) {}

void communication::bissc::BissCChannel::read(const void * data, std::size_t size) {

    uint16_t crc_origin = ( *reinterpret_cast<const uint16_t *>(data) & crc_mask );

    uint64_t data_value = ( (*reinterpret_cast<const uint64_t *>(data)) >> crc_bitsize ) & data_mask;

    uint16_t crc_calc = 0;
    crc_calc = crc_check ? (*crc_check)(reinterpret_cast<const char *>(&data_value), size) : crc_origin;

    if( crc_calc == crc_origin ) {

        if(fault_offset != static_cast<std::size_t>(-1) )
            fault = ( data_value >> fault_offset ) & 1u;;

        if(warning_offset != static_cast<std::size_t>(-1) )
            warning = ( data_value >> warning_offset ) & 1u;

        BinaryDataPublisher::read(&data_value, size);

    } else
        crc_error = true;

}

const bool & communication::bissc::BissCChannel::isFault() const {
    return fault;
}

const bool & communication::bissc::BissCChannel::isWarning() const {
    return warning;
}

bool communication::bissc::BissCChannel::isCrcError() const {
    bool error = crc_error;
    crc_error = false;
    return error;
}