#include "toonzqt/expressionfield.h"

#include "texpression.h"

#include "tparser.h"

#include "tconvert.h"

#include <qsyntaxhighlighter></qsyntaxhighlighter>

#include <qcompleter></qcompleter>

#include <qkeyevent></qkeyevent>

#include <qabstractitemview></qabstractitemview>

#include <qscrollbar></qscrollbar>

#include <qstringlistmodel></qstringlistmodel>

#include <qstandarditemmodel></qstandarditemmodel>

#include <qstandarditem></qstandarditem>

#include <qtooltip></qtooltip>

#include <qlistview></qlistview>

#include <qlabel></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;</syntaxtoken>

		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 ¤t, 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);</qhelpevent>

		// 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);</qkeyevent>

		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);

};