#include "QtCodeField.h"

#include <QPainter>
#include <QTextBlock>

#include "data/location/SourceLocation.h"
#include "data/location/SourceLocationFile.h"
#include "qt/utility/QtHighlighter.h"
#include "settings/ApplicationSettings.h"
#include "settings/ColorScheme.h"
#include "utility/messaging/type/MessageActivateLocalSymbols.h"
#include "utility/messaging/type/MessageActivateSourceLocations.h"
#include "utility/messaging/type/MessageActivateTokenIds.h"
#include "utility/messaging/type/MessageTooltipShow.h"
#include "utility/utility.h"

std::vector<QtCodeField::AnnotationColor> QtCodeField::s_annotationColors;

void QtCodeField::clearAnnotationColors()
{
	s_annotationColors.clear();
}

QtCodeField::QtCodeField(
	uint startLineNumber,
	const std::string& code,
	std::shared_ptr<SourceLocationFile> locationFile,
	QWidget* parent
)
	: QPlainTextEdit(parent)
	, m_startLineNumber(startLineNumber)
	, m_code(code)
	, m_locationFile(locationFile)
	, m_endTextEditPosition(0)
{
	setObjectName("code_area");
	setReadOnly(true);
	setFrameStyle(QFrame::NoFrame);
	setLineWrapMode(QPlainTextEdit::NoWrap);
	setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);

	viewport()->setCursor(Qt::ArrowCursor);

	std::string displayCode = m_code;
	setPlainText(QString::fromUtf8(displayCode.c_str()));
	createLineLengthCache();

	this->setMouseTracking(true);

	createAnnotations(locationFile);

	FilePath path = m_locationFile->getFilePath();
	LanguageType language = LANGUAGE_UNKNOWN;
	if (!path.empty())
	{
		language = (path.extension() == ".java" ? LANGUAGE_JAVA : LANGUAGE_CPP);
	}

	m_highlighter = new QtHighlighter(document(), language);
	m_highlighter->highlightDocument();

	ApplicationSettings* appSettings = ApplicationSettings::getInstance().get();
	QFont font(appSettings->getFontName().c_str());
	font.setPixelSize(appSettings->getFontSize());
	setFont(font);
	setTabStopWidth(appSettings->getCodeTabWidth() * fontMetrics().width('9'));
}

QtCodeField::~QtCodeField()
{
}

QSize QtCodeField::sizeHint() const
{
	double height = 0;
	int width = 0;

	QFontMetrics fm = fontMetrics();
	int maxTextSize = 0;
	for (QTextBlock block = document()->firstBlock(); block.isValid(); block = block.next())
	{
		QRectF rect = blockBoundingGeometry(block);
		height += rect.height();

		{
			int blockWidth = fm.boundingRect(
				0, 0, 1000000, 1000000,
				Qt::AlignLeft | Qt::AlignTop | Qt::TextExpandTabs, block.text(), tabStopWidth()).width();

			width = std::max(blockWidth, width);
			maxTextSize = block.text().size();
		}
	}

	return QSize(width + 1, height + 5);
}

uint QtCodeField::getStartLineNumber() const
{
	return m_startLineNumber;
}

uint QtCodeField::getEndLineNumber() const
{
	return m_startLineNumber + blockCount() - 1;
}

std::string QtCodeField::getCode() const
{
	return m_code;
}

std::shared_ptr<SourceLocationFile> QtCodeField::getSourceLocationFile() const
{
	return m_locationFile;
}

void QtCodeField::annotateText()
{
	annotateText(std::set<Id>(), std::set<Id>(), std::set<Id>());
}

void QtCodeField::paintEvent(QPaintEvent* event)
{
	QPainter painter(viewport());

	QTextBlock block = firstVisibleBlock();
	int top = blockBoundingGeometry(block).translated(contentOffset()).top();
	int bottom = top + blockBoundingRect(block).height();
	int blockHeight = blockBoundingRect(block).height();

	int firstVisibleLine = -1;
	int lastVisibleLine = -1;
	while (block.isValid() && top <= event->rect().bottom())
	{
		if (block.isVisible())
		{
			if (firstVisibleLine < 0 && bottom >= event->rect().top())
			{
				firstVisibleLine = block.blockNumber();
			}
			lastVisibleLine = block.blockNumber();
		}

		block = block.next();
		top = bottom;
		bottom = top + static_cast<int>(blockBoundingRect(block).height());
	}

	m_highlighter->rehighlightLines(m_linesToRehighlight);
	m_linesToRehighlight.clear();

	// TODO: this causes another paint event if lines get rehighlighted
	m_highlighter->highlightRange(firstVisibleLine, lastVisibleLine);

	firstVisibleLine += m_startLineNumber;
	lastVisibleLine += m_startLineNumber;

	int borderRadius = 3;

	for (const Annotation& annotation : m_annotations)
	{
		if (annotation.startLine > lastVisibleLine || annotation.endLine < firstVisibleLine)
		{
			continue;
		}

		const AnnotationColor& color = getAnnotationColorForAnnotation(annotation);

		if (color.text != "transparent" &&
			QColor(color.text.c_str()) != m_highlighter->getFormat(annotation.start, annotation.end).foreground().color())
		{
			// TODO: this causes another paint event if text color changes
			setTextColorForAnnotation(annotation, QColor(color.text.c_str()));
		}

		if (color.border == "transparent" && color.fill == "transparent")
		{
			continue;
		}

		painter.setPen(QPen(color.border.c_str()));
		painter.setBrush(QBrush(color.fill.c_str()));

		if (annotation.locationType == LOCATION_SCOPE)
		{
			painter.drawRoundedRect(
				0, top + (annotation.startLine - m_startLineNumber) * blockHeight,
				width(), (annotation.endLine - annotation.startLine + 1) * blockHeight,
				borderRadius, borderRadius
			);
		}
		else
		{
			std::vector<QRect> rects = getCursorRectsForAnnotation(annotation);
			for (QRect rect : rects)
			{
				rect.adjust(-1, 0, 1, 1);
				painter.drawRoundedRect(rect, borderRadius, borderRadius);
			}
		}
	}

	QPlainTextEdit::paintEvent(event);
}

void QtCodeField::enterEvent(QEvent* event)
{
}

void QtCodeField::leaveEvent(QEvent* event)
{
	setHoveredAnnotations(std::vector<const Annotation*>());
}

void QtCodeField::mouseMoveEvent(QMouseEvent* event)
{
	QTextCursor cursor = this->cursorForPosition(event->pos());
	std::vector<const Annotation*> annotations = getInteractiveAnnotationsForPosition(cursor.position());

	bool same = annotations.size() == m_hoveredAnnotations.size();
	if (same)
	{
		for (size_t i = 0; i < annotations.size(); i++)
		{
			if (annotations[i] != m_hoveredAnnotations[i])
			{
				same = false;
				break;
			}
		}
	}

	if (!same)
	{
		setHoveredAnnotations(annotations);
	}
}

void QtCodeField::mouseReleaseEvent(QMouseEvent* event)
{
	if (event->button() != Qt::LeftButton)
	{
		return;
	}

	viewport()->setCursor(Qt::ArrowCursor);

	QTextCursor cursor = this->cursorForPosition(event->pos());
	std::vector<const Annotation*> annotations = getInteractiveAnnotationsForPosition(cursor.position());

	if (!annotations.size())
	{
		return;
	}

	activateAnnotations(annotations);
}

void QtCodeField::focusTokenIds(const std::vector<Id>& tokenIds)
{
	annotateText(std::set<Id>(), std::set<Id>(), std::set<Id>(tokenIds.begin(), tokenIds.end()));
}

void QtCodeField::defocusTokenIds(const std::vector<Id>& tokenIds)
{
	annotateText(std::set<Id>(), std::set<Id>(), std::set<Id>());
}

bool QtCodeField::annotateText(
	const std::set<Id>& activeSymbolIds, const std::set<Id>& activeLocationIds, const std::set<Id>& focusedSymbolIds)
{
	for (size_t i = 0; i < m_annotations.size(); i++)
	{
		Annotation& annotation = m_annotations[i];
		bool wasActive = annotation.isActive;
		bool wasFocused = annotation.isFocused;

		annotation.isActive = (
			utility::shareElement(activeSymbolIds, annotation.tokenIds) ||
			activeLocationIds.find(annotation.locationId) != activeLocationIds.end()
		);

		annotation.isFocused = utility::shareElement(focusedSymbolIds, annotation.tokenIds);

		if (annotation.locationType == LOCATION_QUALIFIER)
		{
			annotation.isActive = false;
		}

		if (wasFocused != annotation.isFocused || wasActive != annotation.isActive)
		{
			m_linesToRehighlight.push_back(annotation.startLine - m_startLineNumber);
		}
	}

	if (m_linesToRehighlight.size())
	{
		viewport()->update();
		return true;
	}

	return false;
}

void QtCodeField::createAnnotations(std::shared_ptr<SourceLocationFile> locationFile)
{
	uint endLineNumber = getEndLineNumber();
	std::set<Id> locationIds;

	locationFile->forEachSourceLocation(
		[&](const SourceLocation* location)
		{
			if (location->getLocationId() && locationIds.find(location->getLocationId()) != locationIds.end())
			{
				return;
			}
			locationIds.insert(location->getLocationId());

			Annotation annotation;

			const SourceLocation* startLocation = location->getStartLocation();
			if (!startLocation || startLocation->getLineNumber() < m_startLineNumber)
			{
				annotation.start = startTextEditPosition();
				annotation.startLine = m_startLineNumber;
				annotation.startCol = 0;
			}
			else if (startLocation->getLineNumber() <= endLineNumber)
			{
				annotation.start = toTextEditPosition(startLocation->getLineNumber(), startLocation->getColumnNumber() - 1);
				annotation.startLine = startLocation->getLineNumber();
				annotation.startCol = startLocation->getColumnNumber() - 1;
			}
			else
			{
				return;
			}

			const SourceLocation* endLocation = location->getEndLocation();
			if (!endLocation || endLocation->getLineNumber() > endLineNumber)
			{
				annotation.end = endTextEditPosition();
				annotation.endLine = endLineNumber;
				annotation.endCol = m_lineLengths[document()->blockCount() - 1];
			}
			else if (endLocation->getLineNumber() >= m_startLineNumber)
			{
				annotation.end = toTextEditPosition(endLocation->getLineNumber(), endLocation->getColumnNumber());
				annotation.endLine = endLocation->getLineNumber();
				annotation.endCol = endLocation->getColumnNumber();
			}
			else
			{
				return;
			}

			annotation.tokenIds.insert(location->getTokenIds().begin(), location->getTokenIds().end());
			annotation.locationId = location->getLocationId();
			annotation.locationType = location->getType();

			annotation.isActive = false;
			annotation.isFocused = false;

			m_annotations.push_back(annotation);
		}
	);
}

void QtCodeField::activateAnnotations(const std::vector<const Annotation*>& annotations)
{
	std::vector<Id> locationIds;
	std::set<Id> tokenIds;
	std::set<Id> localSymbolIds;

	bool allActive = true;
	for (const Annotation* annotation : annotations)
	{
		if (annotation->locationType == LOCATION_TOKEN || annotation->locationType == LOCATION_QUALIFIER)
		{
			if (!annotation->isActive)
			{
				allActive = false;
			}

			if (annotation->locationId > 0)
			{
				locationIds.push_back(annotation->locationId);
			}

			if (annotation->tokenIds.size())
			{
				tokenIds.insert(annotation->tokenIds.begin(), annotation->tokenIds.end());
			}
		}
		else if (annotation->locationType == LOCATION_LOCAL_SYMBOL)
		{
			if (!annotation->isActive)
			{
				allActive = false;
			}

			if (annotation->tokenIds.size())
			{
				localSymbolIds.insert(annotation->tokenIds.begin(), annotation->tokenIds.end());
			}
		}
	}

	if (!allActive)
	{
		if (tokenIds.size() > 1 || localSymbolIds.size() > 1 || (tokenIds.size() && localSymbolIds.size()))
		{
			MessageTooltipShow(locationIds, utility::toVector(localSymbolIds), TOOLTIP_ORIGIN_CODE).dispatch();
		}
		else if (locationIds.size())
		{
			MessageActivateSourceLocations(locationIds).dispatch();
		}
		else if (tokenIds.size()) // fallback for links in project description
		{
			MessageActivateTokenIds(utility::toVector(tokenIds)).dispatch();
		}
		else if (localSymbolIds.size())
		{
			MessageActivateLocalSymbols(utility::toVector(localSymbolIds)).dispatch();
		}
	}
}

int QtCodeField::toTextEditPosition(int lineNumber, int columnNumber) const
{
	lineNumber -= m_startLineNumber - 1;
	int position = 0;

	for (int i = 0; i < lineNumber - 1; i++)
	{
		position += m_lineLengths[i];
	}

	position += columnNumber;
	return position;
}

std::pair<int, int> QtCodeField::toLineColumn(int textEditPosition) const
{
	int lineNumber = m_startLineNumber;
	for (int i = 0; i < document()->lineCount(); i++)
	{
		int nextTextEditPosition = textEditPosition - m_lineLengths[i];
		if (nextTextEditPosition >= 0)
		{
			textEditPosition = nextTextEditPosition;
			lineNumber++;
		}
		else
		{
			break;
		}
	}
	return std::make_pair(lineNumber, textEditPosition);
}

int QtCodeField::startTextEditPosition() const
{
	return 0;
}

int QtCodeField::endTextEditPosition() const
{
	return m_endTextEditPosition;
}

void QtCodeField::setHoveredAnnotations(const std::vector<const Annotation*>& annotations)
{
	if (m_hoveredAnnotations.size())
	{
		std::vector<Id> tokenIds;
		for (const Annotation* annotation : m_hoveredAnnotations)
		{
			tokenIds.insert(tokenIds.end(), annotation->tokenIds.begin(), annotation->tokenIds.end());
		}

		defocusTokenIds(tokenIds);
	}

	m_hoveredAnnotations = annotations;

	if (annotations.size())
	{
		std::vector<Id> tokenIds;
		for (const Annotation* annotation : annotations)
		{
			tokenIds.insert(tokenIds.end(), annotation->tokenIds.begin(), annotation->tokenIds.end());
		}

		focusTokenIds(tokenIds);
	}
}

std::vector<QRect> QtCodeField::getCursorRectsForAnnotation(const Annotation& annotation) const
{
	std::vector<QRect> rects;

	QTextCursor cursor = QTextCursor(document());
	cursor.setPosition(annotation.start);
	QRect rectStart = cursorRect(cursor);
	QRect rectEnd;

	int line = annotation.startLine;
	while (line <= annotation.endLine)
	{
		if (line == annotation.endLine)
		{
			// Avoid that annotations at line end span down to first column of the next line.
			if (annotation.startLine != annotation.endLine ||
				m_lineLengths[line - m_startLineNumber] != annotation.endCol)
			{
				cursor.setPosition(annotation.end);
			}
		}
		else
		{
			cursor.setPosition(toTextEditPosition(line, m_lineLengths[line - m_startLineNumber] - 1));
		}

		rectEnd = cursorRect(cursor);
		rects.push_back(QRect(
			rectStart.left(),
			rectStart.top(),
			rectEnd.right() - rectStart.left(),
			rectEnd.bottom() - rectStart.top()
		));

		line++;

		if (int(line - m_startLineNumber) < document()->blockCount())
		{
			cursor.setPosition(toTextEditPosition(line, 0));
			rectStart = cursorRect(cursor);
		}
	}

	return rects;
}

const QtCodeField::AnnotationColor& QtCodeField::getAnnotationColorForAnnotation(const Annotation& annotation)
{
	if (!s_annotationColors.size())
	{
		ColorScheme* scheme = ColorScheme::getInstance().get();
		std::vector<std::string> types = { "token", "local_symbol", "scope", "error", "fulltext_search", "screen_search" };
		std::vector<ColorScheme::ColorState> states = { ColorScheme::NORMAL, ColorScheme::FOCUS, ColorScheme::ACTIVE };

		for (const std::string& type : types)
		{
			for (const ColorScheme::ColorState& state : states)
			{
				AnnotationColor color;
				color.border = scheme->getCodeAnnotationTypeColor(type, "border", state);
				color.fill = scheme->getCodeAnnotationTypeColor(type, "fill", state);
				color.text = scheme->getCodeAnnotationTypeColor(type, "text", state);
				s_annotationColors.push_back(color);
			}
		}
	}

	size_t i = 0;

	if (annotation.locationType == LOCATION_LOCAL_SYMBOL)
	{
		i = 3;
	}
	else if (annotation.locationType == LOCATION_SCOPE)
	{
		i = 6;
	}
	else if (annotation.locationType == LOCATION_ERROR)
	{
		i = 9;
	}
	else if (annotation.locationType == LOCATION_FULLTEXT_SEARCH)
	{
		i = 12;
	}
	else if (annotation.locationType == LOCATION_SCREEN_SEARCH)
	{
		i = 15;
	}

	if (annotation.isActive)
	{
		i += 2;
	}
	else if (annotation.isFocused)
	{
		i += 1;
	}

	return s_annotationColors[i];
}

void QtCodeField::setTextColorForAnnotation(const Annotation& annotation, QColor color) const
{
	QTextCharFormat format;
	format.setForeground(color);
	m_highlighter->applyFormat(annotation.start, annotation.end, format);
}

std::vector<const QtCodeField::Annotation*> QtCodeField::getInteractiveAnnotationsForPosition(int pos) const
{
	std::vector<const QtCodeField::Annotation*> annotations;

	for (const Annotation& annotation : m_annotations)
	{
		const LocationType& type = annotation.locationType;
		if ((type == LOCATION_TOKEN || type == LOCATION_QUALIFIER || type == LOCATION_LOCAL_SYMBOL || type == LOCATION_ERROR)
			&& pos >= annotation.start && pos <= annotation.end)
		{
			annotations.push_back(&annotation);
		}
	}

	return annotations;
}

void QtCodeField::createLineLengthCache()
{
	m_endTextEditPosition = -1;

	m_lineLengths.clear();

	for (QTextBlock it = document()->begin(); it != document()->end(); it = it.next())
	{
		m_lineLengths.push_back(it.length());
		m_endTextEditPosition += it.length();
	}
}