#include "datasource.h"
#include "helpers.h"

static constexpr unsigned DATASIZE = 0x2000;
static const uint8_t VoltageRangeTable [] = {
  S100mV, S200mV, S500mV,
  S1V,       S2V,    S5V,
  S10V,     S20V,   S50V,
};

DataSource::DataSource(QObject * p) : QObject (p),
    usart (QString("/dev/serial/by-id/usb-Kizarm_Labs._USB_Osciloscope_00001-if00")),
    trigerSettings () {
  in_buffer  = new char [DATASIZE];
  packet_buf = new char [DATASIZE];
  packet_cnt = 0;
  state = StateIdle;
  catching = true;
  
  connect (&usart, SIGNAL (readyRead()), this, SLOT (read_data()));
  usart.open (QIODevice::ReadWrite);
  usart.write("?\r\n", 3);
}
DataSource::~DataSource() {
  usart.close();
  delete [] in_buffer;
  delete [] packet_buf;
}
void DataSource::Start() {
  catching = true;
}

void DataSource::read_data() {
  const long numRead = usart.read(in_buffer, DATASIZE);
  if (numRead == 0) return;
  // qDebug ("readen = %ld", numRead);
  parse_input (in_buffer, numRead);
}
void DataSource::parse_input(const char * data, const long len) {
  for (long i=0; i<len; i++) {
    const char c = data [i];
    switch (c) {
      case '!':
        state = StateReply;
        packet_cnt = 0;
        break;
      case '$':
        state = StateHeader;
        packet_cnt = 0;
        break;
      case '#':
        parse_header();
        state = StateData;
        packet_cnt = 0;
        break;
      case '\r':
      case '\n':
        parse_packet();
        state = StateIdle;
        packet_cnt = 0;
        break;
      default:
        packet_buf [packet_cnt] = c;
        packet_cnt += 1;
        if (packet_cnt >= (int) DATASIZE) {
          packet_cnt = 0;
          qDebug ("Buffer overflow");
        }
        break;
    }
  }
}
void DataSource::parse_header() {
  if (packet_cnt != 4) return;
  packet_buf [4] = '\0';
  QString h (packet_buf);
  bool ok = false;
  const unsigned hdr = h.toUInt(&ok, 16);
  if (!ok) return;
  header.common = hdr;
  //qDebug ("header:%04X", hdr);
  if (header.bits.trig_flg) {
    emit PaketTriggered ();
  }
}
static uint8_t from_hex (const char * ptr) {
  uint8_t result = 0u;
  for (unsigned n=0; n<2u; n++) {
    result *= 0x10;
    const char    c = ptr [n];
    const uint8_t v = c > '9' ? c - 'A' + 10 : c - '0';
    result += v;
  }
  return result;
}
static uint8_t find_index (uint8_t n) {
  unsigned m = sizeof (VoltageRangeTable);
  for (unsigned i=0u; i<m; i++) {
    if (n == VoltageRangeTable [i]) return i;
  }
  return 0;
}
void DataSource::parse_reply(const char * data, const int len) {
  printf("(%d):%s\n", len, data);
  TrigerSettings ts;
  ChannelVoltage cv;
  AllSettings as (ts, 0, cv);
  const int bl = len >> 1;
  int k = 0;
  for (int n=0; n<bl; n++) {
    as.common [n] = from_hex (data + k);
    k += 2;
  }
  trigerSettings.channel = as.part.trg.channel;
  trigerSettings.mode    = as.part.trg.mode;
  trigerSettings.rising  = as.part.trg.rising;
  trigerSettings.offset  = as.part.trg.offset;
  trigerSettings.value   = as.part.trg.value;
  as.part.asc = find_index (as.part.asc);         // reverse bits
  as.part.bsc = find_index (as.part.bsc);
  emit SettingReceived (as);
}

void DataSource::parse_packet() {
  if (state == StateReply) {
    packet_buf[packet_cnt] = '\0';
    parse_reply(packet_buf, packet_cnt);
    return;
  }
  QVector<int> ChA, ChB;
  if (state != StateData) return;
  bool ok = false;
  int k=0;
  for (int n=0; n<packet_cnt; n+=3) {
    char buf [4];
    memcpy (buf, packet_buf+n, 3);
    buf[3] = '\0';
    QString s (buf);
    const unsigned sample = s.toUInt(&ok, 16);
    if (ok) {
      if (k & 1) {
        ChB.push_back (sample);
      } else {
        ChA.push_back (sample);
      }
    }
    
    k += 1;
  }
  bool sok = true;
  if (ChA.size() != (int) header.bits.pack_len) sok = false;
  if (ChB.size() != (int) header.bits.pack_len) sok = false;
  const size_t al = ChA.size(), bl = ChB.size();
  if ((al != 1ul) and (al != 1024ul)) { qDebug ("A packet len = %zd", al); }
  if ((bl != 1ul) and (bl != 1024ul)) { qDebug ("B packet len = %zd", bl); }
  if (sok) {
    if ((al == 1ul) or (bl == 1ul)) {  // v kontinuálním módu odešli vždy
      emit Channels_received (ChA, ChB);
    } else if (trigerSettings.mode == TRIGER_MODE_SINGLE) {
      if (catching) {
        catching = false;
        emit Channels_received (ChA, ChB);
      }
    } else {
      emit Channels_received (ChA, ChB);
    }
  } else {
    qDebug ("packet error: ChA=%d, ChB=%d, size=%d", ChA.size(), ChB.size(), header.bits.pack_len);
  }
}
void DataSource::SendTrigerMode(int n) {
  trigerSettings.mode = static_cast<TRIGER_MODE> (n);
  send_trig_mode();
}
void DataSource::SendTrigerEdge(int n) {
  trigerSettings.rising = n ? true : false;
  send_trig_mode();
}
void DataSource::SendTrigerChan(int n) {
  trigerSettings.channel = static_cast<ADC_CHANNELS> (n);
  send_trig_mode();
}

void DataSource::send_trig_mode () {
  RcvdHeader hdr;
  hdr.common = 0u;
  hdr.bits.destinat = DEST_TRIG;
  hdr.bits.cmd_type = TRIGGER_CMD_MODE;
  TriggerModeUnion tmu;
  tmu.common = 0u;
  tmu.bits.mode    = trigerSettings.mode;
  tmu.bits.channel = trigerSettings.channel;
  tmu.bits.rissing = trigerSettings.rising ? 1u : 0u;
  hdr.bits.cmd_value = tmu.common;
  
  const unsigned len = 64;
  char buffer [len];
  int r = snprintf(buffer, len, "$%04X\r\n", (int) hdr.common);
  buffer [r] = '\0';
  usart.write (buffer, r);
  qDebug ("%d:%s", r, strip_eol(buffer));
}
void DataSource::SettingChanged(int n) {
  const MOVE_ITEMS items = static_cast<MOVE_ITEMS>(n);
  RcvdHeader hdr;
  hdr.common = 0u;
  hdr.bits.destinat = DEST_TRIG;
  switch (items) {
    case MOVE_VALUE: hdr.bits.cmd_type = TRIGGER_CMD_VALUE; hdr.bits.cmd_value = trigerSettings.value;  break;
    case MOVE_OFSET: hdr.bits.cmd_type = TRIGGER_CMD_OFSET; hdr.bits.cmd_value = trigerSettings.offset; break;
    default : break;
  }

  const unsigned len = 64;
  char buffer [len];
  int r = snprintf(buffer, len, "$%04X\r\n", (int) hdr.common);
  buffer [r] = '\0';
  usart.write (buffer, r);
  // qDebug ("%d::%d:%s", n, r, strip_eol(buffer));
}
void DataSource::SendBaseRange (int n) {
  RcvdHeader hdr;
  hdr.common = 0u;
  hdr.bits.destinat  = DEST_BASE;
  hdr.bits.cmd_value = n;
  const unsigned len = 64;
  char buffer [len];
  int r = snprintf(buffer, len, "$%04X\r\n", (int) hdr.common);
  buffer [r] = '\0';
  usart.write (buffer, r);
  qDebug ("%d:%s", r, strip_eol(buffer));
}
void DataSource::SendVoltage(int ch, int n) {
  const int k = (unsigned) n >= sizeof (VoltageRangeTable) ? (sizeof (VoltageRangeTable) - 1u) : n;
  uint8_t v = VoltageRangeTable [k];
  RcvdHeader hdr;
  hdr.common = 0u;
  hdr.bits.destinat  = ch == 0 ? DEST_CHA : DEST_CHB;
  hdr.bits.cmd_value = v;
  const unsigned len = 64;
  char buffer [len];
  int r = snprintf(buffer, len, "$%04X\r\n", (int) hdr.common);
  buffer [r] = '\0';
  usart.write (buffer, r);
  qDebug ("%d:%s", r, strip_eol(buffer));
}