#include "clusterstack.h"

clusterStack::clusterStack(int firstPacketIndex, ADC_ns::bitDepth bitDepth, QList<ADCChannel *> *channelsConfig, int channelOffset, QList<ADC *> * slaves, QObject *parent)
    : QObject{parent},
      _bitDepth(bitDepth),
      _channelsCount(0),
      _tachoOffset(0),
      _bytesInSample(2),
      _firstPacketIndex(firstPacketIndex)
{
    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[0][i] = __baseFactor * channelsConfig->at(i)->getFactor() / 1000; // mV -> V
    }

    for (int __slaveIndex = 0; __slaveIndex < slaves->count(); __slaveIndex++) {
        QList<ADCChannel *> * __channelsConfig = slaves->at(__slaveIndex)->getChannelsConfig();

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

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

void clusterStack::insert(int adcIndex, int packetIndex, QByteArray packet)
{
    _packets[adcIndex][packetIndex] = packet;
}

double clusterStack::getValue(int adcIndex, int packetIndex, uint8_t channel, int sampleNo)
{
    trans_ns::bytes2word __point;
    trans_ns::bytes2long __longPoint;

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

    if (__pointOffset < 0) {
            #ifdef CLUSTER_DEBUG
                qDebug() << "(!) pointOffset: " << __pointOffset;
                qDebug() << "(!) channel: " << channel;
                qDebug() << "(!) channelsCount: " << _channelsCount;
                qDebug() << "(!) sampleNo: " << sampleNo;
                qDebug() << "(!) bytesInSample: " << _bytesInSample;
            #endif

            return (double)0;
    }

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

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

       } else return (double)0;    }
}

bool clusterStack::getTachoValue(int adcIndex, int packetIndex, int sampleNo)
{
    trans_ns::byte2bits __byte;
    int __byteOffset = _tachoOffset + (int)(sampleNo / 8);
    int __bitOffset = sampleNo % 8;

    if (_packets[adcIndex][packetIndex].size() < __byteOffset + 1) {
        return false;
    } else {
       __byte.byte = _packets[adcIndex][packetIndex][__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;
       }
    }
}