#include "fileinfo.h"
#include "entropy.h"
#include "fontsettings.h"
#include "theme.h"
#include "copyablelabel.h"
#include <QClipboard>
#include <QApplication>
#include <QGuiApplication>
#include <QScreen>
#include <QToolTip>
#include <QPainter>
#include <QFontMetrics>
#include <QScrollArea>
#include <QtConcurrent/QtConcurrent>
#include <QFuture>
#include <QFutureWatcher>

void FileInfoWidget::addCopyableField(const QString& name, const QVariant& value)
{
	auto& [row, column] = this->m_fieldPosition;

	const auto valueLabel = new CopyableLabel(value.toString(), getThemeColor(AlphanumericHighlightColor));
	valueLabel->setFont(getMonospaceFont(this));

	this->m_layout->addWidget(new QLabel(name), row, column);
	this->m_layout->addWidget(valueLabel, row++, column + 1);
}

void FileInfoWidget::addCopyableFieldWithElide(const QString& name, const QVariant& value, int maxWidth)
{
	auto& [row, column] = this->m_fieldPosition;

	const auto fullText = value.toString();
	const auto font = getMonospaceFont(this);
	const QFontMetrics fontMetrics(font);
	const auto elidedText = fontMetrics.elidedText(fullText, Qt::ElideMiddle, maxWidth);

	const auto valueLabel = new CopyableLabel(elidedText, getThemeColor(AlphanumericHighlightColor));
	valueLabel->setFont(font);
	valueLabel->setCopyText(fullText);
	valueLabel->setToolTip(fullText + "\n\nClick to Copy");
	valueLabel->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
	valueLabel->setWordWrap(false);

	this->m_layout->addWidget(new QLabel(name), row, column);
	this->m_layout->addWidget(valueLabel, row++, column + 1);
}

void FileInfoWidget::addField(const QString& name, const QVariant& value)
{
	auto& [row, column] = this->m_fieldPosition;

	const auto valueLabel = new QLabel(value.toString());
	valueLabel->setFont(getMonospaceFont(this));

	this->m_layout->addWidget(new QLabel(name), row, column);
	this->m_layout->addWidget(valueLabel, row++, column + 1);
}

void FileInfoWidget::addHashFields(BinaryViewRef view)
{
	auto& [row, column] = this->m_fieldPosition;

	const auto hashFieldColor = getThemeColor(AlphanumericHighlightColor);
	auto md5Label = new CopyableLabel("Calculating...", hashFieldColor);
	auto sha1Label = new CopyableLabel("Calculating...", hashFieldColor);
	auto sha256Label = new CopyableLabel("Calculating...", hashFieldColor);
	md5Label->setFont(getMonospaceFont(this));
	sha1Label->setFont(getMonospaceFont(this));
	sha256Label->setFont(getMonospaceFont(this));

	this->m_layout->addWidget(new QLabel("MD5: "), row, column);
	this->m_layout->addWidget(md5Label, row++, column + 1);
	this->m_layout->addWidget(new QLabel("SHA-1: "), row, column);
	this->m_layout->addWidget(sha1Label, row++, column + 1);
	this->m_layout->addWidget(new QLabel("SHA-256: "), row, column);
	this->m_layout->addWidget(sha256Label, row++, column + 1);

	// Process the hash calculations in a separate thread and update the labels when done
	QPointer<QFutureWatcher<QStringList>> watcher = new QFutureWatcher<QStringList>(this);
	connect(watcher, &QFutureWatcher<QStringList>::finished, this, [watcher, md5Label, sha1Label, sha256Label]() {
		if (watcher)
		{
			if (const auto results = watcher->result(); results.size() == 3)
			{
				md5Label->setText(results[0]);
				sha1Label->setText(results[1]);
				sha256Label->setText(results[2]);
			}
			watcher->deleteLater();
		}
	});

	uint64_t totalSize = view->GetLength();
	QFuture<QStringList> future = QtConcurrent::run([view, totalSize, watcher]() {
		QCryptographicHash md5(QCryptographicHash::Md5);
		QCryptographicHash sha1(QCryptographicHash::Sha1);
		QCryptographicHash sha256(QCryptographicHash::Sha256);

		uint64_t offset = 0;
		const uint64_t maxChunkSize = 128 * 1024 * 1024;
		auto chunkBuffer = std::make_unique<char[]>(maxChunkSize);
		while (offset < totalSize)
		{
			if (watcher->isCanceled())
				return QStringList();

			const auto remainingBytes = totalSize - offset;
			const auto currentChunkSize = std::min(maxChunkSize, remainingBytes);
			const auto bytesRead = view->Read(chunkBuffer.get(), offset, currentChunkSize);
			if (bytesRead != currentChunkSize)
				return QStringList{"Error", "Error", "Error"};

			const auto chunkView = QByteArrayView(chunkBuffer.get(), currentChunkSize);
			md5.addData(chunkView);
			sha1.addData(chunkView);
			sha256.addData(chunkView);
			offset += currentChunkSize;
		}

		return QStringList {md5.result().toHex(), sha1.result().toHex(), sha256.result().toHex()};
	});

	watcher->setFuture(future);
	connect(this, &QObject::destroyed, this, [watcher]() {
		if (watcher && watcher->isRunning()) {
			watcher->cancel();
			watcher->waitForFinished();
		}
	});
}

FileInfoWidget::FileInfoWidget(QWidget* parent, BinaryViewRef bv, EntropyWidget* entropyWidget)
{
	this->m_layout = new QGridLayout();
	this->m_layout->setContentsMargins(0, 0, 0, 0);
	this->m_layout->setVerticalSpacing(1);

	const auto view = bv->GetParentView() ? bv->GetParentView() : bv;

	const auto file = bv->GetFile();
	const auto filePath = file->GetOriginalFilename();

	// Calculate max path width as 50% of screen width
	// Using screen width since the scroll area viewport isn't sized yet during construction
	const int screenWidth = QGuiApplication::primaryScreen()->availableGeometry().width();
	const int maxPathWidth = screenWidth / 2;

	this->addCopyableFieldWithElide("Path on disk: ", filePath.c_str(), maxPathWidth);

	// If triage view is opened from a project, show both actual filepath and path relative to project
	if (const auto fileProjectRef = file->GetProjectFile())
	{
		const auto projectFilePath = file->GetProjectFile()->GetPathInProject();
		this->addCopyableFieldWithElide("Path in project: ", projectFilePath.c_str(), maxPathWidth);
	}

	const auto fileSize = QString::number(view->GetLength(), 16).prepend("0x");
	this->addCopyableField("Size: ", fileSize);

	// Display entropy value from the entropy widget
	if (entropyWidget)
	{
		auto& [row, column] = this->m_fieldPosition;
		m_entropyLabel = new CopyableLabel("Calculating...", getThemeColor(AlphanumericHighlightColor));
		m_entropyLabel->setFont(getMonospaceFont(this));
		this->m_layout->addWidget(new QLabel("Entropy: "), row, column);
		this->m_layout->addWidget(m_entropyLabel, row++, column + 1);

		// Connect to entropy updates
		connect(entropyWidget, &EntropyWidget::entropyUpdated, this, &FileInfoWidget::updateEntropy);
	}

	this->addHashFields(view);

	const auto scaledWidth = UIContext::getScaledWindowSize(20, 20).width();
	this->m_layout->setColumnMinimumWidth(FileInfoWidget::m_maxColumns * 3 - 1, scaledWidth);
	this->m_layout->setColumnStretch(FileInfoWidget::m_maxColumns * 3 - 1, 1);
	setLayout(this->m_layout);
}


void FileInfoWidget::updateEntropy(double avgEntropy)
{
	if (m_entropyLabel)
	{
		const auto entropyStr = QString::number(avgEntropy, 'f', 6);
		m_entropyLabel->setText(entropyStr);
	}
}