#include "stdafx.h"
#include "Debugger.h"
#include "DebugTypes.h"
#include "Console.h"
#include "Cpu.h"
#include "Ppu.h"
#include "Spc.h"
#include "Sa1.h"
#include "Gsu.h"
#include "Cx4.h"
#include "NecDsp.h"
#include "Gameboy.h"
#include "CpuDebugger.h"
#include "SpcDebugger.h"
#include "GsuDebugger.h"
#include "NecDspDebugger.h"
#include "Cx4Debugger.h"
#include "GbDebugger.h"
#include "BaseCartridge.h"
#include "MemoryManager.h"
#include "EmuSettings.h"
#include "SoundMixer.h"
#include "MemoryMappings.h"
#include "NotificationManager.h"
#include "CpuTypes.h"
#include "DisassemblyInfo.h"
#include "TraceLogger.h"
#include "MemoryDumper.h"
#include "MemoryAccessCounter.h"
#include "CodeDataLogger.h"
#include "Disassembler.h"
#include "BreakpointManager.h"
#include "PpuTools.h"
#include "EventManager.h"
#include "GbEventManager.h"
#include "EventType.h"
#include "DebugBreakHelper.h"
#include "LabelManager.h"
#include "ScriptManager.h"
#include "CallstackManager.h"
#include "ExpressionEvaluator.h"
#include "InternalRegisters.h"
#include "AluMulDiv.h"
#include "Assembler.h"
#include "Gameboy.h"
#include "GbPpu.h"
#include "GbAssembler.h"
#include "GameboyHeader.h"
#include "../Utilities/HexUtilities.h"
#include "../Utilities/FolderUtilities.h"
#include "../Utilities/IpsPatcher.h"

Debugger::Debugger(shared_ptr<Console> console)
{
	_console = console;
	_cpu = console->GetCpu();
	_ppu = console->GetPpu();
	_spc = console->GetSpc();
	_cart = console->GetCartridge();
	_settings = console->GetSettings();
	_memoryManager = console->GetMemoryManager();
	_dmaController = console->GetDmaController();
	_internalRegs = console->GetInternalRegisters();
	_gameboy = _cart->GetGameboy();

	_labelManager.reset(new LabelManager(this));
	_watchExpEval[(int)CpuType::Cpu].reset(new ExpressionEvaluator(this, CpuType::Cpu));
	_watchExpEval[(int)CpuType::Spc].reset(new ExpressionEvaluator(this, CpuType::Spc));
	_watchExpEval[(int)CpuType::Sa1].reset(new ExpressionEvaluator(this, CpuType::Sa1));
	_watchExpEval[(int)CpuType::Gsu].reset(new ExpressionEvaluator(this, CpuType::Gsu));
	_watchExpEval[(int)CpuType::NecDsp].reset(new ExpressionEvaluator(this, CpuType::NecDsp));
	_watchExpEval[(int)CpuType::Cx4].reset(new ExpressionEvaluator(this, CpuType::Cx4));
	_watchExpEval[(int)CpuType::Gameboy].reset(new ExpressionEvaluator(this, CpuType::Gameboy));

	_codeDataLogger.reset(new CodeDataLogger(_cart->DebugGetPrgRomSize(), CpuType::Cpu));
	_memoryDumper.reset(new MemoryDumper(this));
	_disassembler.reset(new Disassembler(console, _codeDataLogger, this));
	_traceLogger.reset(new TraceLogger(this, _console));
	_memoryAccessCounter.reset(new MemoryAccessCounter(this, console.get()));
	_ppuTools.reset(new PpuTools(_console.get(), _ppu.get()));
	_scriptManager.reset(new ScriptManager(this));

	if(_gameboy) {
		_gbDebugger.reset(new GbDebugger(this));
	}
	_cpuDebugger.reset(new CpuDebugger(this, CpuType::Cpu));
	_spcDebugger.reset(new SpcDebugger(this));
	if(_cart->GetSa1()) {
		_sa1Debugger.reset(new CpuDebugger(this, CpuType::Sa1));
	} else if(_cart->GetGsu()) {
		_gsuDebugger.reset(new GsuDebugger(this));
	} else if(_cart->GetDsp()) {
		_necDspDebugger.reset(new NecDspDebugger(this));
	} else if(_cart->GetCx4()) {
		_cx4Debugger.reset(new Cx4Debugger(this));
	}

	_executionStopped = true;
	_breakRequestCount = 0;
	_suspendRequestCount = 0;

	CpuType cpuType = _gbDebugger ? CpuType::Gameboy : CpuType::Cpu;
	string cdlFile = FolderUtilities::CombinePath(FolderUtilities::GetDebuggerFolder(), FolderUtilities::GetFilename(_cart->GetRomInfo().RomFile.GetFileName(), false) + ".cdl");
	GetCodeDataLogger(cpuType)->LoadCdlFile(cdlFile, _settings->CheckDebuggerFlag(DebuggerFlags::AutoResetCdl), _cart->GetCrc32());

	RefreshCodeCache();

	if(_console->IsPaused()) {
		Step(CpuType::Cpu, 1, StepType::Step);
	}
	_executionStopped = false;
}

Debugger::~Debugger()
{
	Release();
}

void Debugger::Release()
{
	CpuType cpuType = _gbDebugger ? CpuType::Gameboy : CpuType::Cpu;
	string cdlFile = FolderUtilities::CombinePath(FolderUtilities::GetDebuggerFolder(), FolderUtilities::GetFilename(_cart->GetRomInfo().RomFile.GetFileName(), false) + ".cdl");
	GetCodeDataLogger(cpuType)->SaveCdlFile(cdlFile, _cart->GetCrc32());

	while(_executionStopped) {
		Run();
	}
}

void Debugger::Reset()
{
	_memoryAccessCounter->ResetCounts();
	_cpuDebugger->Reset();
	_spcDebugger->Reset();
	if(_sa1Debugger) {
		_sa1Debugger->Reset();
	}
}

template<CpuType type>
void Debugger::ProcessMemoryRead(uint32_t addr, uint8_t value, MemoryOperationType opType)
{
	switch(type) {
		case CpuType::Cpu: _cpuDebugger->ProcessRead(addr, value, opType); break;
		case CpuType::Spc: _spcDebugger->ProcessRead(addr, value, opType); break;
		case CpuType::NecDsp: _necDspDebugger->ProcessRead(addr, value, opType); break;
		case CpuType::Sa1: _sa1Debugger->ProcessRead(addr, value, opType); break;
		case CpuType::Gsu: _gsuDebugger->ProcessRead(addr, value, opType); break;
		case CpuType::Cx4: _cx4Debugger->ProcessRead(addr, value, opType); break;
		case CpuType::Gameboy: _gbDebugger->ProcessRead(addr, value, opType); break;
	}
	
	if(_scriptManager->HasScript()) {
		_scriptManager->ProcessMemoryOperation(addr, value, opType, type);
	}
}

template<CpuType type>
void Debugger::ProcessMemoryWrite(uint32_t addr, uint8_t value, MemoryOperationType opType)
{
	switch(type) {
		case CpuType::Cpu: _cpuDebugger->ProcessWrite(addr, value, opType); break;
		case CpuType::Spc: _spcDebugger->ProcessWrite(addr, value, opType); break;
		case CpuType::NecDsp: _necDspDebugger->ProcessWrite(addr, value, opType); break;
		case CpuType::Sa1: _sa1Debugger->ProcessWrite(addr, value, opType); break;
		case CpuType::Gsu: _gsuDebugger->ProcessWrite(addr, value, opType); break;
		case CpuType::Cx4: _cx4Debugger->ProcessWrite(addr, value, opType); break;
		case CpuType::Gameboy: _gbDebugger->ProcessWrite(addr, value, opType); break;
	}
	
	if(_scriptManager->HasScript()) {
		_scriptManager->ProcessMemoryOperation(addr, value, opType, type);
	}
}

void Debugger::ProcessWorkRamRead(uint32_t addr, uint8_t value)
{
	AddressInfo addressInfo { (int32_t)addr, SnesMemoryType::WorkRam };
	_memoryAccessCounter->ProcessMemoryRead(addressInfo, _memoryManager->GetMasterClock());
	
	MemoryOperationInfo operation { 0x7E0000 | addr, value, MemoryOperationType::Read };
	ProcessBreakConditions(false, _cpuDebugger->GetBreakpointManager(), operation, addressInfo);
}

void Debugger::ProcessWorkRamWrite(uint32_t addr, uint8_t value)
{
	AddressInfo addressInfo { (int32_t)addr, SnesMemoryType::WorkRam };
	_memoryAccessCounter->ProcessMemoryWrite(addressInfo, _memoryManager->GetMasterClock());
	
	MemoryOperationInfo operation { 0x7E0000 | addr, value, MemoryOperationType::Write };
	ProcessBreakConditions(false, _cpuDebugger->GetBreakpointManager(), operation, addressInfo);
}

void Debugger::ProcessPpuRead(uint16_t addr, uint8_t value, SnesMemoryType memoryType)
{
	AddressInfo addressInfo { addr, memoryType };
	MemoryOperationInfo operation { addr, value, MemoryOperationType::Read };
	
	BreakpointManager* bpManager = DebugUtilities::ToCpuType(memoryType) == CpuType::Gameboy ? _gbDebugger->GetBreakpointManager() : _cpuDebugger->GetBreakpointManager();
	ProcessBreakConditions(false, bpManager, operation, addressInfo);

	_memoryAccessCounter->ProcessMemoryRead(addressInfo, _console->GetMasterClock());
}

void Debugger::ProcessPpuWrite(uint16_t addr, uint8_t value, SnesMemoryType memoryType)
{
	AddressInfo addressInfo { addr, memoryType };
	MemoryOperationInfo operation { addr, value, MemoryOperationType::Write };
	
	BreakpointManager* bpManager = DebugUtilities::ToCpuType(memoryType) == CpuType::Gameboy ? _gbDebugger->GetBreakpointManager() : _cpuDebugger->GetBreakpointManager();
	ProcessBreakConditions(false, bpManager, operation, addressInfo);

	_memoryAccessCounter->ProcessMemoryWrite(addressInfo, _console->GetMasterClock());
}

template<CpuType cpuType>
void Debugger::ProcessPpuCycle()
{
	uint16_t scanline;
	uint16_t cycle;
	if(cpuType == CpuType::Gameboy) {
		scanline = _gameboy->GetPpu()->GetScanline();
		cycle = _gameboy->GetPpu()->GetCycle();
	} else {
		scanline = _ppu->GetScanline();
		cycle = _memoryManager->GetHClock();
	}

	_ppuTools->UpdateViewers(scanline, cycle, cpuType);

	switch(cpuType) {
		case CpuType::Cpu: 
			//Catch up SPC/DSP as needed (if we're tracing or debugging those particular CPUs)
			if(_traceLogger->IsCpuLogged(CpuType::Spc) || _settings->CheckDebuggerFlag(DebuggerFlags::SpcDebuggerEnabled)) {
				_spc->Run();
			} else if(_traceLogger->IsCpuLogged(CpuType::NecDsp)) {
				_cart->RunCoprocessors();
			}

			_cpuDebugger->ProcessPpuCycle(scanline, cycle);
			break;

		case CpuType::Gameboy: 
			_gbDebugger->ProcessPpuCycle(scanline, cycle);
			break;
	}

	if(_breakRequestCount > 0) {
		SleepUntilResume(BreakSource::Unspecified);
	}
}

void Debugger::SleepUntilResume(BreakSource source, MemoryOperationInfo *operation, int breakpointId)
{
	if(_suspendRequestCount) {
		return;
	}

	_console->GetSoundMixer()->StopAudio();
	_disassembler->Disassemble(CpuType::Cpu);
	_disassembler->Disassemble(CpuType::Spc);
	if(_cart->GetSa1()) {
		_disassembler->Disassemble(CpuType::Sa1);
	} else if(_cart->GetGsu()) {
		_disassembler->Disassemble(CpuType::Gsu);
	} else if(_cart->GetDsp()) {
		_disassembler->Disassemble(CpuType::NecDsp);
	} else if(_cart->GetCx4()) {
		_disassembler->Disassemble(CpuType::Cx4);
	} else if(_cart->GetGameboy()) {
		_disassembler->RefreshDisassembly(CpuType::Gameboy);
	}

	_executionStopped = true;
	
	if(source != BreakSource::Unspecified || _breakRequestCount == 0) {
		//Only trigger code break event if the pause was caused by user action
		BreakEvent evt = {};
		evt.BreakpointId = breakpointId;
		evt.Source = source;
		if(operation) {
			evt.Operation = *operation;
		}
		_waitForBreakResume = true;
		_console->GetNotificationManager()->SendNotification(ConsoleNotificationType::CodeBreak, &evt);
	}

	while((_waitForBreakResume && !_suspendRequestCount) || _breakRequestCount) {
		std::this_thread::sleep_for(std::chrono::duration<int, std::milli>(10));
	}

	_executionStopped = false;
}

void Debugger::ProcessBreakConditions(bool needBreak, BreakpointManager* bpManager, MemoryOperationInfo &operation, AddressInfo &addressInfo, BreakSource source)
{
	if(needBreak || _breakRequestCount || _waitForBreakResume) {
		SleepUntilResume(source);
	} else {
		int breakpointId = bpManager->CheckBreakpoint(operation, addressInfo);
		if(breakpointId >= 0) {
			SleepUntilResume(BreakSource::Breakpoint, &operation, breakpointId);
		}
	}
}

template<CpuType type>
void Debugger::ProcessInterrupt(uint32_t originalPc, uint32_t currentPc, bool forNmi)
{
	switch(type) {
		case CpuType::Cpu: _cpuDebugger->ProcessInterrupt(originalPc, currentPc, forNmi); break;
		case CpuType::Sa1: _sa1Debugger->ProcessInterrupt(originalPc, currentPc, forNmi); break;
		case CpuType::Gameboy: _gbDebugger->ProcessInterrupt(originalPc, currentPc); break;
	}

	ProcessEvent(forNmi ? EventType::Nmi : EventType::Irq);
}

void Debugger::ProcessEvent(EventType type)
{
	_scriptManager->ProcessEvent(type);

	switch(type) {
		default: break;

		case EventType::StartFrame:
			_console->GetNotificationManager()->SendNotification(ConsoleNotificationType::EventViewerRefresh, (void*)CpuType::Cpu);
			GetEventManager(CpuType::Cpu)->ClearFrameEvents();
			break;

		case EventType::GbStartFrame:
			if(_settings->CheckFlag(EmulationFlags::GameboyMode)) {
				_scriptManager->ProcessEvent(EventType::StartFrame);
			}
			_console->GetNotificationManager()->SendNotification(ConsoleNotificationType::EventViewerRefresh, (void*)CpuType::Gameboy);
			GetEventManager(CpuType::Gameboy)->ClearFrameEvents();
			break;
		
		case EventType::GbEndFrame:
			if(_settings->CheckFlag(EmulationFlags::GameboyMode)) {
				_scriptManager->ProcessEvent(EventType::EndFrame);
			}
			break;

		case EventType::Reset:
			Reset();
			break;

		case EventType::StateLoaded:
			_memoryAccessCounter->ResetCounts();
			break;
	}
}

int32_t Debugger::EvaluateExpression(string expression, CpuType cpuType, EvalResultType &resultType, bool useCache)
{
	MemoryOperationInfo operationInfo { 0, 0, MemoryOperationType::Read };
	DebugState state;
	GetState(state, false);
	if(useCache) {
		return _watchExpEval[(int)cpuType]->Evaluate(expression, state, resultType, operationInfo);
	} else {
		ExpressionEvaluator expEval(this, cpuType);
		return expEval.Evaluate(expression, state, resultType, operationInfo);
	}
}

void Debugger::Run()
{
	_cpuDebugger->Run();
	_spcDebugger->Run();
	if(_sa1Debugger) {
		_sa1Debugger->Run();
	}
	if(_gsuDebugger) {
		_gsuDebugger->Run();
	}
	if(_necDspDebugger) {
		_necDspDebugger->Run();
	}
	if(_cx4Debugger) {
		_cx4Debugger->Run();
	}	
	if(_gbDebugger) {
		_gbDebugger->Run();
	}
	_waitForBreakResume = false;
}

void Debugger::Step(CpuType cpuType, int32_t stepCount, StepType type)
{
	DebugBreakHelper helper(this);
	StepRequest step;
	IDebugger *debugger = nullptr;

	switch(cpuType) {
		case CpuType::Cpu: debugger = _cpuDebugger.get(); break;
		case CpuType::Spc: debugger = _spcDebugger.get(); break;
		case CpuType::NecDsp: debugger = _necDspDebugger.get(); break;
		case CpuType::Sa1: debugger = _sa1Debugger.get(); break;
		case CpuType::Gsu: debugger = _gsuDebugger.get(); break;
		case CpuType::Cx4: debugger = _cx4Debugger.get(); break;
		case CpuType::Gameboy: debugger = _gbDebugger.get(); break;
	}

	if(debugger) {
		debugger->Step(stepCount, type);
	}

	if(debugger != _cpuDebugger.get()) {
		_cpuDebugger->Run();
	}
	if(debugger != _spcDebugger.get()) {
		_spcDebugger->Run();
	}
	if(_sa1Debugger && debugger != _sa1Debugger.get()) {
		_sa1Debugger->Run();
	}
	if(_gsuDebugger && debugger != _gsuDebugger.get()) {
		_gsuDebugger->Run();
	}
	if(_necDspDebugger && debugger != _necDspDebugger.get()) {
		_necDspDebugger->Run();
	}
	if(_cx4Debugger && debugger != _cx4Debugger.get()) {
		_cx4Debugger->Run();
	}
	if(_gbDebugger && debugger != _gbDebugger.get()) {
		_gbDebugger->Run();
	}
	_waitForBreakResume = false;
}

bool Debugger::IsExecutionStopped()
{
	return _executionStopped || _console->IsThreadPaused();
}

bool Debugger::HasBreakRequest()
{
	return _breakRequestCount > 0;
}

void Debugger::BreakRequest(bool release)
{
	if(release) {
		_breakRequestCount--;
	} else {
		_breakRequestCount++;
	}
}

void Debugger::SuspendDebugger(bool release)
{
	if(release) {
		if(_suspendRequestCount > 0) {
			_suspendRequestCount--;
		} else {
		#ifdef _DEBUG
			//throw std::runtime_error("unexpected debugger suspend::release call");
		#endif
		}
	} else {
		_suspendRequestCount++;
	}
}

void Debugger::BreakImmediately(BreakSource source)
{
	bool gbDebugger = _settings->CheckDebuggerFlag(DebuggerFlags::GbDebuggerEnabled);
	if(source == BreakSource::GbDisableLcdOutsideVblank && (!gbDebugger || !_settings->CheckDebuggerFlag(DebuggerFlags::GbBreakOnDisableLcdOutsideVblank))) {
		return;
	} else if(source == BreakSource::GbInvalidVramAccess && (!gbDebugger || !_settings->CheckDebuggerFlag(DebuggerFlags::GbBreakOnInvalidVramAccess))) {
		return;
	} else if(source == BreakSource::GbInvalidOamAccess && (!gbDebugger || !_settings->CheckDebuggerFlag(DebuggerFlags::GbBreakOnInvalidOamAccess))) {
		return;
	}
	SleepUntilResume(source);
}

void Debugger::GetState(DebugState &state, bool partialPpuState)
{
	state.MasterClock = _console->GetMasterClock();
	state.Cpu = _cpu->GetState();
	_ppu->GetState(state.Ppu, partialPpuState);
	state.Spc = _spc->GetState();
	state.Dsp = _spc->GetDspState();

	if(!partialPpuState) {
		for(int i = 0; i < 8; i++) {
			state.DmaChannels[i] = _dmaController->GetChannelConfig(i);
		}
		state.InternalRegs = _internalRegs->GetState();
		state.Alu = _internalRegs->GetAluState();
	}

	if(_cart->GetDsp()) {
		state.NecDsp = _cart->GetDsp()->GetState();
	}
	if(_cart->GetSa1()) {
		state.Sa1 = _cart->GetSa1()->GetState();
	}
	if(_cart->GetGsu()) {
		state.Gsu = _cart->GetGsu()->GetState();
	}
	if(_cart->GetCx4()) {
		state.Cx4 = _cart->GetCx4()->GetState();
	}
	if(_cart->GetGameboy()) {
		state.Gameboy = _cart->GetGameboy()->GetState();
	}
}

bool Debugger::GetCpuProcFlag(ProcFlags::ProcFlags flag)
{
	return _cpu->GetCpuProcFlag(flag);
}

void Debugger::SetCpuRegister(CpuRegister reg, uint16_t value)
{
	_cpu->SetReg(reg, value);
}

void Debugger::SetCpuProcFlag(ProcFlags::ProcFlags flag, bool set)
{
	_cpu->SetCpuProcFlag(flag, set);
}

void Debugger::SetCx4Register(Cx4Register reg, uint32_t value)
{
	_cart->GetCx4()->SetReg(reg, value);
}

void Debugger::SetGameboyRegister(GbRegister reg, uint16_t value)
{
	_cart->GetGameboy()->SetReg(reg, value);
}

void Debugger::SetGsuRegister(GsuRegister reg, uint16_t value)
{
	_cart->GetGsu()->SetReg(reg, value);
}

void Debugger::SetNecDspRegister(NecDspRegister reg, uint16_t value)
{
	_cart->GetDsp()->SetReg(reg, value);
}

void Debugger::SetSa1Register(CpuRegister reg, uint16_t value)
{
	_cart->GetSa1()->SetReg(reg, value);
}

void Debugger::SetSpcRegister(SpcRegister reg, uint16_t value)
{
	_spc->SetReg(reg, value);
}

AddressInfo Debugger::GetAbsoluteAddress(AddressInfo relAddress)
{
	if(relAddress.Type == SnesMemoryType::CpuMemory) {
		if(_memoryManager->IsRegister(relAddress.Address)) {
			return { relAddress.Address & 0xFFFF, SnesMemoryType::Register };
		} else {
			return _memoryManager->GetMemoryMappings()->GetAbsoluteAddress(relAddress.Address);
		}
	} else if(relAddress.Type == SnesMemoryType::SpcMemory) {
		return _spc->GetAbsoluteAddress(relAddress.Address);
	} else if(relAddress.Type == SnesMemoryType::Sa1Memory) {
		return _cart->GetSa1()->GetMemoryMappings()->GetAbsoluteAddress(relAddress.Address);
	} else if(relAddress.Type == SnesMemoryType::GsuMemory) {
		return _cart->GetGsu()->GetMemoryMappings()->GetAbsoluteAddress(relAddress.Address);
	} else if(relAddress.Type == SnesMemoryType::Cx4Memory) {
		return _cart->GetCx4()->GetMemoryMappings()->GetAbsoluteAddress(relAddress.Address);
	} else if(relAddress.Type == SnesMemoryType::NecDspMemory) {
		return { relAddress.Address, SnesMemoryType::DspProgramRom };
	} else if(relAddress.Type == SnesMemoryType::GameboyMemory) {
		return _cart->GetGameboy()->GetAbsoluteAddress(relAddress.Address);
	}

	throw std::runtime_error("Unsupported address type");
}

AddressInfo Debugger::GetRelativeAddress(AddressInfo absAddress, CpuType cpuType)
{
	MemoryMappings* mappings = nullptr;
	switch(cpuType) {
		case CpuType::Cpu: mappings = _memoryManager->GetMemoryMappings(); break;
		case CpuType::Spc: break;
		case CpuType::NecDsp: break;
		case CpuType::Sa1: mappings = _cart->GetSa1()->GetMemoryMappings(); break;
		case CpuType::Gsu: mappings = _cart->GetGsu()->GetMemoryMappings(); break;
		case CpuType::Cx4: mappings = _cart->GetCx4()->GetMemoryMappings(); break;
		case CpuType::Gameboy: break;
	}

	switch(absAddress.Type) {
		case SnesMemoryType::PrgRom:
		case SnesMemoryType::WorkRam:
		case SnesMemoryType::SaveRam: {
			if(!mappings) {
				throw std::runtime_error("Unsupported cpu type");
			}

			uint8_t startBank = 0;
			//Try to find a mirror close to where the PC is
			if(cpuType == CpuType::Cpu) {
				if(absAddress.Type == SnesMemoryType::WorkRam) {
					startBank = 0x7E;
				} else {
					startBank = _cpu->GetState().K & 0xC0;
				}
			} else if(cpuType == CpuType::Sa1) {
				startBank = (_cart->GetSa1()->GetCpuState().K & 0xC0);
			} else if(cpuType == CpuType::Gsu) {
				startBank = (_cart->GetGsu()->GetState().ProgramBank & 0xC0);
			}

			return { mappings->GetRelativeAddress(absAddress, startBank), DebugUtilities::GetCpuMemoryType(cpuType) };
		}

		case SnesMemoryType::SpcRam:
		case SnesMemoryType::SpcRom:
			return { _spc->GetRelativeAddress(absAddress), SnesMemoryType::SpcMemory };
		
		case SnesMemoryType::GbPrgRom:
		case SnesMemoryType::GbWorkRam:
		case SnesMemoryType::GbCartRam:
		case SnesMemoryType::GbHighRam:
		case SnesMemoryType::GbBootRom:
			return { _cart->GetGameboy()->GetRelativeAddress(absAddress), SnesMemoryType::GameboyMemory };

		case SnesMemoryType::DspProgramRom:
			return { absAddress.Address, SnesMemoryType::NecDspMemory };

		case SnesMemoryType::Register:
			return { absAddress.Address & 0xFFFF, SnesMemoryType::Register };

		default: 
			return { -1, SnesMemoryType::Register };
	}
}

void Debugger::SetCdlData(CpuType cpuType, uint8_t *cdlData, uint32_t length)
{
	DebugBreakHelper helper(this);
	GetCodeDataLogger(cpuType)->SetCdlData(cdlData, length);
	RefreshCodeCache();
}

void Debugger::MarkBytesAs(CpuType cpuType, uint32_t start, uint32_t end, uint8_t flags)
{
	DebugBreakHelper helper(this);
	GetCodeDataLogger(cpuType)->MarkBytesAs(start, end, flags);
	RefreshCodeCache();
}

void Debugger::RefreshCodeCache()
{
	_disassembler->ResetPrgCache();
	RebuildPrgCache(CpuType::Cpu);
	RebuildPrgCache(CpuType::Gameboy);
}

void Debugger::RebuildPrgCache(CpuType cpuType)
{
	shared_ptr<CodeDataLogger> cdl = GetCodeDataLogger(cpuType);
	if(!cdl) {
		return;
	}

	uint32_t prgRomSize = cdl->GetPrgSize();
	AddressInfo addrInfo;
	addrInfo.Type = cpuType == CpuType::Gameboy ? SnesMemoryType::GbPrgRom : SnesMemoryType::PrgRom;

	for(uint32_t i = 0; i < prgRomSize; i++) {
		if(cdl->IsCode(i)) {
			addrInfo.Address = (int32_t)i;
			i += _disassembler->BuildCache(addrInfo, cdl->GetCpuFlags(i), cdl->GetCpuType(i)) - 1;
		}
	}
}

void Debugger::GetCdlData(uint32_t offset, uint32_t length, SnesMemoryType memoryType, uint8_t* cdlData)
{
	CpuType cpuType = DebugUtilities::ToCpuType(memoryType);
	shared_ptr<CodeDataLogger> cdl = GetCodeDataLogger(cpuType);
	if(memoryType == SnesMemoryType::PrgRom || memoryType == SnesMemoryType::GbPrgRom) {
		cdl->GetCdlData(offset, length, cdlData);
	} else {
		SnesMemoryType prgType = _gbDebugger ? SnesMemoryType::GbPrgRom : SnesMemoryType::PrgRom;

		AddressInfo relAddress;
		relAddress.Type = memoryType;
		for(uint32_t i = 0; i < length; i++) {
			relAddress.Address = offset + i;
			AddressInfo info = GetAbsoluteAddress(relAddress);
			cdlData[i] = info.Type == prgType ? cdl->GetFlags(info.Address) : 0;
		}
	}
}

void Debugger::SetBreakpoints(Breakpoint breakpoints[], uint32_t length)
{
	_cpuDebugger->GetBreakpointManager()->SetBreakpoints(breakpoints, length);
	_spcDebugger->GetBreakpointManager()->SetBreakpoints(breakpoints, length);
	if(_gsuDebugger) {
		_gsuDebugger->GetBreakpointManager()->SetBreakpoints(breakpoints, length);
	}
	if(_sa1Debugger) {
		_sa1Debugger->GetBreakpointManager()->SetBreakpoints(breakpoints, length);
	}
	if(_necDspDebugger) {
		_necDspDebugger->GetBreakpointManager()->SetBreakpoints(breakpoints, length);
	}
	if(_cx4Debugger) {
		_cx4Debugger->GetBreakpointManager()->SetBreakpoints(breakpoints, length);
	}
	if(_gbDebugger) {
		_gbDebugger->GetBreakpointManager()->SetBreakpoints(breakpoints, length);
	}
}

void Debugger::GetBreakpoints(CpuType cpuType, Breakpoint* breakpoints, int& execs, int& reads, int& writes)
{
	switch (cpuType) {
	case CpuType::Cpu: return _cpuDebugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
	case CpuType::Spc: return _spcDebugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
	case CpuType::Gsu: {
		if (_gsuDebugger) {
			return _gsuDebugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
		}
	} break;
	case CpuType::Sa1: {
		if (_sa1Debugger) {
			return _sa1Debugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
		}
	} break;
	case CpuType::NecDsp: {
		if (_necDspDebugger) {
			return _necDspDebugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
		}
	} break;
	case CpuType::Cx4: {
		if (_cx4Debugger) {
			return _cx4Debugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
		}
	} break;
	case CpuType::Gameboy: {
		if (_gbDebugger) {
			return _gbDebugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
		}
	} break;
	}
}

void Debugger::Log(string message)
{
	auto lock = _logLock.AcquireSafe();
	if(_debuggerLog.size() >= 1000) {
		_debuggerLog.pop_front();
	}
	_debuggerLog.push_back(message);
}

string Debugger::GetLog()
{
	auto lock = _logLock.AcquireSafe();
	stringstream ss;
	for(string& msg : _debuggerLog) {
		ss << msg << "\n";
	}
	return ss.str();
}

void Debugger::SaveRomToDisk(string filename, bool saveAsIps, CdlStripOption stripOption)
{
	vector<uint8_t> output;
	RomInfo romInfo = _cart->GetRomInfo();
	Gameboy* gb = _cart->GetGameboy();

	vector<uint8_t> rom;
	if(gb) {
		uint8_t* prgRom = gb->DebugGetMemory(SnesMemoryType::GbPrgRom);
		uint32_t prgRomSize = gb->DebugGetMemorySize(SnesMemoryType::GbPrgRom);
		rom = vector<uint8_t>(prgRom, prgRom+prgRomSize);
	} else {
		rom = vector<uint8_t>(_cart->DebugGetPrgRom(), _cart->DebugGetPrgRom() + _cart->DebugGetPrgRomSize());
	}

	if(saveAsIps) {
		output = IpsPatcher::CreatePatch(_cart->GetOriginalPrgRom(), rom);
	} else {
		if(stripOption != CdlStripOption::StripNone) {
			GetCodeDataLogger(gb ? CpuType::Gameboy : CpuType::Cpu)->StripData(rom.data(), stripOption);

			//Preserve rom header regardless of CDL file contents
			if(gb) {
				GameboyHeader header = gb->GetHeader();
				memcpy(rom.data() + romInfo.HeaderOffset, &header, sizeof(GameboyHeader));
			} else {
				memcpy(rom.data() + romInfo.HeaderOffset, &romInfo.Header, sizeof(SnesCartInformation));
			}
		}
		output = rom;
	}

	ofstream file(filename, ios::out | ios::binary);
	if(file) {
		file.write((char*)output.data(), output.size());
		file.close();
	}
}

shared_ptr<TraceLogger> Debugger::GetTraceLogger()
{
	return _traceLogger;
}

shared_ptr<MemoryDumper> Debugger::GetMemoryDumper()
{
	return _memoryDumper;
}

shared_ptr<MemoryAccessCounter> Debugger::GetMemoryAccessCounter()
{
	return _memoryAccessCounter;
}

shared_ptr<CodeDataLogger> Debugger::GetCodeDataLogger(CpuType cpuType)
{
	if(cpuType == CpuType::Gameboy) {
		return _gbDebugger ? _gbDebugger->GetCodeDataLogger() : nullptr;
	} else {
		return _codeDataLogger;
	}
}

shared_ptr<Disassembler> Debugger::GetDisassembler()
{
	return _disassembler;
}

shared_ptr<PpuTools> Debugger::GetPpuTools()
{
	return _ppuTools;
}

shared_ptr<IEventManager> Debugger::GetEventManager(CpuType cpuType)
{
	if(cpuType == CpuType::Gameboy) {
		return std::dynamic_pointer_cast<IEventManager>(_gbDebugger->GetEventManager());
	} else {
		return std::dynamic_pointer_cast<IEventManager>(_cpuDebugger->GetEventManager());
	}
}

shared_ptr<LabelManager> Debugger::GetLabelManager()
{
	return _labelManager;
}

shared_ptr<ScriptManager> Debugger::GetScriptManager()
{
	return _scriptManager;
}

shared_ptr<CallstackManager> Debugger::GetCallstackManager(CpuType cpuType)
{
	switch(cpuType) {
		case CpuType::Cpu: return _cpuDebugger->GetCallstackManager();
		case CpuType::Spc: return _spcDebugger->GetCallstackManager();
		case CpuType::Sa1: return _sa1Debugger->GetCallstackManager();
		case CpuType::Gameboy: return _gbDebugger->GetCallstackManager();

		case CpuType::Gsu:
		case CpuType::NecDsp:
		case CpuType::Cx4:
			break;
	}
	throw std::runtime_error("GetCallstackManager() - Unsupported CPU type");
}

shared_ptr<Console> Debugger::GetConsole()
{
	return _console;
}

shared_ptr<IAssembler> Debugger::GetAssembler(CpuType cpuType)
{
	if(cpuType == CpuType::Gameboy) {
		return std::dynamic_pointer_cast<IAssembler>(_gbDebugger->GetAssembler());
	} else {
		return std::dynamic_pointer_cast<IAssembler>(_cpuDebugger->GetAssembler());
	}
}

template void Debugger::ProcessMemoryRead<CpuType::Cpu>(uint32_t addr, uint8_t value, MemoryOperationType opType);
template void Debugger::ProcessMemoryRead<CpuType::Sa1>(uint32_t addr, uint8_t value, MemoryOperationType opType);
template void Debugger::ProcessMemoryRead<CpuType::Spc>(uint32_t addr, uint8_t value, MemoryOperationType opType);
template void Debugger::ProcessMemoryRead<CpuType::Gsu>(uint32_t addr, uint8_t value, MemoryOperationType opType);
template void Debugger::ProcessMemoryRead<CpuType::NecDsp>(uint32_t addr, uint8_t value, MemoryOperationType opType);
template void Debugger::ProcessMemoryRead<CpuType::Cx4>(uint32_t addr, uint8_t value, MemoryOperationType opType);
template void Debugger::ProcessMemoryRead<CpuType::Gameboy>(uint32_t addr, uint8_t value, MemoryOperationType opType);

template void Debugger::ProcessMemoryWrite<CpuType::Cpu>(uint32_t addr, uint8_t value, MemoryOperationType opType);
template void Debugger::ProcessMemoryWrite<CpuType::Sa1>(uint32_t addr, uint8_t value, MemoryOperationType opType);
template void Debugger::ProcessMemoryWrite<CpuType::Spc>(uint32_t addr, uint8_t value, MemoryOperationType opType);
template void Debugger::ProcessMemoryWrite<CpuType::Gsu>(uint32_t addr, uint8_t value, MemoryOperationType opType);
template void Debugger::ProcessMemoryWrite<CpuType::NecDsp>(uint32_t addr, uint8_t value, MemoryOperationType opType);
template void Debugger::ProcessMemoryWrite<CpuType::Cx4>(uint32_t addr, uint8_t value, MemoryOperationType opType);
template void Debugger::ProcessMemoryWrite<CpuType::Gameboy>(uint32_t addr, uint8_t value, MemoryOperationType opType);

template void Debugger::ProcessInterrupt<CpuType::Cpu>(uint32_t originalPc, uint32_t currentPc, bool forNmi);
template void Debugger::ProcessInterrupt<CpuType::Sa1>(uint32_t originalPc, uint32_t currentPc, bool forNmi);
template void Debugger::ProcessInterrupt<CpuType::Gameboy>(uint32_t originalPc, uint32_t currentPc, bool forNmi);

template void Debugger::ProcessPpuCycle<CpuType::Cpu>();
template void Debugger::ProcessPpuCycle<CpuType::Gameboy>();