// %flair:license{
// This file is part of the Flair framework distributed under the
// CECILL-C License, Version 1.0.
// %flair:license}
#include "Scope.h"
#include "Scrollbar.h"
#include <qwt_plot_curve.h>
#include <qwt_plot_grid.h>
#include <qwt_plot_magnifier.h>
#include <qwt_plot_canvas.h>
#include <qwt_scale_widget.h>
#include <qwt_legend_label.h>
#include <qwt_legend.h>
#include <qwt_plot_panner.h>
#include <QMouseEvent>
#include <QMenu>
#include <QTimer>
#include <QTime>
#include <QApplication>

#define WHEEL_DIVIDOR 30

Scope::Scope(QString title, float ymin, float ymax, float view_size_s,
             unsigned int refresh_rate_ms, unsigned int history_size)
    : QwtPlot() {
  this->ymin = ymin;
  this->ymax = ymax;
  this->history_size = history_size;
  this->view_size_s = view_size_s;
  orig_view_size_s = view_size_s;

  // scroll bar
  scrollbar = new ScrollBar(Qt::Horizontal, canvas());
  connect(scrollbar, SIGNAL(valueChanged(Qt::Orientation, float, float)), this,
          SLOT(scrollBarMoved(Qt::Orientation, float, float)));
  scrolling = true;

  // minimum size; sinon widget trop grand
  setMinimumHeight(10);
  setMinimumWidth(1);

  alignScales(); // is it necessary?

  //  Initialize data
  elapsed_time_s = 0;

  // Assign a title
  setTitle(title);

  // Axis
  setAxisTitle(QwtPlot::xBottom, "Time (s)");
  setAxisScale(QwtPlot::xBottom, 0, view_size_s);

  setAxisTitle(QwtPlot::yLeft, "Values");
  setAxisScale(QwtPlot::yLeft, ymin, ymax);

  // grid
  QwtPlotGrid *grid = new QwtPlotGrid;
  grid->setPen(QPen(Qt::black, 0, Qt::DotLine));
  grid->attach(this);

  // zoomer
  QwtPlotMagnifier *zoomer = new QwtPlotMagnifier(canvas());
  zoomer->setWheelModifiers(Qt::ControlModifier);
  zoomer->setMouseButton(Qt::NoButton);
  zoomer->setAxisEnabled(xBottom, 0);

  // scroller
  QwtPlotPanner *scroller = new QwtPlotPanner(canvas());
  scroller->setAxisEnabled(xBottom, 0);

  // legend
  QwtLegend *new_legend = new QwtLegend();
  new_legend->setDefaultItemMode(QwtLegendData::Checkable);
  insertLegend(new_legend, QwtPlot::BottomLegend);

  connect(new_legend, SIGNAL(checked(const QVariant &, bool, int)),
          SLOT(legendChecked(const QVariant &, bool)));

  QTimer *timer = new QTimer(this);
  connect(timer, SIGNAL(timeout()), this, SLOT(replot()));
  timer->start(refresh_rate_ms);
}

Scope::~Scope() {
  for (int i = 0; i < curves.count(); i++) {
    free(curves.at(i)->data_x);
    free(curves.at(i)->data_y);
    delete curves.at(i)->plot;
    free(curves.at(i));
  }
}

void Scope::resetXView(void) {
  // setAxisScale(QwtPlot::xBottom,0, orig_view_size_s);
  changeViewSize(orig_view_size_s);
}

void Scope::resetYView(void) { setAxisScale(QwtPlot::yLeft, ymin, ymax); }

bool Scope::eventFilter(QObject *o, QEvent *e) {
  switch (e->type()) {
  case QEvent::Resize: {
    const int fw = ((QwtPlotCanvas *)canvas())->frameWidth();

    QRect rect;
    rect.setSize(((QResizeEvent *)e)->size());
    rect.setRect(rect.x() + fw, rect.y() + fw, rect.width() - 2 * fw,
                 rect.height() - 2 * fw);

    scrollbar->setGeometry(0, 0, rect.width(), 10);
    return true;
  }
  case QEvent::Wheel: {
    // ctrl+wheel is already handled for y zoom
    if (!(QApplication::keyboardModifiers() & Qt::ControlModifier)) {
      QWheelEvent *wheelevent = static_cast<QWheelEvent *>(e);
      if (view_size_s + wheelevent->delta() / WHEEL_DIVIDOR > 0)
        changeViewSize(view_size_s + wheelevent->delta() / WHEEL_DIVIDOR);
    }
    return true;
  }
  default:
    break;
  }
  return QwtPlot::eventFilter(o, e);
}

void Scope::changeViewSize(float new_view_size_s) {
  view_size_s = new_view_size_s;

  if (scrolling == false) {
    // 4 cas: on utilise le temps au milieu de la vue actuelle

    // le temps total est plus petit que le view_size_s, on affiche tout:
    if (elapsed_time_s < view_size_s) {
      scrolling = true;
    } else {
      double min = (min_scroll + max_scroll) / 2 - view_size_s / 2;
      double max = (min_scroll + max_scroll) / 2 + view_size_s / 2;
      // on va du debut jusqu'a view size
      if (min < 0) {
        min = 0;
        max = view_size_s;
      }
      // on va de fin-viewsize jusqu'a la fin
      if (max > elapsed_time_s) {
        min = elapsed_time_s - view_size_s;
        max = elapsed_time_s;
      }
      scrollbar->moveSlider(
          min, max); // move slider coupe le signal, on fait aussi le scrollbar
      scrollBarMoved(Qt::Horizontal, min, max);
    }
  }
}

void Scope::legendChecked(const QVariant &itemInfo, bool on) {
  QwtPlotItem *plotItem = infoToItem(itemInfo);
  if (plotItem)
    showCurve(plotItem, on);
}

void Scope::showCurve(QwtPlotItem *item, bool on) {
  item->setVisible(on);

  QwtLegend *lgd = qobject_cast<QwtLegend *>(legend());

  QList<QWidget *> legendWidgets = lgd->legendWidgets(itemToInfo(item));

  if (legendWidgets.size() == 1) {
    QwtLegendLabel *legendLabel =
        qobject_cast<QwtLegendLabel *>(legendWidgets[0]);

    if (legendLabel)
      legendLabel->setChecked(on);
  }
}

int Scope::addCurve(QPen pen, QString legend) {
  Curve *curve = (Curve *)malloc(sizeof(Curve));
  curve->data_x = (double *)calloc(history_size, sizeof(double));
  curve->data_y = (double *)calloc(history_size, sizeof(double));
  curve->index = 0;
  curve->min_index = 0;
  curve->max_index = 0;

  // Insert new curve
  curve->plot = new QwtPlotCurve(legend);
  curve->plot->attach(this);
  curve->plot->setPen(pen);
  curves.append(curve);

  showCurve(curve->plot, true);

  return curves.count() - 1;
}

void Scope::updateCurve(Curve *curve) {
  if (scrolling == true) {
    curve->plot->setRawSamples(&curve->data_x[curve->min_index],
                               &curve->data_y[curve->min_index],
                               curve->max_index - curve->min_index);
  }

  if (curve->index == history_size) {
    // printf("a revoir qd on arrive a la fin, il faudrait faire un realloc pour
    // rien perdre\n");
    // attention le setrawdata s'attend a ce que l'adresse change pas, ce qui
    // n'est pas le cas avec lerealloc
    // il faudra refaire un setrawdata ici
    curve->index = 0;
    curve->min_index = 0;
    scrolling = true;
  }

  // determine les index pour la visualisation
  if (scrolling == true) {
    curve->max_index = curve->index;
    computeMinIndex(curve, elapsed_time_s - view_size_s);
  }

  scrollbar->setBase(0, elapsed_time_s);
  if (scrolling == true) {
    scrollbar->moveSlider(elapsed_time_s - view_size_s, elapsed_time_s);

    if (elapsed_time_s < view_size_s) {
      setAxisScale(QwtPlot::xBottom, 0, view_size_s);
    } else {
      setAxisScale(QwtPlot::xBottom, elapsed_time_s - view_size_s,
                   elapsed_time_s);
    }
  } else {
    scrollbar->moveSlider(min_scroll, max_scroll);
  }
}

void Scope::alignScales(void) {
  // The code below shows how to align the scales to
  // the canvas frame, but is also a good example demonstrating
  // why the spreaded API needs polishing.
  /*
      plot->canvas()->setFrameStyle(QFrame::Box | QFrame::Plain );
      plot->canvas()->setLineWidth(1);
  */
  for (int i = 0; i < QwtPlot::axisCnt; i++) {
    QwtScaleWidget *scaleWidget = (QwtScaleWidget *)axisWidget(i);
    if (scaleWidget)
      scaleWidget->setMargin(0);

    QwtScaleDraw *scaleDraw = (QwtScaleDraw *)axisScaleDraw(i);
    if (scaleDraw)
      scaleDraw->enableComponent(QwtAbstractScaleDraw::Backbone, false);
  }
}

void Scope::scrollBarMoved(Qt::Orientation o, float min, float max) {
  min_scroll = min;
  max_scroll = max;

  if (max == scrollbar->maxBaseValue()) {
    scrolling = true;
  } else {
    scrolling = false;
    setAxisScale(QwtPlot::xBottom, min, max);

    // determine les index pour la visualisation
    for (int i = 0; i < curves.count(); i++) {
      computeMinIndex(curves.at(i), min);
      computeMaxIndex(curves.at(i), max);
      curves.at(i)->plot->setRawSamples(
          &curves.at(i)->data_x[curves.at(i)->min_index],
          &curves.at(i)->data_y[curves.at(i)->min_index],
          curves.at(i)->max_index - curves.at(i)->min_index);
    }
  }
}

// TODO: faire une dichotomie
void Scope::computeMinIndex(Curve *curve, float displayed_min_time) {
  if (curve->data_x[curve->index] > displayed_min_time) {
    if (curve->data_x[curve->min_index] < displayed_min_time) {
      while (curve->data_x[curve->min_index] < displayed_min_time &&
             curve->min_index != curve->index)
        curve->min_index++;
    } else {
      while (curve->data_x[curve->min_index] > displayed_min_time &&
             curve->min_index != 0)
        curve->min_index--;
    }
  }
}

void Scope::computeMaxIndex(Curve *curve, float displayed_max_time) {
  if (curve->data_x[curve->max_index] < displayed_max_time) {
    while (curve->data_x[curve->max_index] < displayed_max_time &&
           curve->max_index != curve->index)
      curve->max_index++;
  } else {
    while (curve->data_x[curve->max_index] > displayed_max_time)
      curve->max_index--;
  }
}