#include "KeymapEditor.hpp"
#include "MainWindow.hpp"
#include "KeyboardWidget.hpp"
#include <QVBoxLayout>
#include <QPainter>
#include <QScrollBar>

static const int HueTable[] = {0, 30, 60, 80, 120, 170, 200, 240, 280, 320};

static const int SaturationTable[] = {255, 255, 255, 255, 255, 127, 127, 127, 127, 127, 63, 63, 63};

static const int ValueTable[] = {240, 200, 160, 120, 80, 240, 200, 160, 120, 80, 240, 200, 160};

static const QPoint PointTable[] = {{21, 180},  {41, 104},  {61, 180},  {86, 104},  {101, 180}, {141, 180},
                                    {156, 104}, {181, 180}, {201, 104}, {221, 180}, {246, 104}, {261, 180}};

static const int RadiusTable[] = {14, 10, 14, 10, 14, 14, 10, 14, 10, 14, 10, 14};

static const QColor PenColorTable[] = {Qt::black, Qt::white, Qt::black, Qt::white, Qt::black, Qt::black,
                                       Qt::white, Qt::black, Qt::white, Qt::black, Qt::white, Qt::black};

static const QColor NeutralColorTable[] = {Qt::white, Qt::black, Qt::white, Qt::black, Qt::white, Qt::white,
                                           Qt::black, Qt::white, Qt::black, Qt::white, Qt::black, Qt::white};

PaintButton::PaintButton(QWidget* parent) : QPushButton(parent) {
  setIcon(QIcon(QStringLiteral(":/icons/IconPaintbrush.svg")));
  setIconSize(QSize(26, 26));
  setFixedSize(46, 46);
  setToolTip(tr("Activate brush to apply values to keys"));
}

KeymapEditor* KeymapView::getEditor() const {
  return qobject_cast<KeymapEditor*>(parentWidget()->parentWidget()->parentWidget());
}

void KeymapView::loadData(ProjectModel::KeymapNode* node) { m_node = node; }

void KeymapView::unloadData() {
  m_node.reset();
  std::fill(std::begin(m_keyPalettes), std::end(m_keyPalettes), -1);
}

ProjectModel::INode* KeymapView::currentNode() const { return m_node.get(); }

void KeymapView::drawKey(QPainter& painter, const QRect& octaveRect, qreal penWidth, const QColor* keyPalette, int o,
                         int k) const {
  int keyIdx = o * 12 + k;
  int keyPalIdx = m_keyPalettes[keyIdx];
  painter.setPen(QPen(PenColorTable[k], penWidth));
  painter.setBrush(keyPalIdx < 0 ? NeutralColorTable[k] : keyPalette[keyPalIdx]);
  painter.drawEllipse(PointTable[k] + octaveRect.topLeft(), RadiusTable[k], RadiusTable[k]);
  painter.setTransform(
      QTransform()
          .translate(PointTable[k].x() + octaveRect.left() - 13, PointTable[k].y() + octaveRect.top() - 20)
          .rotate(-90.0));
  painter.drawStaticText(QPointF{}, m_keyTexts[keyIdx]);
  painter.setTransform(QTransform());
}

void KeymapView::paintEvent(QPaintEvent* ev) {
  QPainter painter(this);
  painter.setRenderHint(QPainter::Antialiasing);

  const QColor* keyPalette = getEditor()->m_paintPalette;

  qreal deviceRatio = devicePixelRatioF();
  qreal penWidth = std::max(std::floor(deviceRatio), 1.0) / deviceRatio;

  painter.setFont(m_keyFont);
  int kbY = height() / 2 - 100;
  for (int o = 0; o < 10; ++o) {
    QRect thisRect(o * 280, kbY, 280, 200);
    if (ev->rect().intersects(thisRect)) {
      m_octaveRenderer.render(&painter, thisRect);
      for (int k = 0; k < 12; ++k)
        drawKey(painter, thisRect, penWidth, keyPalette, o, k);
    }
  }
  QRect thisRect(2800, kbY, 202, 200);
  if (ev->rect().intersects(thisRect)) {
    m_lastOctaveRenderer.render(&painter, thisRect);
    for (int k = 0; k < 8; ++k)
      drawKey(painter, thisRect, penWidth, keyPalette, 10, k);
  }
}

void KeymapView::mousePressEvent(QMouseEvent* ev) { mouseMoveEvent(ev); }

int KeymapView::getKey(const QPoint& localPos) const {
  QPointF localPoint = m_widgetToSvg.map(localPos);
  for (int i = 0; i < 5; ++i)
    if (m_sharp[i].contains(localPoint))
      return SharpKeyNumbers[i];
  for (int i = 0; i < 7; ++i)
    if (m_natural[i].contains(localPoint))
      return NaturalKeyNumbers[i];
  return -1;
}

void KeymapView::mouseMoveEvent(QMouseEvent* ev) {
  int octave = ev->x() / 280;
  int key = getKey(ev->pos() - QPoint(octave * 280, height() / 2 - 100));
  if (octave >= 0 && key >= 0)
    getEditor()->touchKey(octave * 12 + key, ev->modifiers() & Qt::ShiftModifier);
}

void KeymapView::wheelEvent(QWheelEvent* event) {
  if (QScrollArea* scroll = qobject_cast<QScrollArea*>(parentWidget()->parentWidget())) {
    /* Send wheel event directly to the scroll bar */
    QApplication::sendEvent(scroll->horizontalScrollBar(), event);
  }
}

KeymapView::KeymapView(QWidget* parent)
: QWidget(parent)
, m_octaveRenderer(QStringLiteral(":/bg/keyboard.svg"))
, m_lastOctaveRenderer(QStringLiteral(":/bg/keyboard_last.svg")) {
  setMinimumWidth(3002);

  int k = 0;
  for (int i = 0; i < 11; ++i)
    for (int j = 0; j < 12 && k < 128; ++j)
      m_keyTexts[k++].setText(QStringLiteral("%1%2").arg(KeyStrings[j]).arg(i - 1));
  m_keyFont.setPointSize(12);
  std::fill(std::begin(m_keyPalettes), std::end(m_keyPalettes), -1);

  for (int i = 0; i < 7; ++i)
    if (m_octaveRenderer.elementExists(NaturalKeyNames[i]))
      m_natural[i] = m_octaveRenderer.matrixForElement(NaturalKeyNames[i])
                         .mapRect(m_octaveRenderer.boundsOnElement(NaturalKeyNames[i]));

  for (int i = 0; i < 5; ++i)
    if (m_octaveRenderer.elementExists(SharpKeyNames[i]))
      m_sharp[i] = m_octaveRenderer.matrixForElement(SharpKeyNames[i])
                       .mapRect(m_octaveRenderer.boundsOnElement(SharpKeyNames[i]));

  m_widgetToSvg = RectToRect(QRect(0, 0, 280, 200), m_octaveRenderer.viewBoxF());
}

KeymapEditor* KeymapControls::getEditor() const { return qobject_cast<KeymapEditor*>(parentWidget()); }

void KeymapControls::setPaintIdx(int idx) {
  QPalette palette = m_paintButton->palette();
  if (idx < 0) {
    palette.setColor(QPalette::Background, QWidget::palette().color(QPalette::Background));
    palette.setColor(QPalette::Button, QWidget::palette().color(QPalette::Button));
  } else {
    const QColor* keyPalette = getEditor()->m_paintPalette;
    palette.setColor(QPalette::Background, keyPalette[idx]);
    palette.setColor(QPalette::Button, keyPalette[idx].darker(300));
  }
  m_paintButton->setPalette(palette);
}

void KeymapControls::setKeymap(const amuse::Keymap& km) {
  m_enableUpdate = false;
  int idx = m_macro->collection()->indexOfId(km.macro.id);
  m_macro->setCurrentIndex(idx + 1);
  m_transpose->setValue(km.transpose);
  if (km.pan == -128) {
    m_pan->setDisabled(true);
    m_pan->setValue(true);
    m_surround->setChecked(true);
  } else {
    m_pan->setEnabled(true);
    m_pan->setValue(km.pan);
    m_surround->setChecked(false);
  }
  m_prioOffset->setValue(km.prioOffset);
  m_enableUpdate = true;
}

void KeymapControls::loadData(ProjectModel::KeymapNode* node) {
  m_enableUpdate = false;
  m_macro->setCollection(
      g_MainWindow->projectModel()->getGroupNode(node)->getCollectionOfType(ProjectModel::INode::Type::SoundMacro));
  m_macro->setDisabled(false);
  m_transpose->setDisabled(false);
  m_transpose->setValue(0);
  m_pan->setDisabled(false);
  m_pan->setValue(64);
  m_surround->setDisabled(false);
  m_surround->setChecked(false);
  m_prioOffset->setDisabled(false);
  m_prioOffset->setValue(0);
  m_paintButton->setDisabled(false);
  m_paintButton->setPalette(palette());
  m_enableUpdate = true;
}

void KeymapControls::unloadData() {
  m_enableUpdate = false;
  m_macro->setCollection(nullptr);
  m_macro->setDisabled(true);
  m_transpose->setDisabled(true);
  m_pan->setDisabled(true);
  m_surround->setDisabled(true);
  m_prioOffset->setDisabled(true);
  m_paintButton->setDisabled(true);
  m_paintButton->setPalette(palette());
  m_enableUpdate = true;
}

void KeymapControls::controlChanged() {
  if (m_enableUpdate) {
    amuse::Keymap km;
    km.macro.id = m_macro->currentIndex() == 0 ? amuse::SoundMacroId{}
                                               : m_macro->collection()->idOfIndex(m_macro->currentIndex() - 1);
    km.transpose = int8_t(m_transpose->value());
    km.pan = int8_t(m_pan->value());
    if (m_surround->isChecked()) {
      km.pan = -128;
      m_pan->setDisabled(true);
    } else {
      m_pan->setEnabled(true);
    }
    km.prioOffset = int8_t(m_prioOffset->value());
    getEditor()->touchControl(km);
  }
}

void KeymapControls::paintButtonPressed() {
  KeymapEditor* editor = getEditor();
  if (!editor->m_inPaint) {
    editor->setCursor(QCursor(QPixmap(QStringLiteral(":/icons/IconPaintbrush.svg")), 2, 30));
    editor->m_inPaint = true;
    m_paintButton->setDown(true);
  } else {
    editor->unsetCursor();
    editor->m_inPaint = false;
    m_paintButton->setDown(false);
  }
}

KeymapControls::KeymapControls(QWidget* parent) : QFrame(parent) {
  setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
  setFixedHeight(100);
  setFrameShape(QFrame::StyledPanel);
  setFrameShadow(QFrame::Sunken);
  setBackgroundRole(QPalette::Base);
  setAutoFillBackground(true);

  QPalette palette = QWidget::palette();
  palette.setColor(QPalette::Base, palette.color(QPalette::Background));

  QHBoxLayout* mainLayout = new QHBoxLayout;

  QGridLayout* leftLayout = new QGridLayout;

  leftLayout->addWidget(new QLabel(tr("SoundMacro")), 0, 0);
  m_macro = new FieldProjectNode;
  m_macro->setDisabled(true);
  connect(m_macro, SIGNAL(currentIndexChanged(int)), this, SLOT(controlChanged()));
  leftLayout->addWidget(m_macro, 1, 0);

  leftLayout->addWidget(new QLabel(tr("Transpose")), 0, 1);
  m_transpose = new QSpinBox;
  m_transpose->setPalette(palette);
  m_transpose->setDisabled(true);
  m_transpose->setRange(-128, 127);
  m_transpose->setToolTip(tr("Offset resulting MIDI note"));
  connect(m_transpose, SIGNAL(valueChanged(int)), this, SLOT(controlChanged()));
  leftLayout->addWidget(m_transpose, 1, 1);

  leftLayout->addWidget(new QLabel(tr("Pan")), 0, 2);
  m_pan = new QSpinBox;
  m_pan->setPalette(palette);
  m_pan->setDisabled(true);
  m_pan->setRange(-127, 127);
  m_pan->setToolTip(tr("Set initial pan"));
  connect(m_pan, SIGNAL(valueChanged(int)), this, SLOT(controlChanged()));
  leftLayout->addWidget(m_pan, 1, 2);

  leftLayout->addWidget(new QLabel(tr("Surround")), 0, 3);
  m_surround = new QCheckBox;
  m_surround->setPalette(palette);
  m_surround->setDisabled(true);
  m_surround->setToolTip(tr("Initially play through surround channels"));
  connect(m_surround, SIGNAL(stateChanged(int)), this, SLOT(controlChanged()));
  leftLayout->addWidget(m_surround, 1, 3);

  leftLayout->addWidget(new QLabel(tr("Prio Offset")), 0, 4);
  m_prioOffset = new QSpinBox;
  m_prioOffset->setPalette(palette);
  m_prioOffset->setDisabled(true);
  m_prioOffset->setRange(-128, 127);
  m_prioOffset->setToolTip(tr("Offset resulting priority"));
  connect(m_prioOffset, SIGNAL(valueChanged(int)), this, SLOT(controlChanged()));
  leftLayout->addWidget(m_prioOffset, 1, 4);

  leftLayout->setColumnMinimumWidth(0, 200);
  leftLayout->setColumnMinimumWidth(1, 75);
  leftLayout->setColumnMinimumWidth(2, 75);
  leftLayout->setColumnMinimumWidth(3, 50);
  leftLayout->setColumnMinimumWidth(4, 75);
  leftLayout->setRowMinimumHeight(0, 22);
  leftLayout->setRowMinimumHeight(1, 37);
  leftLayout->setContentsMargins(10, 6, 0, 14);

  QVBoxLayout* rightLayout = new QVBoxLayout;

  m_paintButton = new PaintButton;
  m_paintButton->setDisabled(true);
  connect(m_paintButton, SIGNAL(pressed()), this, SLOT(paintButtonPressed()));
  rightLayout->addWidget(m_paintButton);
  rightLayout->setContentsMargins(0, 0, 10, 0);

  mainLayout->addLayout(leftLayout);
  mainLayout->addStretch(1);
  mainLayout->addLayout(rightLayout);
  setLayout(mainLayout);
}

void KeymapEditor::_touch() {
  if (m_controlKeymap.macro.id == 0xffff)
    m_controls->setPaintIdx(-1);
  else
    m_controls->setPaintIdx(getConfigIdx(m_controlKeymap.configKey()));
}

void KeymapEditor::touchKey(int key, bool bulk) {
  if (m_inPaint) {
    if (bulk) {
      uint64_t refKey = (*m_kmView->m_node->m_obj)[key].configKey();
      for (int i = 0; i < 128; ++i) {
        amuse::Keymap& km = (*m_kmView->m_node->m_obj)[i];
        if (km.configKey() != refKey)
          continue;
        if (km.macro.id != 0xffff)
          deallocateConfigIdx(km.configKey());
        km = m_controlKeymap;
        if (km.macro.id == 0xffff)
          m_kmView->m_keyPalettes[i] = -1;
        else
          m_kmView->m_keyPalettes[i] = allocateConfigIdx(km.configKey());
      }
    } else {
      amuse::Keymap& km = (*m_kmView->m_node->m_obj)[key];
      if (km.macro.id != 0xffff)
        deallocateConfigIdx(km.configKey());
      km = m_controlKeymap;
      if (km.macro.id == 0xffff)
        m_kmView->m_keyPalettes[key] = -1;
      else
        m_kmView->m_keyPalettes[key] = allocateConfigIdx(km.configKey());
    }

    m_kmView->update();
  } else {
    amuse::Keymap& km = (*m_kmView->m_node->m_obj)[key];
    m_controlKeymap = km;
    m_controls->setKeymap(km);
    _touch();
  }
}

void KeymapEditor::touchControl(const amuse::Keymap& km) {
  m_controlKeymap = km;
  _touch();
}

int KeymapEditor::allocateConfigIdx(uint64_t key) {
  auto search = m_configToIdx.find(key);
  if (search != m_configToIdx.end()) {
    ++search->second.second;
    return search->second.first;
  }
  for (int i = 0; i < 129; ++i)
    if (!m_idxBitmap[i]) {
      m_configToIdx[key] = std::make_pair(i, 1);
      m_idxBitmap.set(i);
      return i;
    }
  Q_UNREACHABLE();
}

void KeymapEditor::deallocateConfigIdx(uint64_t key) {
  auto search = m_configToIdx.find(key);
  if (search != m_configToIdx.end()) {
    --search->second.second;
    if (search->second.second == 0) {
      m_idxBitmap.reset(search->second.first);
      m_configToIdx.erase(search);
    }
    return;
  }
  Q_UNREACHABLE();
}

int KeymapEditor::getConfigIdx(uint64_t key) const {
  auto search = m_configToIdx.find(key);
  if (search != m_configToIdx.end())
    return search->second.first;
  for (int i = 0; i < 129; ++i)
    if (!m_idxBitmap[i])
      return i;
  Q_UNREACHABLE();
}

bool KeymapEditor::loadData(ProjectModel::KeymapNode* node) {
  if (m_kmView->m_node.get() != node) {
    m_configToIdx.clear();
    m_idxBitmap.reset();

    for (int i = 0; i < 128; ++i) {
      amuse::Keymap& km = (*node->m_obj)[i];
      if (km.macro.id == 0xffff)
        m_kmView->m_keyPalettes[i] = -1;
      else
        m_kmView->m_keyPalettes[i] = allocateConfigIdx(km.configKey());
    }

    m_controlKeymap = amuse::Keymap();
    m_kmView->loadData(node);
    m_controls->loadData(node);
  }

  m_inPaint = false;
  m_controls->m_paintButton->setDown(false);
  unsetCursor();

  return true;
}

void KeymapEditor::unloadData() {
  m_configToIdx.clear();
  m_idxBitmap.reset();
  m_kmView->unloadData();
  m_controls->unloadData();

  m_inPaint = false;
  m_controls->m_paintButton->setDown(false);
  unsetCursor();
}

ProjectModel::INode* KeymapEditor::currentNode() const { return m_kmView->currentNode(); }

void KeymapEditor::keyPressEvent(QKeyEvent* event) {
  if (event->key() == Qt::Key_Escape) {
    if (m_inPaint) {
      m_inPaint = false;
      m_controls->m_paintButton->setDown(false);
      unsetCursor();
    }
  }
}

KeymapEditor::KeymapEditor(QWidget* parent)
: EditorWidget(parent), m_scrollArea(new QScrollArea), m_kmView(new KeymapView), m_controls(new KeymapControls) {

  int k = 0;
  for (int i = 0; i < 13; ++i)
    for (int j = 0; j < 10 && k < 129; ++j)
      m_paintPalette[k++].setHsv(HueTable[j], SaturationTable[i], ValueTable[i]);

  m_scrollArea->setWidget(m_kmView);
  m_scrollArea->setWidgetResizable(true);

  QVBoxLayout* layout = new QVBoxLayout;
  layout->setContentsMargins(QMargins());
  layout->setSpacing(1);
  layout->addWidget(m_scrollArea);
  layout->addWidget(m_controls);
  setLayout(layout);
}