//
// Created by anonymus-raccoon on 3/20/20.
//

#include "MemoryBusDebug.hpp"
#include "../SNES.hpp"
#include "../Utility/Utility.hpp"
#include "../Exceptions/InvalidAction.hpp"
#include "../Exceptions/InvalidAddress.hpp"

namespace ComSquare::Debugger
{
	MemoryBusDebug::MemoryBusDebug(SNES &snes, const Memory::MemoryBus &bus)
		: MemoryBus(bus),
		_window(new ClosableWindow(*this, &MemoryBusDebug::disableViewer)),
		_snes(snes),
		_ui(),
		_model(),
		_proxy(this->_model)
	{
		this->_window->setContextMenuPolicy(Qt::NoContextMenu);
		this->_window->setAttribute(Qt::WA_QuitOnClose, false);
		this->_window->setAttribute(Qt::WA_DeleteOnClose);

		this->_ui.setupUi(this->_window);
		this->_proxy.setSourceModel(&this->_model);
		this->_ui.log->setModel(&this->_proxy);
		this->_ui.log->horizontalHeader()->setSectionResizeMode(QHeaderView::Interactive);
		this->_ui.log->horizontalHeader()->setStretchLastSection(true);
		this->_ui.log->horizontalHeader()->setSectionsMovable(true);
		for (int i = 0; i < this->_model.column; i++)
			this->_ui.log->setColumnWidth(i, this->_ui.log->width());

		QMainWindow::connect(this->_ui.fromAPU, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[0].apu = checked;
		});
		QMainWindow::connect(this->_ui.fromCPU, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[0].cpu = checked;
		});
		QMainWindow::connect(this->_ui.fromOAM, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[0].oamram = checked;
		});
		QMainWindow::connect(this->_ui.fromPPU, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[0].ppu = checked;
		});
		QMainWindow::connect(this->_ui.fromROM, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[0].rom = checked;
		});
		QMainWindow::connect(this->_ui.fromSRAM, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[0].sram = checked;
		});
		QMainWindow::connect(this->_ui.fromVRAM, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[0].vram = checked;
		});
		QMainWindow::connect(this->_ui.fromWRAM, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[0].wram = checked;
		});
		QMainWindow::connect(this->_ui.fromCG, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[0].cgram = checked;
		});

		QMainWindow::connect(this->_ui.toAPU, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[1].apu = checked;
		});
		QMainWindow::connect(this->_ui.toCPU, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[1].cpu = checked;
		});
		QMainWindow::connect(this->_ui.toOAM, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[1].oamram = checked;
		});
		QMainWindow::connect(this->_ui.toPPU, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[1].ppu = checked;
		});
		QMainWindow::connect(this->_ui.toSRAM, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[1].sram = checked;
		});
		QMainWindow::connect(this->_ui.toVRAM, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[1].vram = checked;
		});
		QMainWindow::connect(this->_ui.toWRAM, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[1].wram = checked;
		});
		QMainWindow::connect(this->_ui.toCG, &QCheckBox::toggled, [this](bool checked) {
			this->_proxy.filters[1].cgram = checked;
		});

		this->_window->show();
	}

	void MemoryBusDebug::disableViewer()
	{
		this->_snes.disableMemoryBusDebugging();
	}

	void MemoryBusDebug::focus()
	{
		this->_window->activateWindow();
	}

	bool MemoryBusDebug::isDebugger()
	{
		return true;
	}

	uint8_t MemoryBusDebug::read(uint24_t addr, bool silence)
	{
		if (!silence) {
			auto accessor = this->getAccessor(addr);
			uint8_t value = accessor->read(addr - accessor->getStart());
			this->_model.log(BusLog(false, addr, accessor, value, value));
		}
		return MemoryBus::read(addr);
	}

	void MemoryBusDebug::write(uint24_t addr, uint8_t data)
	{
		auto accessor = this->getAccessor(addr);
		uint8_t value;
		try {
			value = accessor->read(addr - accessor->getStart());
		} catch (InvalidAddress &) {
			value = 0;
		}
		this->_model.log(BusLog(true, addr, accessor, value, data));
		MemoryBus::write(addr, data);
	}

	BusLog::BusLog(bool _write, uint24_t _addr, std::shared_ptr<Memory::AMemory> &_accessor, uint8_t _oldData, uint8_t _newData) :
		write(_write), addr(_addr), accessor(std::move(_accessor)), oldData(_oldData), newData(_newData)
	{}
}

int BusLogModel::rowCount(const QModelIndex &) const
{
	return this->_logs.size();
}

int BusLogModel::columnCount(const QModelIndex &) const
{
	return this->column;
}

QVariant BusLogModel::data(const QModelIndex &index, int role) const
{
	if (role == Qt::TextAlignmentRole)
		return Qt::AlignCenter;
	if (role != Qt::DisplayRole)
		return QVariant();
	ComSquare::Debugger::BusLog log = this->_logs[index.row()];
	switch (index.column()) {
	case 0:
		return QString(log.write ? "Write" : "Read");
	case 1:
		return QString(ComSquare::Utility::to_hex(log.addr).c_str());
	case 2:
		return QString(log.accessor ? log.accessor->getName().c_str() : "Bus");
	case 3:
		return QString(log.accessor ? log.accessor->getValueName(log.addr - log.accessor->getStart()).c_str() : "Open bus");
	case 4:
		return QString(ComSquare::Utility::to_hex(log.oldData).c_str());
	case 5:
		return QString(ComSquare::Utility::to_hex(log.newData).c_str());
	default:
		return QVariant();
	}
}

QVariant BusLogModel::headerData(int section, Qt::Orientation orientation, int role) const
{
	if (role != Qt::DisplayRole || orientation == Qt::Vertical)
		return QVariant();
	switch (section) {
	case 0:
		return QString("Type");
	case 1:
		return QString("Address");
	case 2:
		return QString("Component");
	case 3:
		return QString("Data Name");
	case 4:
		return QString("Old Data");
	case 5:
		return QString("New Data");
	default:
		return QString("");
	}
}

void BusLogModel::log(ComSquare::Debugger::BusLog log)
{
	int row = this->_logs.size();
	this->beginInsertRows(QModelIndex(), row, row);
	this->_logs.push_back(log);
	this->insertRow(row);
	this->endInsertRows();
}

ComSquare::Debugger::BusLog BusLogModel::getLogAt(int index)
{
	return this->_logs[index];
}

BusLoggerProxy::BusLoggerProxy(BusLogModel &parent) : QSortFilterProxyModel(), _parent(parent) {}

bool BusLoggerProxy::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
{
	ComSquare::Debugger::BusLog log = this->_parent.getLogAt(sourceRow);

	if (!log.accessor)
		return true;
	ComSquare::Component component = log.accessor->getComponent();
	switch (component) {
	case ComSquare::Component::Cpu:
		return this->filters[log.write].cpu;
	case ComSquare::Component::Ppu:
		return this->filters[log.write].ppu;
	case ComSquare::Component::Apu:
		return this->filters[log.write].apu;
	case ComSquare::Component::Rom:
		return this->filters[log.write].rom;
	case ComSquare::Component::WRam:
		return this->filters[log.write].wram;
	case ComSquare::Component::VRam:
		return this->filters[log.write].vram;
	case ComSquare::Component::CGRam:
		return this->filters[log.write].cgram;
	case ComSquare::Component::OAMRam:
		return this->filters[log.write].oamram;
	case ComSquare::Component::SRam:
		return this->filters[log.write].sram;
	}
}