#include <cstring>
#include <time.h>
#include <map>
#include "headers.h"
#include "fontsettings.h"
#include "theme.h"
#include "viewframe.h"


NavigationLabel::NavigationLabel(const QString& text, QColor color, const std::function<void()>& func) :
    QLabel(text), m_func(func)
{
	QPalette style(palette());
	style.setColor(QPalette::WindowText, color);
	setPalette(style);
	setFont(getMonospaceFont(this));
	setCursor(Qt::PointingHandCursor);
}


void NavigationLabel::mousePressEvent(QMouseEvent*)
{
	m_func();
}


NavigationAddressLabel::NavigationAddressLabel(const QString& text) :
    NavigationLabel(text, getThemeColor(AddressColor), [this]() { clickEvent(); })
{
}


void NavigationAddressLabel::clickEvent()
{
	auto address = text().toULongLong(nullptr, 0);
	ViewFrame* viewFrame = ViewFrame::viewFrameForWidget(this);
	if (viewFrame)
	{
		if (BinaryNinja::Settings::Instance()->Get<bool>("ui.view.graph.preferred") &&
			viewFrame->getCurrentBinaryView() &&
			viewFrame->getCurrentBinaryView()->GetAnalysisFunctionsForAddress(address).size() > 0)
		{
			viewFrame->navigate("Graph:" + viewFrame->getCurrentDataType(), address);
		}
		else
		{
			viewFrame->navigate("Linear:" + viewFrame->getCurrentDataType(), address);
		}
	}
}


NavigationCodeLabel::NavigationCodeLabel(const QString& text) :
    NavigationLabel(text, getThemeColor(CodeSymbolColor), [this]() { clickEvent(); })
{
}


void NavigationCodeLabel::clickEvent()
{
	auto address = text().toULongLong(nullptr, 0);
	ViewFrame* viewFrame = ViewFrame::viewFrameForWidget(this);
	if (viewFrame)
	{
		if (BinaryNinja::Settings::Instance()->Get<bool>("ui.view.graph.preferred") &&
			viewFrame->getCurrentBinaryView() &&
			viewFrame->getCurrentBinaryView()->GetAnalysisFunctionsForAddress(address).size() > 0)
		{
			viewFrame->navigate("Graph:" + viewFrame->getCurrentDataType(), address);
		}
		else
		{
			viewFrame->navigate("Linear:" + viewFrame->getCurrentDataType(), address);
		}
	}
}


Headers::Headers() : m_columns(1), m_rowsPerColumn(8) {}


void Headers::AddField(const QString& title, const QString& value, HeaderFieldType type)
{
	m_fields.push_back(HeaderField {title, {value}, type});
}


void Headers::AddField(const QString& title, const std::vector<QString>& values, HeaderFieldType type)
{
	m_fields.push_back(HeaderField {title, values, type});
}


GenericHeaders::GenericHeaders(BinaryViewRef data)
{
	AddField("Type", QString::fromStdString(data->GetTypeName()));
	if (data->GetDefaultPlatform())
		AddField("Platform", QString::fromStdString(data->GetDefaultPlatform()->GetName()));
	auto entryFunctions = data->GetAllEntryFunctions();
	if (!entryFunctions.empty() && data->GetEntryPoint() != 0)
		AddField("Entry Point", QString("0x") + QString::number(data->GetEntryPoint(), 16), AddressHeaderField);
	else
		AddField("Entry Point", "None");
	if (data->IsValidOffset(data->GetStart()))
		AddField("Current Base", QString("0x") + QString::number(data->GetStart(), 16), AddressHeaderField);
	AddField("Endianness", data->GetDefaultEndianness() == BigEndian ? "Big" : "Little");
}


PEHeaders::PEHeaders(BinaryViewRef data)
{
	uint64_t peOffset = data->GetStart() + GetValueOfStructMember(data, "DOS_Header", data->GetStart(), "e_lfanew");
	uint64_t optHeaderStart = GetAddressAfterStruct(data, "COFF_Header", peOffset);

	BinaryNinja::DataBuffer peMagic = data->ReadBuffer(optHeaderStart, 2);
	bool is64bit;
	std::string optHeaderName;
	if ((peMagic.GetLength() == 2) && (peMagic[0] == 0x0b) && (peMagic[1] == 0x01))
	{
		optHeaderName = "PE32_Optional_Header";
		AddField("Type", "PE 32-bit");
		is64bit = false;
	}
	else if ((peMagic.GetLength() == 2) && (peMagic[0] == 0x0b) && (peMagic[1] == 0x02))
	{
		optHeaderName = "PE64_Optional_Header";
		AddField("Type", "PE 64-bit");
		is64bit = true;
	}
	else
	{
		AddField("Type", QString::fromStdString(data->GetTypeName()));
		if (data->GetDefaultPlatform())
			AddField("Platform", QString::fromStdString(data->GetDefaultPlatform()->GetName()));
		auto entryFunctions = data->GetAllEntryFunctions();
		if (!entryFunctions.empty() && data->GetEntryPoint() != 0)
			AddField("Entry Point", QString("0x") + QString::number(data->GetEntryPoint(), 16), AddressHeaderField);
		else
			AddField("Entry Point", "None");
		return;
	}

	uint64_t machineValue = GetValueOfStructMember(data, "COFF_Header", peOffset, "machine");
	QString machineName = GetNameOfEnumerationMember(data, "coff_machine", machineValue);
	if (machineName.startsWith("IMAGE_FILE_MACHINE_"))
		machineName = machineName.mid((int)strlen("IMAGE_FILE_MACHINE_"));
	AddField("Machine", machineName);

	AddField("Endianness", data->GetDefaultEndianness() == BigEndian ? "Big" : "Little");

	uint64_t subsysValue = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "subsystem");
	QString subsysName = GetNameOfEnumerationMember(data, "pe_subsystem", subsysValue);
	if (subsysName.startsWith("IMAGE_SUBSYSTEM_"))
		subsysName = subsysName.mid((int)strlen("IMAGE_SUBSYSTEM_"));
	AddField("Subsystem", subsysName);

	uint64_t secs = GetValueOfStructMember(data, "COFF_Header", peOffset, "timeDateStamp");
	QDateTime t = QDateTime::fromSecsSinceEpoch(secs);
	AddField("Timestamp", t.toString());
	AddField("Timestamp (Hex)", QString::number(secs, 16).prepend("0x"));

	uint64_t currentBase = data->GetStart();
	AddField("Current Base", QString("0x") + QString::number(currentBase, 16), AddressHeaderField);

	uint64_t base = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "imageBase");
	AddField("Image Base", QString("0x") + QString::number(base, 16), AddressHeaderField);

	uint64_t entryPoint = currentBase + GetValueOfStructMember(data, optHeaderName, optHeaderStart, "addressOfEntryPoint");
	auto entryFunctions = data->GetAllEntryFunctions();
	if (!entryFunctions.empty() && entryPoint != 0)
		AddField("Entry Point", QString("0x") + QString::number(entryPoint, 16), AddressHeaderField);
	else
		AddField("Entry Point", "None");

	uint64_t sectionAlign = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "sectionAlignment");
	AddField("Section Alignment", QString("0x") + QString::number(sectionAlign, 16));

	uint64_t fileAlign = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "fileAlignment");
	AddField("File Alignment", QString("0x") + QString::number(fileAlign, 16));

	uint64_t checksum = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "checkSum");
	AddField("Checksum", QString("0x") + QString::number(checksum, 16));

	uint64_t codeBase = currentBase + GetValueOfStructMember(data, optHeaderName, optHeaderStart, "baseOfCode");
	AddField("Base of Code", QString("0x") + QString::number(codeBase, 16), AddressHeaderField);

	if (!is64bit)
	{
		uint64_t dataBase = currentBase + GetValueOfStructMember(data, optHeaderName, optHeaderStart, "baseOfData");
		AddField("Base of Data", QString("0x") + QString::number(dataBase, 16), AddressHeaderField);
	}

	uint64_t codeSize = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "sizeOfCode");
	AddField("Size of Code", QString("0x") + QString::number(codeSize, 16));

	uint64_t initDataSize = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "sizeOfInitializedData");
	AddField("Size of Init Data", QString("0x") + QString::number(initDataSize, 16));

	uint64_t uninitDataSize = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "sizeOfUninitializedData");
	AddField("Size of Uninit Data", QString("0x") + QString::number(uninitDataSize, 16));

	uint64_t headerSize = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "sizeOfHeaders");
	AddField("Size of Headers", QString("0x") + QString::number(headerSize, 16));

	uint64_t imageSize = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "sizeOfImage");
	AddField("Size of Image", QString("0x") + QString::number(imageSize, 16));

	uint64_t stackCommit = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "sizeOfStackCommit");
	uint64_t stackReserve = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "sizeOfStackReserve");
	AddField("Stack Size",
	    QString("0x") + QString::number(stackCommit, 16) + QString(" / 0x") + QString::number(stackReserve, 16));

	uint64_t heapCommit = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "sizeOfHeapCommit");
	uint64_t heapReserve = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "sizeOfHeapReserve");
	AddField("Heap Size",
	    QString("0x") + QString::number(heapCommit, 16) + QString(" / 0x") + QString::number(heapReserve, 16));

	uint64_t linkerMajor = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "majorLinkerVersion");
	uint64_t linkerMinor = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "minorLinkerVersion");
	AddField("Linker Version",
	    QString::number(linkerMajor) + QString(".") + QString::number(linkerMinor).rightJustified(2, '0'));

	uint64_t imageMajor = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "majorImageVersion");
	uint64_t imageMinor = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "minorImageVersion");
	AddField("Image Version",
	    QString::number(imageMajor) + QString(".") + QString::number(imageMinor).rightJustified(2, '0'));

	uint64_t osMajor = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "majorOperatingSystemVersion");
	uint64_t osMinor = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "minorOperatingSystemVersion");
	AddField("OS Version", QString::number(osMajor) + QString(".") + QString::number(osMinor).rightJustified(2, '0'));

	uint64_t subMajor = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "majorSubsystemVersion");
	uint64_t subMinor = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "minorSubsystemVersion");
	AddField("Subsystem Version",
	    QString::number(subMajor) + QString(".") + QString::number(subMinor).rightJustified(2, '0'));

	uint64_t coffCharValue = GetValueOfStructMember(data, "COFF_Header", peOffset, "characteristics");
	TypeRef coffCharEnum = data->GetTypeByName(BinaryNinja::QualifiedName("coff_characteristics"));
	if (coffCharEnum && (coffCharEnum->GetClass() == EnumerationTypeClass))
	{
		std::vector<QString> coffCharValues;
		for (auto& member : coffCharEnum->GetEnumeration()->GetMembers())
		{
			if (coffCharValue & member.value)
			{
				if (QString::fromStdString(member.name).startsWith("IMAGE_FILE_"))
					coffCharValues.push_back(QString::fromStdString(member.name).mid((int)strlen("IMAGE_FILE_")));
				else
					coffCharValues.push_back(QString::fromStdString(member.name));
			}
		}
		if (coffCharValues.size() > 0)
			AddField("COFF Characteristics", coffCharValues);
	}

	uint64_t dllCharValue = GetValueOfStructMember(data, optHeaderName, optHeaderStart, "dllCharacteristics");
	TypeRef dllCharEnum = data->GetTypeByName(BinaryNinja::QualifiedName("pe_dll_characteristics"));
	if (dllCharEnum && (dllCharEnum->GetClass() == EnumerationTypeClass))
	{
		std::vector<QString> dllCharValues;
		for (auto& member : dllCharEnum->GetEnumeration()->GetMembers())
		{
			if (dllCharValue & member.value)
			{
				if (QString::fromStdString(member.name).startsWith("IMAGE_DLLCHARACTERISTICS_"))
					dllCharValues.push_back(
					    QString::fromStdString(member.name).mid((int)strlen("IMAGE_DLLCHARACTERISTICS_")));
				else
					dllCharValues.push_back(QString::fromStdString(member.name));
			}
		}
		if (dllCharValues.size() > 0)
			AddField("DLL Characteristics", dllCharValues);
	}


	auto richHeaderIdentifiers = data->QueryMetadata("RichHeaderLookupIdentifiers");
	auto richHeaderNames = data->QueryMetadata("RichHeaderLookupNames");
	auto richHeader = data->QueryMetadata("RichHeader");
	if (richHeaderIdentifiers && richHeaderIdentifiers && richHeader) // Should only be present on PE files
	{
		std::vector<QString> compilersUsed;

		// Get a set of unique identifiers
		std::map<uint64_t, uint64_t> identifiers;
		for (auto& entry : richHeader->GetArray())
		{
			auto kv = entry->GetKeyValueStore();
			identifiers[kv["ObjectVersionValue"]->GetUnsignedInteger()] += kv["ObjectCount"]->GetUnsignedInteger();
		}
		auto lookupVersionStrings = [&](uint64_t id) -> std::string {
			auto ids = richHeaderIdentifiers->GetUnsignedIntegerList();
			auto names = richHeaderNames->GetStringList();
			for (size_t i = 0; i < ids.size(); i++)
			{
				if (ids[i] == id)
					return names[i];
				if (ids[i] > id && i > 0)
					return names[i - 1] + " and " + names[i];
			}
			return "Unknown";
		};
		for (auto& entry : identifiers)
			compilersUsed.push_back(QString::fromStdString(lookupVersionStrings(entry.first) + " (" + std::to_string(entry.second) + " objects)"));

		AddField("Compiler(s) Used", compilersUsed);
	}

	auto versionInfo = data->QueryMetadata("PEVersionInfo");
	if (versionInfo && versionInfo->IsKeyValueStore())
	{
		for (const auto& [key, value] : versionInfo->GetKeyValueStore())
		{
			if (value->IsString() && !value->GetString().empty())
				AddField(QString::fromStdString(key), QString::fromStdString(value->GetString()));
		}
	}

	SetColumns(3);
	size_t numFields = GetFields().size();
	SetRowsPerColumn((numFields + 2) / 3);
}


uint64_t PEHeaders::GetValueOfStructMember(
    BinaryViewRef data, const std::string& structName, uint64_t structStart, const std::string& fieldName)
{
	TypeRef type = data->GetTypeByName(structName);
	if (!type)
		return 0;
	if (type->GetClass() != StructureTypeClass)
		return 0;
	StructureRef s = type->GetStructure();
	for (auto& member : s->GetMembers())
	{
		if (member.name == fieldName)
		{
			uint64_t offset = structStart + member.offset;
			size_t width = member.type->GetWidth();
			if (width > 8)
				return 0;
			uint64_t value = 0;
			data->Read(&value, offset, width);
			return value;
		}
	}
	return 0;
}


uint64_t PEHeaders::GetAddressAfterStruct(BinaryViewRef data, const std::string& structName, uint64_t structStart)
{
	TypeRef type = data->GetTypeByName(structName);
	if (!type)
		return structStart;
	return structStart + type->GetWidth();
}


QString PEHeaders::GetNameOfEnumerationMember(BinaryViewRef data, const std::string& enumName, uint64_t value)
{
	TypeRef type = data->GetTypeByName(enumName);
	if (type && (type->GetClass() == EnumerationTypeClass))
	{
		for (auto& member : type->GetEnumeration()->GetMembers())
		{
			if (member.value == value)
				return QString::fromStdString(member.name);
		}
	}
	return QString("0x") + QString::number(value, 16);
}


HeaderWidget::HeaderWidget(QWidget* parent, const Headers& header) : QWidget(parent), m_headers(header)
{
	m_layout = new QGridLayout();
	m_layout->setContentsMargins(0, 0, 0, 0);
	m_layout->setVerticalSpacing(1);
	m_layout->setHorizontalSpacing(2);
	setLayout(m_layout);
	m_currentColumns = (int)header.GetColumns();
	m_pendingWidth = -1;

	// Create timer for debouncing resize events
	m_resizeTimer = new QTimer(this);
	m_resizeTimer->setSingleShot(true);
	m_resizeTimer->setInterval(50);  // 50ms delay after resize stops
	connect(m_resizeTimer, &QTimer::timeout, this, &HeaderWidget::performDelayedResize);

	rebuildLayout();
}


void HeaderWidget::resizeEvent(QResizeEvent* event)
{
	QWidget::resizeEvent(event);
	updateColumns(this->width());
}


void HeaderWidget::updateColumns(int width)
{
	m_pendingWidth = width;
	m_resizeTimer->start();
}


void HeaderWidget::performDelayedResize()
{
	if (m_pendingWidth < 0)
		return;

	int width = m_pendingWidth;
	m_pendingWidth = -1;

	int desiredColumns;

	// Add hysteresis to prevent thrashing when width oscillates near breakpoints
	if (m_currentColumns == 1)
	{
		// Growing from 1 column: need to exceed threshold to switch
		if (width >= TriageBreakpoints::NARROW + 40)
			desiredColumns = (width >= TriageBreakpoints::MEDIUM + 40) ? (int)m_headers.GetColumns() : 2;
		else
			desiredColumns = 1;
	}
	else if (m_currentColumns == 2)
	{
		// From 2 columns: wider hysteresis band
		if (width < TriageBreakpoints::NARROW - 40)
			desiredColumns = 1;
		else if (width >= TriageBreakpoints::MEDIUM + 40)
			desiredColumns = (int)m_headers.GetColumns();
		else
			desiredColumns = 2;
	}
	else
	{
		// Shrinking from 3 columns: need to fall below threshold to switch
		if (width < TriageBreakpoints::NARROW - 40)
			desiredColumns = 1;
		else if (width < TriageBreakpoints::MEDIUM - 40)
			desiredColumns = 2;
		else
			desiredColumns = (int)m_headers.GetColumns();
	}

	if (desiredColumns != m_currentColumns)
	{
		m_currentColumns = desiredColumns;
		rebuildLayout();
	}
}


void HeaderWidget::rebuildLayout()
{
	// Disable updates during rebuild to prevent flickering
	setUpdatesEnabled(false);

	// Clear existing layout
	QLayoutItem* item;
	while ((item = m_layout->takeAt(0)) != nullptr)
	{
		if (item->widget())
		{
			item->widget()->hide();  // Hide before deletion to reduce flicker
			item->widget()->deleteLater();  // Use deleteLater() to safely delete during events
		}
		delete item;
	}

	// Rebuild with current column count
	int row = 0;
	int col = 0;
	for (auto& field : m_headers.GetFields())
	{
		m_layout->addWidget(new QLabel(field.title + ": "), row, col * 3);

		// For text fields with multiple values, join them with newlines for copying
		QString copyText;
		if (field.type == TextHeaderField && field.values.size() > 1)
		{
			copyText = field.values[0];
			for (size_t i = 1; i < field.values.size(); i++)
				copyText += "\n" + field.values[i];
		}

		for (auto& value : field.values)
		{
			QWidget* label;
			if (field.type == AddressHeaderField)
			{
				label = new NavigationAddressLabel(value);
			}
			else if (field.type == CodeHeaderField)
			{
				label = new NavigationCodeLabel(value);
			}
			else
			{
				// Use CopyableLabel for text fields with AlphanumericHighlightColor
				auto copyLabel = new CopyableLabel(value, getThemeColor(AlphanumericHighlightColor));
				copyLabel->setFont(getMonospaceFont(this));
				if (field.values.size() > 1)
					copyLabel->setCopyText(copyText);
				label = copyLabel;
			}
			m_layout->addWidget(label, row, col * 3 + 1);
			row++;
		}
		if ((m_currentColumns > 1) && (row >= (int)m_headers.GetRowsPerColumn())
		    && ((col + 1) < m_currentColumns))
		{
			row = 0;
			col++;
		}
	}

	// Clear all column stretches and minimum widths first
	for (col = 0; col < 9; col++)  // Max 3 columns * 3 grid columns each
	{
		m_layout->setColumnStretch(col, 0);
		m_layout->setColumnMinimumWidth(col, 0);
	}

	// Set spacing columns to minimum width
	for (col = 1; col < m_currentColumns; col++)
		m_layout->setColumnMinimumWidth(col * 3 - 1, UIContext::getScaledWindowSize(20, 20).width());

	// Set last column to stretch
	m_layout->setColumnStretch(m_currentColumns * 3 - 1, 1);

	// Re-enable updates and force a single repaint
	setUpdatesEnabled(true);
}