#include "toonzqt/expressionfield.h"

#include "texpression.h"
#include "tparser.h"
#include "tconvert.h"
#include <QSyntaxHighlighter>
#include <QCompleter>
#include <QKeyEvent>
#include <QAbstractItemView>
#include <QScrollBar>
#include <QStringListModel>
#include <QStandardItemModel>
#include <QStandardItem>
#include <QToolTip>
#include <QListView>
#include <QLabel>

using namespace DVGui;
using namespace TSyntax;

//=============================================================================

class ExpressionField::SyntaxHighlighter : public QSyntaxHighlighter {
  const Grammar *m_grammar;

public:
  bool m_open;
  SyntaxHighlighter(QTextDocument *parent)
      : QSyntaxHighlighter(parent), m_grammar(0), m_open(true) {}
  ~SyntaxHighlighter() {}

  void setGrammar(const Grammar *grammar) { m_grammar = grammar; }

  void highlightBlock(const QString &text) {
    Parser parser(m_grammar);
    std::vector<SyntaxToken> tokens;
    Parser::SyntaxStatus status =
        parser.checkSyntax(tokens, text.toStdString());

    int nextPos = 0;
    for (int i = 0; i < (int)tokens.size(); i++) {
      QTextCharFormat fmt;
      int pos    = tokens[i].m_pos;
      int length = tokens[i].m_length;
      int type   = tokens[i].m_type;
      nextPos    = pos + length;
      switch (type) {
      case TSyntax::Unknown:
        fmt.setForeground(Qt::black);
        break;
      case TSyntax::Number:
        fmt.setForeground(QColor(0x50, 0x7d, 0x0));
        break;  // number
      case TSyntax::Constant:
        fmt.setForeground(QColor(0x50, 0x7d, 0x0));
        break;  // constant
      case TSyntax::Variable:
        fmt.setForeground(QColor(0x0, 0x88, 0xc8));
        break;  // var
      case TSyntax::Operator:
        fmt.setForeground(QColor(50, 0, 255));
        break;  // infix
      case TSyntax::Parenthesis:
        fmt.setForeground(QColor(50, 50, 255));
        break;  // braket
      case TSyntax::Function:
        fmt.setForeground(QColor(0x0, 0x50, 0x7d));
        break;  // fname
      case TSyntax::Comma:
        fmt.setForeground(QColor(50, 20, 255));
        break;  // f ;

      case TSyntax::UnexpectedToken:
        fmt.setForeground(QColor(0xdc, 0x0, 0x0));
        break;  // expression not found
      case TSyntax::Eos:
        fmt.setForeground(QColor(255, 127, 0));
        break;  //  EOS
      case TSyntax::Mismatch:
        fmt.setForeground(QColor(255, 0, 0));
        break;  // token mismatch

      default:
        fmt.setForeground(QColor(127, 127, 255));
        break;
      }
      if (type == 4) fmt.setToolTip("Infix");
      if (length == 0) length = 1;
      setFormat(pos, length, fmt);
    }
  }
};

//=============================================================================

class MyListView : public QListView {
  QLabel *m_tooltip;

public:
  MyListView() : QListView() {
    setObjectName("SuggestionPopup");
    setStyleSheet(
        "#SuggestionPopup {background-color:#FFFFFF; border:1px solid black;}");
    setWindowFlags(Qt::Popup);
    setMouseTracking(true);
    m_tooltip = new QLabel(0, Qt::ToolTip);
    // Stesso stile del popuop che lo contiene.
    m_tooltip->hide();

    m_tooltip->setObjectName("helpTooltip");
    m_tooltip->setAlignment(Qt::AlignLeft);
    m_tooltip->setIndent(1);
    m_tooltip->setWordWrap(false);
  }
  void showEvent(QShowEvent *) { showToolTip(currentIndex()); }
  void hideEvent(QHideEvent *) { m_tooltip->hide(); }
  void currentChanged(const QModelIndex &current, const QModelIndex &previous) {
    showToolTip(current);
    QListView::currentChanged(current, previous);
  }
  void showToolTip(const QModelIndex &index) {
    if (!index.isValid()) {
      m_tooltip->hide();
      return;
    }
    QVariant data = model()->data(index, Qt::ToolTipRole);
    if (!data.isValid()) {
      m_tooltip->hide();
      return;
    }
    QRect rect = visualRect(index);
    m_tooltip->setText(data.toString());
    QPoint pos = viewport()->mapToGlobal(
        QPoint(-m_tooltip->sizeHint().width(), rect.top()));
    m_tooltip->setGeometry(QRect(pos, m_tooltip->sizeHint()));
    m_tooltip->show();
  }

protected:
  void resizeEvent(QResizeEvent *e) {
    QListView::resizeEvent(e);
    if (m_tooltip->isVisible()) showToolTip(currentIndex());
  }
};

//=============================================================================

ExpressionField::ExpressionField(QWidget *parent)
    : QTextEdit(parent)
    , m_editing(false)
    , m_grammar(0)
    , m_syntaxHighlighter(0)
    , m_completerPopup(0)
    , m_completerStartPos(0) {
  setFrameStyle(QFrame::StyledPanel);
  setObjectName("ExpressionField");
  setLineWrapMode(NoWrap);
  setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
  setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
  setTabChangesFocus(true);
  // setSizePolicy(QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Fixed));
  connect(this, SIGNAL(textChanged()), this, SLOT(onTextChanged()));

#ifdef MACOSX
  setFixedHeight(23);
#else
  setFixedHeight(20);  // +40);
#endif

  m_completerPopup          = new MyListView();
  QStandardItemModel *model = new QStandardItemModel();
  m_completerPopup->setModel(model);
  m_completerPopup->setFocusPolicy(Qt::NoFocus);
  m_completerPopup->setFocusProxy(this);
  m_completerPopup->installEventFilter(this);
  connect(m_completerPopup, SIGNAL(clicked(const QModelIndex &)), this,
          SLOT(insertCompletion(const QModelIndex &)));

  m_syntaxHighlighter = new SyntaxHighlighter(document());
}

ExpressionField::~ExpressionField() { delete m_syntaxHighlighter; }

void ExpressionField::showEvent(QShowEvent *e) { QTextEdit::showEvent(e); }

void ExpressionField::hideEvent(QHideEvent *e) { QTextEdit::hideEvent(e); }

void ExpressionField::setExpression(std::string expression) {
  setPlainText(QString::fromStdString(expression));
}

std::string ExpressionField::getExpression() const {
  return toPlainText().toStdString();
}

bool ExpressionField::event(QEvent *e) {
  if (e->type() == QEvent::ToolTip) {
    QHelpEvent *helpEvent = static_cast<QHelpEvent *>(e);
    // openCompletionPopup();

  } else if (e->type() == QEvent::ShortcutOverride) {
    e->accept();
    return true;
  }
  // else
  return QTextEdit::event(e);
}

void ExpressionField::keyPressEvent(QKeyEvent *e) {
  // setStyleSheet("background-color: cyan");
  if (e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter) {
    m_editing = false;
    emit expressionChanged();
  } else if (e->key() == Qt::Key_F10) {
    setAutoFillBackground(true);
    QPalette p = palette();
    p.setColor(QPalette::Base, Qt::cyan);
    p.setColor(QPalette::Background, Qt::cyan);
    setPalette(p);
    update();
    setStyleSheet("#ExpressionField {background-color:cyan;}");
  } else if (e->key() == Qt::Key_F11) {
    m_completerPopup->installEventFilter(this);
    QRect cr = cursorRect();
    QSize size(100, 200);
    QPoint pos = mapToGlobal(QPoint(cr.left(), cr.top() - size.height()));
    m_completerPopup->setGeometry(QRect(pos, size));
    m_completerPopup->show();
    QTextEdit::keyPressEvent(e);
  } else {
    QTextEdit::keyPressEvent(e);
    if (m_completerPopup->isVisible()) {
      updateCompleterPopup();
    } else if (Qt::Key_A <= e->key() && e->key() <= Qt::Key_Z ||
               std::string("+&|!*/=?,:-").find(e->key()) != std::string::npos) {
      openCompleterPopup();
    }
    setFocus();
  }
}

bool ExpressionField::eventFilter(QObject *obj, QEvent *e) {
  if (e->type() == QEvent::KeyPress) {
    QKeyEvent *keyEvent = static_cast<QKeyEvent *>(e);
    switch (keyEvent->key()) {
    case Qt::Key_Return:
    case Qt::Key_Enter:
      insertCompletion(m_completerPopup->currentIndex());
      return true;

    case Qt::Key_Left:
    case Qt::Key_Right:
      event(keyEvent);
      m_completerPopup->hide();
      return true;

    case Qt::Key_Escape:
      m_completerPopup->hide();
      return true;

    case Qt::Key_Down:
    case Qt::Key_Up:
      return false;

    default:
      event(e);
      return true;
    }
  } else if (e->type() == QEvent::MouseButtonPress) {
    m_completerPopup->hide();
    event(e);
    return true;
  } else if (e->type() == QEvent::ShortcutOverride) {
    e->accept();
    return true;
  }
  return QObject::eventFilter(obj, e);
}

void ExpressionField::onTextChanged() {
  if (!m_editing) {
    m_editing = true;

    // setStyleSheet("background: rgb(250,200,200)");
  }
}

void ExpressionField::focusInEvent(QFocusEvent *e) {
  m_syntaxHighlighter->m_open = true;
  m_syntaxHighlighter->rehighlight();
  QTextEdit::focusInEvent(e);
}

void ExpressionField::focusOutEvent(QFocusEvent *e) {
  m_syntaxHighlighter->m_open = false;
  m_syntaxHighlighter->rehighlight();
  QTextEdit::focusOutEvent(e);
}

void ExpressionField::onCursorPositionChanged() {}

void ExpressionField::openCompleterPopup() {
  int n = computeSuggestions();
  if (n < 2) return;
  if (updateCompleterPopup()) m_completerPopup->show();
}

bool ExpressionField::updateCompleterPopup() {
  int start        = m_completerStartPos;
  int pos          = textCursor().position();
  std::string text = getExpression();
  if (m_suggestions.empty() || start < 0 || start > pos ||
      pos > (int)text.length()) {
    if (m_completerPopup->isVisible()) m_completerPopup->hide();
    return false;
  }

  QStandardItemModel *model = new QStandardItemModel();
  std::string prefix        = toLower(text.substr(start, pos - start));
  int prefixLength          = prefix.length();
  int count                 = 0;
  for (int i = 0; i < (int)m_suggestions.size(); i++) {
    std::string item = m_suggestions[i].first;
    if ((int)item.length() >= prefixLength &&
        toLower(item.substr(0, prefixLength)) == prefix) {
      QStandardItem *item = new QStandardItem();
      item->setData(QString::fromStdString(m_suggestions[i].first),
                    Qt::EditRole);
      if (m_suggestions[i].second != "")
        item->setData(QString::fromStdString(m_suggestions[i].second),
                      Qt::ToolTipRole);
      model->appendRow(item);
      count++;
    }
  }
  if (count == 0) {
    if (m_completerPopup->isVisible()) m_completerPopup->hide();
    return false;
  }
  m_completerPopup->setModel(model);
  m_completerPopup->setCurrentIndex(model->index(0, 0));

  QTextCursor cursor(textCursor());
  cursor.setPosition(m_completerStartPos);
  QRect cr = cursorRect(cursor);

  int w = m_completerPopup->sizeHintForColumn(0) +
          m_completerPopup->verticalScrollBar()->sizeHint().width() + 5;
  int h =
      (m_completerPopup->sizeHintForRow(0) * qMin(7, model->rowCount()) + 3) +
      3;

  QSize size(w, h);
  QPoint popupPos = mapToGlobal(QPoint(cr.left(), cr.bottom() + 3));
  m_completerPopup->setGeometry(QRect(popupPos, size));
  return true;
}

int ExpressionField::computeSuggestions() {
  m_completerStartPos = -1;
  m_suggestions.clear();

  std::string text = getExpression();
  int pos          = textCursor().position();
  int start        = pos;
  if (start > 0) {
    start--;
    while (start > 0) {
      char c = text[start - 1];
      if (isascii(c) && isalpha(c) || c == '_' ||
          c == '.' && (start - 2 < 0 ||
                       isascii(text[start - 2]) && isalpha(text[start - 2]))) {
      } else
        break;
      start--;
    }
  }
  if (start >= (int)text.length()) return 0;
  m_completerStartPos = start;
  text                = text.substr(0, start);
  TSyntax::Parser parser(m_grammar);
  parser.getSuggestions(m_suggestions, text);
  return (int)m_suggestions.size();
}

void ExpressionField::insertCompletion() {
  if (!m_completerPopup->isVisible()) return;
  QModelIndex index = m_completerPopup->currentIndex();
  if (!index.isValid()) return;
  QString item =
      m_completerPopup->model()->data(index, Qt::EditRole).toString();
  QTextCursor tc = textCursor();
  int pos        = tc.position();
  // tc.movePosition(m_completionStartPos, QTextCursor::KeepAnchor);
  tc.insertText(item);
  m_completerPopup->hide();
}

void ExpressionField::insertCompletion(const QModelIndex &index) {
  if (index.isValid()) {
    QString item =
        m_completerPopup->model()->data(index, Qt::EditRole).toString();

    QTextCursor tc = textCursor();
    int pos        = tc.position();
    if (pos - m_completerStartPos >= 1)
      tc.movePosition(QTextCursor::Left, QTextCursor::KeepAnchor,
                      pos - m_completerStartPos);
    tc.insertText(item);
  }
  m_completerPopup->hide();
}

void ExpressionField::setGrammar(const Grammar *grammar) {
  m_grammar = grammar;
  m_syntaxHighlighter->setGrammar(grammar);
};