#include <QPainter>
#include <QResizeEvent>
#include <QPaintEvent>
#include <QWheelEvent>
#include <QSettings>
#include <math.h>
#include "displaywidget.h"
#include "helpers.h"

static const double TimeBaseSteps [] = {
  2.0e-6, 5.0e-6, 1.0e-5, 2.0e-5, 5.0e-5, 1.0e-4, 2.0e-4, 5.0e-4, 1.0e-3,
  2.0e-3, 5.0e-3, 1.0e-2, 2.0e-2, 5.0e-2, 1.0e-1, 2.0e-1, 5.0e-1, 1.0,
};
static const int TimeBaseCounts [] = {
  0, 0, 0, 0, 0, 0, 0, 0, 10,
  5, 2, 1, 1, 1, 1, 1, 1, 1,
};
static const double ChannelsSteps [] = {
  0.1, 0.2, 0.5,
  1.0, 2.0, 5.0,
  10.0,20.0,50.0,
};
static constexpr double   REF_Y  = 3.3;                 // maximum napětí převodníku
static constexpr double   MAX_Y  = double (1 << 12);    // 12. bit rozlišení - 4096 steps
static constexpr double   HALF_Y = 0.5 * MAX_Y;
static constexpr double   QSCL_Y = 0.5 * HALF_Y;
static constexpr double   STEP_Y = REF_Y / MAX_Y;       // jeden krok ve Voltech
static constexpr unsigned T_SIZE = 1u << 10;
static constexpr unsigned T_MASK = T_SIZE - 1u;

DisplayWidget::DisplayWidget(QWidget * p) : QWidget(p), pcol(), ACopy(), BCopy(), m_forward(), m_inverse(), background(), m_ts(nullptr),
  ChA (T_SIZE), ChB(T_SIZE), m_items (MOVE_VALUE), m_timeBase(6), m_ChBase(0), m_timeCount(0u) {
    x_lenght = T_SIZE;
    m_time.a = 200.0;
    m_time.b = 300.0;
    m_volt.a = -1.0 / STEP_Y;
    m_volt.b = +1.0 / STEP_Y;
    m_channels.a = ChannelsSteps[3];
    m_channels.b = ChannelsSteps[3];
    m_offset.a   = 0;
    m_offset.b   = 0;
    marker_type  = MARKER_TIME;
    m_TrgSource  = 0;
    int n = 0;
    for (QPointF & e : ChA) { const QPointF p (n++, 0); e = p; }
    n = 0;
    for (QPointF & e : ChB) { const QPointF p (n++, 0); e = p; }
    m_continual  = false;
    m_cont_limit = 0;
    m_cont_pass  = 0;
}
DisplayWidget::~DisplayWidget() {
}
void DisplayWidget::SendTrigerChan(int n) {
  m_TrgSource = n;
  drawBackground();
  update();
}

void DisplayWidget::MarkerChanged (int n, bool b) {
  if (!b) return;
  // qDebug ("Marker : %d -> %s", n, b ? "true" : "false"); // OK
  switch (n) {
    case 0: marker_type = MARKER_TIME;   break;
    case 1: marker_type = MARKER_VOLT_A; break;
    case 2: marker_type = MARKER_VOLT_B; break;
    default : break;
  }
  drawBackground();
  update();
}

void DisplayWidget::TriggerValues(int n) {
  m_items = static_cast<MOVE_ITEMS>(n);
}
static constexpr double FMULT = 1.189207115002721;
static constexpr double IMULT = 1.0 / FMULT;
void DisplayWidget::wheelEvent(QWheelEvent * event) {
  if (m_ts == nullptr) return;
  const QPoint d = event->angleDelta();
  const double increment = d.y() > 0 ? +1 : -1;
  const double zy = -m_inverse.m22();
  switch (m_items) {
    case MOVE_VALUE: {
      m_ts->value  += uint16_t (increment * zy);
      emit SettingsChanged (m_items);
    } break;
    case MOVE_OFSET: {
      m_ts->offset += increment;
      emit SettingsChanged (m_items);
    } break;
    case MOVE_MARKERA: {
      if (marker_type == MARKER_TIME) m_time.a += increment;
      else                            m_volt.a += increment * zy;
    } break;
    case MOVE_MARKERB: {
      if (marker_type == MARKER_TIME) m_time.b += increment;
      else                            m_volt.b += increment * zy;
    } break;
    case TIME_ZOOM: {
      const double mx = FMULT * double (size().width()) / x_lenght;
      if ((m_forward.m11() > mx) or (increment > 0)) {  // limit to window
        const QMatrix m = increment > 0 ? QMatrix (FMULT,0,0,1,0,0) : QMatrix (IMULT,0,0,1,0,0);
        m_forward *= m;
        m_inverse  = m_forward.inverted();
      }
    } break;
    case OFSET_A: {
      m_offset.a += increment * zy;
    } break;
    case OFSET_B: {
      m_offset.b += increment * zy;
    } break;
    default : {
      qDebug ("wheelEvent : %d", int (m_items));
    } break;
  }
  drawBackground();
  update();
  QWidget::wheelEvent(event);
}
void DisplayWidget::mousePressEvent(QMouseEvent * event) {
  if (m_ts == nullptr) return;
  const QPointF dp = m_inverse.map (event->pos ());
  const double ofs = m_TrgSource ? m_offset.b : m_offset.a;
  // qDebug ("dp:[%g, %g] %g", dp.x(), dp.y(), ofs);
  switch (m_items) {
    case MOVE_VALUE: {
      m_ts->value  = dp.y() - ofs + HALF_Y;
      // qDebug("Set Triger : %d", m_ts->value);
      emit SettingsChanged (m_items);
    } break;
    case MOVE_OFSET: {
      m_ts->offset = dp.x();
      emit SettingsChanged (m_items);
    } break;
    case MOVE_MARKERA: {
      if (marker_type == MARKER_TIME) m_time.a = dp.x();
      else                            m_volt.a = dp.y();
    } break;
    case MOVE_MARKERB: {
      if (marker_type == MARKER_TIME) m_time.b = dp.x();
      else                            m_volt.b = dp.y();
    } break;
    case OFSET_A: {
      m_offset.a = dp.y();
    } break;
    case OFSET_B: {
      m_offset.b = dp.y();
    } break;
    case TIME_ZOOM: QWidget::mousePressEvent(event); return;
    default : {
      qDebug ("mousePressEvent : %d", int (m_items));
    } break;
  }
  drawBackground();
  update();
  QWidget::mousePressEvent(event);
}

void DisplayWidget::resizeEvent(QResizeEvent * event) {
  const QSize sz = event->size();
  reloadMatrix (sz);
  QImage tmpi (sz, QImage::Format_ARGB32);
  background = tmpi;
  drawBackground();
  QWidget::resizeEvent(event);
}
void DisplayWidget::paintEvent(QPaintEvent * event) {
  QPainter p (this);
  p.drawImage(event->rect(), background);
  drawCurrent(p);
  QPen pa (pcol.colA, 2);
  QPen pb (pcol.colB, 2);
  p.setPen(pb);
  QMatrix mb (m_forward);
  mb.translate(0, m_offset.b - HALF_Y);
  p.drawPolyline (mb.map(ChB));
  p.setPen(pa);
  QMatrix ma (m_forward);
  ma.translate(0, m_offset.a - HALF_Y);
  p.drawPolyline (ma.map(ChA));
}
void DisplayWidget::drawCurrent(QPainter & p) {
  if (!m_continual) return;
  const QPen pen (QColor(192,192,192));
  p.setPen (pen);
  QLineF vl (QPointF(m_timeCount, -QSCL_Y), QPointF(m_timeCount, +QSCL_Y));
  p.drawLine (m_forward.map (vl));    // Stávající poloha v kontinuálním módu
}

void DisplayWidget::setTrigger(TrigerSettings * ts) {
  m_ts = ts;
}
void DisplayWidget::DispChannels(QVector<int> cha, QVector<int> chb) {
  ACopy = cha;
  BCopy = chb;
  if (reloadData()) update();
}
bool DisplayWidget::reloadData () {
  const size_t Alen = ACopy.size();
  const size_t Blen = BCopy.size();
  const size_t Amin = Alen < T_SIZE ? Alen : T_SIZE;
  const size_t Bmin = Blen < T_SIZE ? Blen : T_SIZE;
  if ((Alen == 1u) and (Blen == 1u)) { // kontinuální mód
    m_continual = true;
    const QPointF pta (m_timeCount, ACopy [0]), ptb (m_timeCount, BCopy [0]);
    ChA[m_timeCount] = pta;
    ChB[m_timeCount] = ptb;
    m_timeCount += 1u;
    m_timeCount &= T_MASK;
    m_cont_pass += 1;
    if (m_cont_pass >= m_cont_limit) {
      m_cont_pass = 0;
      return true;
    } else {
      return false;
    }
  }
  m_continual = false;
  for (unsigned n=0u; n<Amin; n++) {
    QPointF & p = ChA [n];
    p.setY (ACopy [n]);
  }
  for (unsigned n=0u; n<Bmin; n++) {
    QPointF & p = ChB [n];
    p.setY (BCopy [n]);
  }
  const int l = Alen > Blen ? Alen : Blen;
  if (l != x_lenght) {
    x_lenght = l;
    reloadMatrix (size());
  }
  return true;
}
void DisplayWidget::reloadMatrix(const QSize & sz) {
  const double xm = sz.width();
  const double ym = sz.height();
  const double xz = xm / (x_lenght);   // převod zpět ma pixely
  const double yz = ym / (MAX_Y);
  const QMatrix tm (xz,0,0,-yz, 0, 0.5 * ym);
  m_forward = tm;
  m_inverse = m_forward.inverted();
}
void DisplayWidget::TimeBaseRange(int n) {
  m_timeBase = n;
  m_cont_limit = TimeBaseCounts [m_timeBase];
  //qDebug("count = %d", m_cont_limit);
  reloadMatrix (size());
  drawBackground();
  update();
}

void DisplayWidget::drawBackground() {
  QPainter p (&background);
  QRect r = background.rect();
  p.fillRect (r, QBrush(Qt::black, Qt::SolidPattern));
  if (!m_ts) return;
  const double yb = 0.0, ye = HALF_Y;
  const double xb = 0.0, xe = x_lenght;
  // rastr
  QPen pg (QColor(64,64,64), 1);
  p.setPen(pg);
  const double dx = 100.0;
  for (double x=xb; x<xe; x+=dx) {
    const QLineF yline (x, -ye, x, +ye);
    p.drawLine (m_forward.map(yline));
  }
  const double dv = 0.5;
  const double dy = dv / STEP_Y;
  for (double y=yb; y<ye; y+=dy) {
    const QLineF xlinep (xb, +y, xe, +y);
    p.drawLine (m_forward.map(xlinep));
    const QLineF xlinem (xb, -y, xe, -y);
    p.drawLine (m_forward.map(xlinem));
  }
  QPen pg0 (QColor(128,128,128), 2);
  p.setPen(pg0);
  const QLineF hline0 (xb, 0,  xe, 0);
  p.drawLine (m_forward.map(hline0));
  // triger
  const double ofs = (m_TrgSource ? m_offset.b : m_offset.a) - HALF_Y;
  QPointF trg (m_ts->offset, m_ts->value + ofs);
  QPen pc (QColor(0,128,255), 1);
  p.setPen(pc);
  const qreal  pos = 30.0;
  const QLineF hline = m_forward.map(QLine(xb, trg.y(),  xe, trg.y()));
  const QLineF vline = m_forward.map(QLine(trg.x(), -ye, trg.x(), ye));
  QPointF vb = vline.p1() + QPointF(0,-pos), ve = vline.p2() + QPointF(0,+pos);
  p.drawLine (hline);
  p.drawLine (QLineF(vb,ve));
  // markers
  QPen pm (QColor(255,255,0,196), 1);
  p.setPen(pm);
  if (marker_type == MARKER_TIME) {
    const QLineF ma = m_forward.map(QLine (m_time.a, -ye, m_time.a, ye));
    const QLineF mb = m_forward.map(QLine (m_time.b, -ye, m_time.b, ye));
    vb = ma.p1() + QPointF(0,-pos), ve = ma.p2() + QPointF(0,+pos);
    p.drawLine (QLineF(vb, ve));
    vb = mb.p1() + QPointF(0,-pos), ve = mb.p2() + QPointF(0,+pos);
    p.drawLine (QLineF(vb, ve));
  } else {
    const QLineF ma (xb, m_volt.a, xe, m_volt.a);
    const QLineF mb (xb, m_volt.b, xe, m_volt.b);
    p.drawLine (m_forward.map(ma));
    p.drawLine (m_forward.map(mb));
  }
  // offsets
  QPen ofpen(pcol.colA);
  QVector<qreal>dashes;
  const qreal gap = 10;
  dashes << gap << gap;
  ofpen.setDashPattern(dashes);
  p.setPen (ofpen);
  const QLineF oa (xb, m_offset.a, xe, m_offset.a);
  p.drawLine (m_forward.map(oa));
  ofpen.setColor(pcol.colB);
  ofpen.setDashPattern(dashes);
  ofpen.setDashOffset(gap);
  p.setPen (ofpen);
  const QLineF ob (xb, m_offset.b, xe, m_offset.b);
  p.drawLine (m_forward.map(ob));
  // text
  p.setPen (QPen (pcol.colT));
  QFont font = p.font();
  font.setPixelSize(16);
  p.setFont (font);
  QString desc;
  const double xz = TimeBaseSteps [m_timeBase];
  const int    my = r.size().height() - 10;
  desc.sprintf("T=%ss/d, ChA %gV, ChB %gV", ing_fmt (xz * dx).c_str(), m_channels.a, m_channels.b);
  p.drawText(10,20, desc);
  
  if (marker_type == MARKER_TIME) {
    const double delta = xz * (m_time.b - m_time.a);
    const double freq  = delta == 0.0 ? 0.0 : 1.0 / delta;
    desc.sprintf("Marker A: %ss, Marker B: %ss, Δ=%ss, f=%sHz", ing_fmt(xz * m_time.a).c_str(), ing_fmt(xz * m_time.b).c_str(),
                                                                ing_fmt(delta).c_str(), ing_fmt(freq).c_str());
  } else {
    const double ofs = - (marker_type == MARKER_VOLT_A ? m_offset.a : m_offset.b);
    double scl = 0.0;
    if (marker_type == MARKER_VOLT_A) { p.setPen (QPen (pcol.colA)); scl = m_channels.a; }
    else                              { p.setPen (QPen (pcol.colB)); scl = m_channels.b; }
    //qDebug("scl = %g, a=%g, b=%g, oa=%g, ob=%g", scl, m_volt.a, m_volt.b, m_offset.a, m_offset.b);
    const double yz = STEP_Y * scl;
    const double delta = yz * (m_volt.b - m_volt.a), va = m_volt.a + ofs, vb = m_volt.b + ofs;
    desc.sprintf("Marker A: %sV, Marker B: %sV, Δ=%sV",         ing_fmt(yz * va).c_str(), ing_fmt(yz * vb).c_str(),
                                                                ing_fmt(delta).c_str());
  }
  p.drawText(10,my, desc);
}
void DisplayWidget::SendVoltage(int ch, int n) {
  switch (ch) {
    case 0: m_channels.a = ChannelsSteps [n]; break;
    case 1: m_channels.b = ChannelsSteps [n]; break;
    default: break;
  }
  // qDebug ("Scale: %d => %g,%g", ch, m_channels.a, m_channels.b);
  drawBackground();
  update();
}
void DisplayWidget::reloadChRange(int a, int b) {
  m_channels.a = ChannelsSteps [a];
  m_channels.b = ChannelsSteps [b];
  drawBackground();
  update();
}

void DisplayWidget::saveSettings(QSettings & setting) {
  setting.setValue("TimeA", m_time.a);
  setting.setValue("TimeB", m_time.b);
  setting.setValue("VoltA", m_volt.a);
  setting.setValue("VoltB", m_volt.b);
  setting.setValue("OfsA" , m_offset.a);
  setting.setValue("OfsB" , m_offset.b);
}
void DisplayWidget::restSettings(QSettings & setting) {
  m_time.a = setting.value("TimeA").toDouble();
  m_time.b = setting.value("TimeB").toDouble();
  m_volt.a = setting.value("VoltA").toDouble();
  m_volt.b = setting.value("VoltB").toDouble();
  m_offset.a = setting.value("OfsA").toDouble();
  m_offset.b = setting.value("OfsB").toDouble();
  drawBackground();
  update();
}