#include "singlestack.h"

singleStack::singleStack(uint32_t firstPacketIndex, ADC_ns::bitDepth bitDepth, QList<ADCChannel *> * channelsConfig, int channelOffset, QObject *parent)
    : QObject{parent},
    _bitDepth(bitDepth),
    _channelsCount(0),
    _tachoOffset(0),
    _bytesInSample(2),
    _firstPacketIndex(firstPacketIndex)
{
    for (int __i = 0; __i < 45; __i++) {
        _packets[__i] = QByteArray();
    }

    double __baseFactor = 0;

    if (bitDepth == ADC_ns::bitDepth::BIT16) {
        __baseFactor = (double)12500/32768;
        _bytesInSample = 2;
    } else if (bitDepth == ADC_ns::bitDepth::BIT24) {
        __baseFactor = (double)12500/8388608;
        _bytesInSample = 3;
    }

    for (int i=0; i<channelsConfig->count(); i++) {
        _channelFactors[i] = __baseFactor * channelsConfig->at(i)->getFactor() / 1000; // mV -> V
    }

    _tachoOffset = _bytesInSample * channelOffset * channelsConfig->count() + DATA_OFFSET;
    _channelsCount = channelsConfig->count();

}

void singleStack::insert(int index, QByteArray packet)
{
    _packets[index] = packet;
}

double singleStack::getValue(int packet, uint8_t channel, int sampleNo)
{
        trans_ns::bytes2word __point;
        trans_ns::bytes2long __longPoint;

        int __pointOffset = (channel + _channelsCount * sampleNo) * _bytesInSample + DATA_OFFSET;

        if (_packets[packet].size() < __pointOffset + _bytesInSample) {
            return (double)0;
        } else {
            if (_bytesInSample == 2) {
                __point.bytes.L = _packets[packet][__pointOffset];
                __point.bytes.H = _packets[packet][__pointOffset + 1];
                return (double)((int16_t)__point.word * _channelFactors[channel]);
            } else if (_bytesInSample == 3) {
                __longPoint.bytes.LL = _packets[packet][__pointOffset];
                __longPoint.bytes.LH = _packets[packet][__pointOffset + 1];
                __longPoint.bytes.HL = _packets[packet][__pointOffset + 2];
                if (__longPoint.bytes.HL > 127) {
                    __longPoint.bytes.HH = 0xFF;
                } else {
                    __longPoint.bytes.HH = 0x00;
                }

                return (double)((int32_t)__longPoint.twinWord * _channelFactors[channel]);

            } else return (double)0;
        }
}

bool singleStack::getTachoValue(int packet, int point)
{
    trans_ns::byte2bits __byte;
    int __byteOffset = _tachoOffset + (int)(point / 8);
    int __bitOffset = point % 8;

    if (_packets[packet].size() < __byteOffset + 1) {
        return false;
    } else {
       __byte.byte = _packets[packet][__byteOffset];

       switch (__bitOffset) {
       case 0:
           return __byte.bits.a0 == 1;
           break;
       case 1:
           return __byte.bits.a1 == 1;
           break;
       case 2:
           return __byte.bits.a2 == 1;
           break;
       case 3:
           return __byte.bits.a3 == 1;
           break;
       case 4:
           return __byte.bits.a4 == 1;
           break;
       case 5:
           return __byte.bits.a5 == 1;
           break;
       case 6:
           return __byte.bits.a6 == 1;
           break;
       case 7:
           return __byte.bits.a7 == 1;
           break;

       default: return false;
       }
    }
}