/* SPDX-License-Identifier: Unlicense
 */

#include "m68k_debugging.hpp"
#include "musashi-m68k/m68k.h"
#include "utils.hpp"

#include <cstdlib>
#include <cassert>

static inline m68k_register_t ConvertRegisterId(M68KRegister register_id)
{
    switch (register_id) {
    case M68KRegister::kD0:
        return M68K_REG_D0;
    case M68KRegister::kD1:
        return M68K_REG_D1;
    case M68KRegister::kD2:
        return M68K_REG_D2;
    case M68KRegister::kD3:
        return M68K_REG_D3;
    case M68KRegister::kD4:
        return M68K_REG_D4;
    case M68KRegister::kD5:
        return M68K_REG_D5;
    case M68KRegister::kD6:
        return M68K_REG_D6;
    case M68KRegister::kD7:
        return M68K_REG_D7;
    case M68KRegister::kA0:
        return M68K_REG_A0;
    case M68KRegister::kA1:
        return M68K_REG_A1;
    case M68KRegister::kA2:
        return M68K_REG_A2;
    case M68KRegister::kA3:
        return M68K_REG_A3;
    case M68KRegister::kA4:
        return M68K_REG_A4;
    case M68KRegister::kA5:
        return M68K_REG_A5;
    case M68KRegister::kA6:
        return M68K_REG_A6;
    case M68KRegister::kA7:
        return M68K_REG_A7;
    case M68KRegister::kPS:
        return M68K_REG_SR;
    case M68KRegister::kPC:
        return M68K_REG_PC;
    case M68KRegister::kFP0:
    case M68KRegister::kFPC:
    case M68KRegister::kFPS:
    case M68KRegister::kFPI:
    case M68KRegister::kRegistersCount:
        assert(!"Unsupported register_id");
        break;
    }
    assert(!"Unknown register_id");
    UNREACHABLE();
}

uint32_t M68KDebuggingControl::GetRegister(M68KRegister register_id) const
{
    return m68k_get_reg(nullptr, ConvertRegisterId(register_id));
}

M68KCPUState M68KDebuggingControl::GetCPUState() const
{
    return M68KCPUState{
        static_cast<size_t>(M68KRegister::kPC) + 1,
        {
            GetRegister(M68KRegister::kD0),
            GetRegister(M68KRegister::kD1),
            GetRegister(M68KRegister::kD2),
            GetRegister(M68KRegister::kD3),
            GetRegister(M68KRegister::kD4),
            GetRegister(M68KRegister::kD5),
            GetRegister(M68KRegister::kD6),
            GetRegister(M68KRegister::kD7),
            GetRegister(M68KRegister::kA0),
            GetRegister(M68KRegister::kA1),
            GetRegister(M68KRegister::kA2),
            GetRegister(M68KRegister::kA3),
            GetRegister(M68KRegister::kA4),
            GetRegister(M68KRegister::kA5),
            GetRegister(M68KRegister::kA6),
            GetRegister(M68KRegister::kA7),
            GetRegister(M68KRegister::kPS),
            GetRegister(M68KRegister::kPC),
        },
    };
}

void M68KDebuggingControl::SetRegister(M68KRegister register_id, uint32_t value)
{
    return m68k_set_reg(ConvertRegisterId(register_id), value);
}

void M68KDebuggingControl::Reset()
{
    m68k_pulse_reset();
}

void M68KDebuggingControl::Continue()
{
    // TODO
    abort();
}

void M68KDebuggingControl::Pause()
{
    // TODO
    abort();
}

uint8_t M68KDebuggingControl::Read8(uint32_t address) const
{
    return static_cast<uint8_t>(m68k_read_memory_8(address & 0x00FFFFFF));
}

uint16_t M68KDebuggingControl::Read16(uint32_t address) const
{
    return static_cast<uint16_t>(m68k_read_memory_16(address & 0x00FFFFFF));
}

uint32_t M68KDebuggingControl::Read32(uint32_t address) const
{
    return static_cast<uint32_t>(m68k_read_memory_32(address & 0x00FFFFFF));
}

void M68KDebuggingControl::Write8(uint32_t address, uint8_t value)
{
    m68k_write_memory_8(address, value);
}

void M68KDebuggingControl::Write16(uint32_t address, uint16_t value)
{
    m68k_write_memory_16(address, value);
}

void M68KDebuggingControl::Write32(uint32_t address, uint32_t value)
{
    m68k_write_memory_32(address, value);
}