#pragma once

#include "FrameDecoder.h"

namespace Incart::Usb
{

// Создан для приема кадров ЭКГ (+ внутр. Асс и Reo) для приборов 7ой серии
// Прибор: КТ07-АД-3 (тип 38), КТ07-АД-1 (тип 46)
class Device7SeriesWithADFrameDecoder final: public FrameDecoder
{
  using ChannelTypeInfo = DevicesInfo::DeviceChannelTypeInfo;
  using ChannelType = DevicesInfo::EDeviceChannelType;
  using ChannelSource = DevicesInfo::EDeviceChannelSourceType;

public:
    Device7SeriesWithADFrameDecoder(size_t ecgSignalCount_) : FrameDecoder("Device7SeriesWithAD")
    {
        m_data.push_back(AdcChannelData{ ChannelTypeInfo{ ChannelType::Ecg, ChannelSource::Device }, static_cast<int8_t>(ecgSignalCount_) });
        m_data.push_back(AdcChannelData{ ChannelTypeInfo{ ChannelType::Reo, ChannelSource::Device }, 2 });
        m_data.push_back(AdcChannelData{ ChannelTypeInfo{ ChannelType::Acc, ChannelSource::Device }, 3 });
        m_data.push_back(AdcChannelData{ ChannelTypeInfo{ ChannelType::Prs, ChannelSource::Device }, 1 });
        m_data.push_back(AdcChannelData{ ChannelTypeInfo{ ChannelType::Ton, ChannelSource::Device }, 1 });
    }

protected:
    bool isValidFrame(const std::vector<uint8_t>& frame) override
    {
        if (frame.size() != 7 + 3*16 + 2)
        {
            return false;
        }

        int32_t z0 = static_cast<int32_t>(frame[0]);
        int32_t z1 = static_cast<int32_t>(frame[1]);
        int32_t z2 = static_cast<int32_t>(frame[2]);
        int32_t z3 = static_cast<int32_t>(frame[3]);

        int32_t sign = z0 | (z1<<8) | (z2<<16) | (z3<<24);
        return sign == static_cast<int32_t>(0x8000327E);
    }

    uint32_t getFrameNumber(const std::vector<uint8_t>& frame) override
    {
        int p = 4 + 3 * 16;
        uint32_t z0 = static_cast<uint32_t>(frame[p++]);
        uint32_t z1 = static_cast<uint32_t>(frame[p++]);
        uint32_t ret = (z0 | (z1<<8));
        return ret;
    }

    bool hasButtonLabel(const std::vector<uint8_t>& frame) override
    {
        int offset = 4 + 3 * 15;
        uint32_t flag = static_cast<uint32_t>(frame[offset]);
        return (flag & 0x01) != 0;
    }

    void parseData(const std::vector<uint8_t>& frame) override
    {
        // Ecg
        auto& dataEcg = m_data[0].getData();
        for (int ch = 0; ch < m_data[0].getSignalCount(); ++ch)
        {
            dataEcg[ch] = getAdcValue(frame, ch);
        }
        // Reo
        auto& dataReo = m_data[1].getData();
        for (int ch = 0; ch < 2; ++ch)
        {
            dataReo[ch] = getAdcValue(frame, ch + 8);
        }
        // Acc
        auto& dataAcc = m_data[2].getData();
        for (int ch = 0; ch < 3; ++ch)
        {
            dataAcc[ch] = getAdcValue(frame, ch + 10);
        }
        // Prs
        auto& dataPrs = m_data[3].getData();
        dataPrs[0] = getAdcValue(frame, 13);
        // Ton
        auto& dataTon = m_data[4].getData();
        dataTon[0] = getAdcValue(frame, 14);
    }

    int32_t getAdcValue(const std::vector<uint8_t>& frame, int n)
    {
        int p = 4 + 3 * n;
        if ((p < 0) | (p > (4 + 3 * 16)))
            return 0; // непонятно, что тут делать

        uint32_t z0 = static_cast<uint32_t>(frame[p++]);
        uint32_t z1 = static_cast<uint32_t>(frame[p++]);
        uint32_t z2 = static_cast<uint32_t>(frame[p++]);
        uint32_t z3 = 0;
        if ((z2 & 0x80) != 0) z3 = static_cast<uint32_t>(0xFF000000);
        int32_t res = static_cast<int32_t>(z0 | (z1<<8) | (z2<<16) | z3);
        return  res;
    }
};

} // namespace Incart::Usb