// Copyright (c) 2025 taitep
// SPDX-License-Identifier: MIT
//
// This file is part of TRVE (https://gitea.taitep.se/taitep/trve)
// See LICENSE file in the project root for full license text.

use crate::{core::Core, decode::Instruction, exceptions::ExceptionType};

mod mem;

pub use mem::*;

pub fn add(core: &mut Core, instr: Instruction) -> Result<(), ExceptionType> {
    core.reg_write(
        instr.rd(),
        core.reg_read(instr.rs1())
            .wrapping_add(core.reg_read(instr.rs2())),
    );
    core.advance_pc();
    Ok(())
}

pub fn sub(core: &mut Core, instr: Instruction) -> Result<(), ExceptionType> {
    core.reg_write(
        instr.rd(),
        core.reg_read(instr.rs1())
            .wrapping_sub(core.reg_read(instr.rs2())),
    );
    core.advance_pc();
    Ok(())
}

pub fn addi(core: &mut Core, instr: Instruction) -> Result<(), ExceptionType> {
    core.reg_write(
        instr.rd(),
        core.reg_read(instr.rs1()).wrapping_add(instr.imm_i()),
    );
    core.advance_pc();
    Ok(())
}

pub fn addiw(core: &mut Core, instr: Instruction) -> Result<(), ExceptionType> {
    let res = core.reg_read(instr.rs1()).wrapping_add(instr.imm_i()) as i32;
    core.reg_write(instr.rd(), res as i64 as u64);
    core.advance_pc();
    Ok(())
}

pub fn and(core: &mut Core, instr: Instruction) -> Result<(), ExceptionType> {
    core.reg_write(
        instr.rd(),
        core.reg_read(instr.rs1()) & core.reg_read(instr.rs2()),
    );
    core.advance_pc();
    Ok(())
}

pub fn andi(core: &mut Core, instr: Instruction) -> Result<(), ExceptionType> {
    core.reg_write(instr.rd(), core.reg_read(instr.rs1()) & instr.imm_i());
    core.advance_pc();
    Ok(())
}

pub fn or(core: &mut Core, instr: Instruction) -> Result<(), ExceptionType> {
    core.reg_write(
        instr.rd(),
        core.reg_read(instr.rs1()) | core.reg_read(instr.rs2()),
    );
    core.advance_pc();
    Ok(())
}

pub fn slli(core: &mut Core, instr: Instruction) -> Result<(), ExceptionType> {
    core.reg_write(instr.rd(), core.reg_read(instr.rs1()) << instr.imm_shamt());
    core.advance_pc();
    Ok(())
}

pub fn srli(core: &mut Core, instr: Instruction) -> Result<(), ExceptionType> {
    core.reg_write(instr.rd(), core.reg_read(instr.rs1()) >> instr.imm_shamt());
    core.advance_pc();
    Ok(())
}

pub fn lui(core: &mut Core, instr: Instruction) -> Result<(), ExceptionType> {
    core.reg_write(instr.rd(), instr.imm_u());
    core.advance_pc();
    Ok(())
}

pub fn auipc(core: &mut Core, instr: Instruction) -> Result<(), ExceptionType> {
    core.reg_write(instr.rd(), core.pc.wrapping_add(instr.imm_u()));
    core.advance_pc();
    Ok(())
}

pub fn jal(core: &mut Core, instr: Instruction) -> Result<(), ExceptionType> {
    core.reg_write(instr.rd(), core.pc.wrapping_add(4));
    core.pc = core.pc.wrapping_add(instr.imm_j());
    Ok(())
}

pub fn jalr(core: &mut Core, instr: Instruction) -> Result<(), ExceptionType> {
    core.reg_write(instr.rd(), core.pc.wrapping_add(4));
    core.pc = core.reg_read(instr.rs1()).wrapping_add(instr.imm_i());
    Ok(())
}

macro_rules! instr_branch {
    ($name:ident, $cond:expr) => {
        pub fn $name(core: &mut Core, instr: Instruction) -> Result<(), ExceptionType> {
            let a = core.reg_read(instr.rs1());
            let b = core.reg_read(instr.rs2());
            if $cond(a, b) {
                core.pc = core.pc.wrapping_add(instr.imm_b());
            } else {
                core.advance_pc();
            }
            Ok(())
        }
    };
}
macro_rules! instr_branch_signed {
    ($name:ident, $cond:expr) => {
        instr_branch!($name, |a, b| $cond((a as i64), (b as i64)));
    };
}

instr_branch!(beq, |a, b| a == b);
instr_branch!(bne, |a, b| a != b);
instr_branch!(bltu, |a, b| a < b);
instr_branch!(bgeu, |a, b| a >= b);
instr_branch_signed!(blt, |a, b| a < b);
instr_branch_signed!(bge, |a, b| a >= b);