#include <QtWidgets/QGroupBox>
#include <QtWidgets/QVBoxLayout>
#include <QtWidgets/QSplitter>
#include "view.h"
#include "entropy.h"
#include "entry.h"
#include "imports.h"
#include "exports.h"
#include "resources.h"
#include "sections.h"
#include "fileinfo.h"
#include "librariesinfo.h"
#include "headers.h"
#include "strings.h"
#include "baseaddress.h"
#include "fontsettings.h"
#include "analysisinfo.h"
#include <binaryninjacore.h>

TriageView::TriageView(QWidget* parent, BinaryViewRef data) : QScrollArea(parent)
{
	setupView(this);
	m_data = data;
	m_currentOffset = m_data->GetEntryPoint();

	QWidget* container = new QWidget(this);
	QVBoxLayout* layout = new QVBoxLayout();

	QGroupBox* entropyGroup = new QGroupBox("Entropy", container);
	QVBoxLayout* entropyLayout = new QVBoxLayout();
	m_entropyWidget = new EntropyWidget(entropyGroup, this, m_data);
	entropyLayout->addWidget(m_entropyWidget);
	entropyGroup->setLayout(entropyLayout);
	layout->addWidget(entropyGroup);

	QGroupBox* fileInfoGroup = new QGroupBox("File Info", container);
	QVBoxLayout* fileInfoLayout = new QVBoxLayout();
	fileInfoLayout->addWidget(new FileInfoWidget(fileInfoGroup, m_data, m_entropyWidget));
	fileInfoGroup->setLayout(fileInfoLayout);
	layout->addWidget(fileInfoGroup);

	Headers* hdr = nullptr;
	if (m_data->GetTypeName() == "PE")
		hdr = new PEHeaders(m_data);
	else if (m_data->GetTypeName() != "Raw")
		hdr = new GenericHeaders(m_data);

	if (hdr)
	{
		QGroupBox* headerGroup = new QGroupBox("Headers", container);
		QVBoxLayout* headerLayout = new QVBoxLayout();
		m_headerWidget = new HeaderWidget(headerGroup, *hdr);
		headerLayout->addWidget(m_headerWidget);
		headerGroup->setLayout(headerLayout);
		layout->addWidget(headerGroup);
		delete hdr;
	}

	auto fileMetadata = m_data->GetFile();
	if (m_data == fileMetadata->GetViewOfType("Raw") || m_data == fileMetadata->GetViewOfType("Mapped"))
	{
		QGroupBox* baseDetectionGroup = new QGroupBox("Base Address Detection", container);
		QVBoxLayout* baseDetectionLayout = new QVBoxLayout();
		baseDetectionLayout->addWidget(new BaseAddressDetectionWidget(this, data));
		baseDetectionGroup->setLayout(baseDetectionLayout);
		layout->addWidget(baseDetectionGroup);
	}

	if (m_data->IsExecutable())
	{
		QGroupBox* librariesGroup = new QGroupBox("Libraries", container);
		QVBoxLayout* librariesLayout = new QVBoxLayout();
		librariesLayout->addWidget(new LibrariesWidget(this, data));
		librariesGroup->setLayout(librariesLayout);
		layout->addWidget(librariesGroup);

		m_importExportSplitter = new QSplitter(Qt::Horizontal);

		QGroupBox* importGroup = new QGroupBox("Imports", container);
		QVBoxLayout* importLayout = new QVBoxLayout();
		importLayout->addWidget(new ImportsWidget(importGroup, this, m_data));
		importGroup->setLayout(importLayout);
		m_importExportSplitter->addWidget(importGroup);

		QSplitter* exportEntrySplitter = new QSplitter(Qt::Vertical);

		QGroupBox* exportGroup = new QGroupBox("Exports", container);
		QVBoxLayout* exportLayout = new QVBoxLayout();
		exportLayout->addWidget(new ExportsWidget(exportGroup, this, m_data));
		exportGroup->setLayout(exportLayout);
		exportEntrySplitter->addWidget(exportGroup);

		QGroupBox* entryGroup = new QGroupBox("Entry Functions", container);
		QVBoxLayout* entryLayout = new QVBoxLayout();
		entryLayout->addWidget(new EntryWidget(entryGroup, this, m_data));
		entryGroup->setLayout(entryLayout);
		exportEntrySplitter->addWidget(entryGroup);

		m_importExportSplitter->addWidget(exportEntrySplitter);
		layout->addWidget(m_importExportSplitter);

		if (m_data->GetTypeName() != "PE")
		{
			QGroupBox* segmentsGroup = new QGroupBox("Segments", container);
			QVBoxLayout* segmentsLayout = new QVBoxLayout();
			SegmentsWidget* segmentsWidget = new SegmentsWidget(segmentsGroup, m_data);
			segmentsLayout->addWidget(segmentsWidget);
			segmentsGroup->setLayout(segmentsLayout);
			layout->addWidget(segmentsGroup);
			if (segmentsWidget->GetSegments().size() == 0)
				segmentsGroup->hide();
		}

		QGroupBox* sectionsGroup = new QGroupBox("Sections", container);
		QVBoxLayout* sectionsLayout = new QVBoxLayout();
		SectionsWidget* sectionsWidget = new SectionsWidget(sectionsGroup, m_data);
		sectionsLayout->addWidget(sectionsWidget);
		sectionsGroup->setLayout(sectionsLayout);
		layout->addWidget(sectionsGroup);
		if (sectionsWidget->GetSections().size() == 0)
			sectionsGroup->hide();

		if (m_data->GetTypeName() == "PE")
		{
			auto resourcesMd = m_data->QueryMetadata("PEResources");
			if (resourcesMd && resourcesMd->IsArray() && !resourcesMd->GetArray().empty())
			{
				QGroupBox* resourcesGroup = new QGroupBox("Resources", container);
				QVBoxLayout* resourcesLayout = new QVBoxLayout();
				resourcesLayout->addWidget(new ResourcesWidget(resourcesGroup, this, m_data));
				resourcesGroup->setLayout(resourcesLayout);
				layout->addWidget(resourcesGroup);
			}
		}

		QGroupBox* analysisInfoGroup = new QGroupBox("Analysis Info", container);
		QVBoxLayout* analysisInfoLayout = new QVBoxLayout();
		analysisInfoLayout->addWidget(new AnalysisInfoWidget(analysisInfoGroup, m_data));
		analysisInfoGroup->setLayout(analysisInfoLayout);
		layout->addWidget(analysisInfoGroup);

		QGroupBox* stringsGroup = new QGroupBox("Strings", container);
		QVBoxLayout* stringsLayout = new QVBoxLayout();
		stringsLayout->addWidget(new StringsWidget(stringsGroup, this, m_data));
		stringsGroup->setLayout(stringsLayout);
		layout->addWidget(stringsGroup);

		QHBoxLayout* buttonLayout = new QHBoxLayout();
		buttonLayout->addStretch(1);
		m_fullAnalysisButton = new QPushButton("Start Full Analysis");
		connect(m_fullAnalysisButton, &QPushButton::clicked, this, &TriageView::startFullAnalysis);
		buttonLayout->addWidget(m_fullAnalysisButton);
		layout->addLayout(buttonLayout);
		layout->addStretch(1);
		m_byteView = nullptr;
	}
	else
	{
		m_byteView = new ByteView(this, m_data);
		layout->addWidget(m_byteView, 1);
	}

	setBinaryDataNavigable(true);
	container->setLayout(layout);
	setWidgetResizable(true);
	setWidget(container);

	if (m_fullAnalysisButton && (BinaryNinja::Settings::Instance()->Get<std::string>("analysis.mode", data) == "full"))
		m_fullAnalysisButton->hide();

	// Bind the "Go to Address..." action
	actionHandler()->bindAction("Go to Address...", UIAction([this]() { goToAddress(); }));
}


BinaryViewRef TriageView::getData()
{
	return m_data;
}


uint64_t TriageView::getCurrentOffset()
{
	if (m_byteView)
		return m_byteView->getCurrentOffset();
	return m_currentOffset;
}


BNAddressRange TriageView::getSelectionOffsets()
{
	if (m_byteView)
		return m_byteView->getSelectionOffsets();
	return {m_currentOffset, m_currentOffset};
}

void TriageView::setSelectionOffsets(BNAddressRange range)
{
	// for subclass of View who does not have a meaningful setSelectionOffsets() behavior,
	// we navigate to the start of the selection range
	navigate(range.start);
}

void TriageView::setCurrentOffset(uint64_t offset)
{
	m_currentOffset = offset;
	UIContext::updateStatus();
	updateCrossReferenceSelection();
}


QFont TriageView::getFont()
{
	return getMonospaceFont(this);
}


bool TriageView::navigate(uint64_t addr)
{
	if (m_byteView)
		return m_byteView->navigate(addr);

	setCurrentOffset(addr);
	return false;
}


void TriageView::startFullAnalysis()
{
	BinaryNinja::Settings::Instance()->Set("analysis.mode", "full", m_data);
	for (auto& f : m_data->GetAnalysisFunctionList())
	{
		if (f->IsAnalysisSkipped())
			f->Reanalyze();
	}
	m_data->UpdateAnalysis();
	m_fullAnalysisButton->hide();
}


void TriageView::goToAddress()
{
	uint64_t addr;
	if (!ViewFrame::getAddressFromInput(this, m_data, addr, getCurrentOffset()))
		return;

	ViewFrame* frame = ViewFrame::viewFrameForWidget(this);
	if (!frame)
		return;

	QString viewType = BinaryNinja::Settings::Instance()->Get<bool>("ui.view.graph.preferred") ? "Graph" : "Linear";
	QString dataType = QString::fromStdString(m_data->GetTypeName());
	frame->navigate(viewType + ":" + dataType, addr);
}


void TriageView::navigateToFileOffset(uint64_t offset)
{
	if (!m_byteView)
	{
		uint64_t addr = 0;
		bool hasAddr = m_data->GetAddressForDataOffset(offset, addr);
		ViewFrame* frame = ViewFrame::viewFrameForWidget(this);
		if (!frame)
			return;
		if (!hasAddr)
			frame->navigate("Hex:Raw", offset);
		else
		{
			QString viewType = BinaryNinja::Settings::Instance()->Get<bool>("ui.view.graph.preferred") ? "Graph" : "Linear";
			QString dataType = QString::fromStdString(m_data->GetTypeName());
			frame->navigate(viewType + ":" + dataType, addr);
		}
	}
	else
	{
		uint64_t addr;
		bool hasAddr;
		if (m_data == m_data->GetFile()->GetViewOfType("Raw"))
		{
			addr = offset;
			hasAddr = true;
		}
		else
		{
			hasAddr = m_data->GetAddressForDataOffset(offset, addr);
		}
		if (!hasAddr)
		{
			ViewFrame* frame = ViewFrame::viewFrameForWidget(this);
			if (frame)
				frame->navigate("Hex:Raw", offset);
		}
		else
		{
			m_byteView->navigate(addr);
			m_byteView->setFocus(Qt::OtherFocusReason);
		}
	}
}


void TriageView::focusInEvent(QFocusEvent*)
{
	if (m_byteView)
		m_byteView->setFocus(Qt::OtherFocusReason);
}


void TriageView::resizeEvent(QResizeEvent* event)
{
	QScrollArea::resizeEvent(event);
	updateImportExportLayout();
}


void TriageView::updateImportExportLayout()
{
	if (!m_importExportSplitter)
		return;

	int width = viewport()->width();
	Qt::Orientation currentOrientation = m_importExportSplitter->orientation();
	Qt::Orientation desiredOrientation;

	// Add hysteresis: use different thresholds for shrinking vs growing
	if (currentOrientation == Qt::Horizontal)
	{
		desiredOrientation = (width < TriageBreakpoints::NARROW - 20) ? Qt::Vertical : Qt::Horizontal;
	}
	else
	{
		desiredOrientation = (width >= TriageBreakpoints::NARROW + 20) ? Qt::Horizontal : Qt::Vertical;
	}

	if (currentOrientation != desiredOrientation)
		m_importExportSplitter->setOrientation(desiredOrientation);
}


TriageViewType::TriageViewType() : ViewType("Triage", "Triage Summary") {}


int TriageViewType::getPriority(BinaryViewRef data, const QString&)
{
	BinaryNinja::Ref<BinaryNinja::Settings> settings = BinaryNinja::Settings::Instance();
	auto analysisMode = settings->Get<std::string>("analysis.mode", data);
	bool full = analysisMode == "full";
	bool intermediate = analysisMode == "intermediate";
	bool alwaysPrefer = settings->Get<bool>("triage.preferSummaryView", data);
	bool preferForRaw = settings->Get<bool>("triage.preferSummaryViewForRaw", data);
	if (data->IsExecutable() && (alwaysPrefer || (!full && !intermediate)))
		return 100;
	if (data->GetLength() > 0)
	{
		if (alwaysPrefer || preferForRaw)
			return 35;
		if (data->IsExecutable())
			return 25;
		return 1;
	}
	return 0;
}


QWidget* TriageViewType::create(BinaryViewRef data, ViewFrame* frame)
{
	return new TriageView(frame, data);
}