osiris-set-std 0.1.17

//! 0x01 Control operations (branch, thread, future, message, configuration)
//! * `0x0101` [jump]:`address`
//! * `0x0102` [call]:`address`
//! * `0x0103` return ([call_return])
//! * `0x0104` [goto] `direct:32`
//! * `0x0105` [gosub] `direct:32`
//! * `0x0108` loop:`counter_init` ([loop_init])
//! * `0x0109` [next] `direct:32`
//! * `0x010A` [goto_if]:`CMP` `direct:32`
//! * `0x010B` [gosub_if]:`CMP` `direct:32`
//! * `0x010C` [goto_check]:`checked` `direct:32`
//! * `0x010D` [gosub_check]:`checked` `direct:32`
//! * `0x010E` [skip_if]:`CMP`
//! * `0x010F` [skip_check]:`checked`
//! * `0x01FF` [halt]
//!
//!
//! * TODO 0x0170 FORK $target :
//!     invoke [Cpu] which `JUMP`s to `$target` with a new context instance,
//!     while the current [Cpu] continues with the next instruction.
//! * TODO 0x0180 PROMISE ?
//! * TODO 0x0181 RESOLVE ?
//! * TODO 0x0188 PRODUCE ?
//! * TODO 0x0187 CONSUME ?
//! * TODO ... MESSAGES
//! * TODO 0x01F0 CHANGE FREQUENCY
//!

use std::collections::HashMap;

use osiris_data::data::identification::Address;
use osiris_process::compare::Compare;
use osiris_process::operation::error::{OperationError, OperationResult};
use osiris_process::operation::{Operation, OperationSet};
use osiris_process::operation::scheme::{ArgumentScheme, ArgumentType, InstructionScheme, OperationId};
use osiris_process::processor::Cpu;

use crate::logic::FALSE;

pub const SET_MASK: u16 = 0x0100;

/// 0x0101
pub const JUMP: OperationId = OperationId::new(SET_MASK | 0x01);

/// 0x0102
pub const CALL: OperationId = OperationId::new(SET_MASK | 0x02);

/// 0x0103
pub const CALL_RETURN: OperationId = OperationId::new(SET_MASK | 0x03);

/// 0x0104
pub const GOTO: OperationId = OperationId::new(SET_MASK | 0x04);

/// 0x0105
pub const GOSUB: OperationId = OperationId::new(SET_MASK | 0x05);

/// 0x0108
pub const LOOP: OperationId = OperationId::new(SET_MASK | 0x08);

/// 0x0109
pub const NEXT: OperationId = OperationId::new(SET_MASK | 0x09);

/// 0x010A
pub const GOTO_IF: OperationId = OperationId::new(SET_MASK | 0x0A);

/// 0x010B
pub const GOSUB_IF: OperationId = OperationId::new(SET_MASK | 0x0B);

/// 0x010C
pub const GOTO_CHECK: OperationId = OperationId::new(SET_MASK | 0x0C);

/// 0x010D
pub const GOSUB_CHECK: OperationId = OperationId::new(SET_MASK | 0x0D);

/// 0x010E
pub const SKIP_IF: OperationId = OperationId::new(SET_MASK | 0x0E);

/// 0x010F
pub const SKIP_CHECK: OperationId = OperationId::new(SET_MASK | 0x0F);

/// 0x01FF
pub const HALT: OperationId = OperationId::new(SET_MASK | 0xFF);

fn _jump(cpu: &mut Cpu, address: Address) -> OperationResult<()> {
    match cpu.point_instruction(address) {
        Ok(_) => Ok(()),
        Err(err) => Err(OperationError::MemoryError(err)),
    }
}

fn _goto(cpu: &mut Cpu, current: Address, target: u32) -> OperationResult<()> {
    _jump(cpu, Address::new(0xFFFFFFFF_00000000 & current.to_u64() | target as u64))
}

/// # `0x0101` [jump]:`address`
///
/// ## Target
///  - The register containing the target address in memory.
///
/// ## Arguments
///  - None.
///
/// ## Operation
///  - `current = r:target`
///
/// ## Errors
///  - [OperationError::InvalidArgumentType] if the provided argument is not an [ArgumentScheme::NoArgument],
///  - [OperationError::MemoryError] if a memory error occurs.
pub fn jump(cpu: &mut Cpu, scheme: InstructionScheme) -> OperationResult<()> {
    scheme.argument.get_no_argument()?;
    _jump(cpu, Address::from_word(cpu.bank_get(scheme.target)))
}

/// # `0x0102` [call]:`address`
///
/// ## Target
///  - The register containing the target address in memory.
///
/// ## Arguments
///  - None.
///
/// ## Operation
///  - `push:current`
///  - `jump:target`
///
/// ## Errors
///  - [OperationError::InvalidArgumentType] if the provided argument is not an [ArgumentScheme::NoArgument],
///  - [OperationError::MemoryError] if a memory error occurs.
pub fn call(cpu: &mut Cpu, scheme: InstructionScheme) -> OperationResult<()> {
    cpu.stack_push(cpu.state.current.to_word());
    jump(cpu, scheme)
}

/// * `0x0103` return ([call_return])
///
/// ## Target
///  - None
///
/// ## Arguments
///  - None.
///
/// ## Operation
///  - `current = pop`
///
/// ## Errors
///  - [OperationError::InvalidArgumentType] if the provided argument is not an [ArgumentScheme::NoArgument],
///  - [OperationError::CannotReturnFromEmptyStack] if the stack is empty,
///  - [OperationError::MemoryError] if a memory error occurs.
pub fn call_return(cpu: &mut Cpu, scheme: InstructionScheme) -> OperationResult<()> {
    scheme.argument.get_no_argument()?;
    match cpu.stack_pop() {
        None => { Err(OperationError::CannotReturnFromEmptyStack) }
        Some(addr) => {
            let result = _jump(cpu, Address::from_word(addr));
            cpu.state.current.increment();
            result
        }
    }
}

/// # `0x0104` [goto] `direct:32`
///
/// Performs a short jump (offset is 32 bits long).
///
/// ## Target
///  - None.
///
/// ## Arguments
///  - direct:**32**
///
/// ## Operation
///  - `current = (current.top) | direct`
///
/// ## Errors
///  - [OperationError::InvalidArgumentType] if the provided argument is not an [ArgumentType::OneU32],
///  - [OperationError::MemoryError] if a memory error occurs.
pub fn goto(cpu: &mut Cpu, scheme: InstructionScheme) -> OperationResult<()> {
    let target = scheme.argument.get_one_u32()?;
    _goto(cpu, cpu.state.current, target)
}

/// # `0x0105` [gosub] `direct:32`
///
/// Performs a short call (offset is 32 bits long).
///
/// ## Target
///  - None.
///
/// ## Arguments
///  - direct:**32**
///
/// ## Operation
///  - `current = direct`
///
/// ## Errors
///  - [OperationError::InvalidArgumentType] if the provided argument is not an [ArgumentType::OneU32],
///  - [OperationError::MemoryError] if a memory error occurs.
pub fn gosub(cpu: &mut Cpu, scheme: InstructionScheme) -> OperationResult<()> {
    cpu.stack_push(cpu.state.current.to_word());
    goto(cpu, scheme)
}


/// * `0x0108` loop:`counter_init` ([loop_init])
///
/// ## Target
///  - The register holding the initial value
///
/// ## Arguments
///  - None.
///
/// ## Operation
///  - `counter = r:target`
///
/// ## Errors
///  - [OperationError::InvalidArgumentType] if the provided argument is not an [ArgumentScheme::NoArgument],
pub fn loop_init(cpu: &mut Cpu, scheme: InstructionScheme) -> OperationResult<()> {
    scheme.argument.get_no_argument()?;
    cpu.state.operation.counter = cpu.bank_get(scheme.target);
    cpu.debug("for", format!("{:016x}", cpu.state.operation.counter.to_u64()), "⚙️".to_string());
    Ok(())
}


/// * `0x0109` [next] `direct:32`
///
/// ## Target
///  - None.
///
/// ## Arguments
///  - direct:**32**
///
/// ## Operation
///  - `counter -= 1`
///  - `if counter >= 0 : current = direct`
///
/// ## Errors
///  - [OperationError::InvalidArgumentType] if the provided argument is not an [ArgumentType::OneU32],
pub fn next(cpu: &mut Cpu, scheme: InstructionScheme) -> OperationResult<()> {
    cpu.decrease_loop_counter();
    if cpu.state.operation.counter.to_u64() > 0 {
        goto(cpu, scheme)?;
    }
    Ok(())
}

fn fn_if(state: i64, operator: u16) -> OperationResult<bool> {
    let cmp_op = Compare::from(operator);
    match cmp_op {
        None => Err(OperationError::Panic(format!("Invalid argument for comparison : {}", operator)))?,
        Some(op) => Ok(op.is(state))
    }
}


/// # `0x010A` [goto_if]:`CMP` `direct:32`
///
/// Jumps to a target address if the last comparison corresponds the selected operator.
///
/// ## Target
///  - CMP : LT(<) / LE(<=) / NE(!=) / EQ(==) / GE(>=) / GT(>)
///
/// ## Arguments
///  - The address to jump to.
///
/// ## Errors
///  - [OperationError::InvalidArgumentType] if the provided argument is not an [ArgumentType::OneU32],
pub fn goto_if(cpu: &mut Cpu, scheme: InstructionScheme) -> OperationResult<()> {
    let target = scheme.argument.get_one_u32()?;
    let state = cpu.state.operation.compare;
    if fn_if(state, scheme.target.to_u16())? {
        _goto(cpu, cpu.state.current, target)
    } else { Ok(()) }
}

/// # `0x010B` [gosub_if]:`CMP` `direct:32`
///
/// Calls a procedure stored at the given address if the last comparison corresponds the selected operator.
///
/// ## Target
///  - CMP : LT(<) / LE(<=) / NE(!=) / EQ(==) / GE(>=) / GT(>)
///
/// ## Arguments
///  - The address to jump to.
///
/// ## Errors
///  - [OperationError::InvalidArgumentType] if the provided argument is not an [ArgumentType::OneU32],
pub fn gosub_if(cpu: &mut Cpu, scheme: InstructionScheme) -> OperationResult<()> {
    cpu.stack_push(cpu.state.current.to_word());
    goto_if(cpu, scheme)
}

/// # `0x010C` [goto_check]:`checked` `direct:32`
///
/// Skip the next instruction if the register is not FALSE.
///
/// ## Target
/// - The register to check.
///
/// ## Arguments
///  - The address to jump to.
///
/// ## Errors
///  - [OperationError::InvalidArgumentType] if the provided argument is not an [ArgumentType::OneU32],
pub fn goto_check(cpu: &mut Cpu, scheme: InstructionScheme) -> OperationResult<()> {
    let argument = scheme.argument.get_one_u32()?;
    if cpu.bank_get(scheme.target) != FALSE {
        _goto(cpu, cpu.state.current, argument)?;
    }
    Ok(())
}

/// # `0x010D` [gosub_check]:`checked` `direct:32`
///
/// Skip the next instruction if the register is not FALSE.
///
/// ## Target
/// - The register to check.
///
/// ## Arguments
///  - The address to jump to.
///
/// ## Errors
///  - [OperationError::InvalidArgumentType] if the provided argument is not an [ArgumentType::OneU32],
pub fn gosub_check(cpu: &mut Cpu, scheme: InstructionScheme) -> OperationResult<()> {
    let argument = scheme.argument.get_one_u32()?;
    if cpu.bank_get(scheme.target) != FALSE {
        cpu.stack_push(cpu.state.current.to_word());
        _goto(cpu, cpu.state.current, argument)?;
    }
    Ok(())
}

/// # `0x010E` [skip_if]:`CMP`
///
/// Jumps to a target address if the last comparison corresponds the selected operator.
///
/// ## Target
///  - CMP : LT(<) / LE(<=) / NE(!=) / EQ(==) / GE(>=) / GT(>)
///
/// ## Arguments
///  - None.
///
/// ## Errors
///  - [OperationError::InvalidArgumentType] if the provided argument is not an [ArgumentType::NoArgument],
pub fn skip_if(cpu: &mut Cpu, scheme: InstructionScheme) -> OperationResult<()> {
    scheme.argument.get_no_argument()?;
    let state = cpu.state.operation.compare;
    if fn_if(state, scheme.target.to_u16())? {
        cpu.state.flag_skip = true;
    }
    Ok(())
}

/// # `0x010F` [skip_check]:`checked`
///
/// Skip the next instruction if the register is not FALSE.
///
/// ## Target
/// - The register to check.
///
/// ## Arguments
///  - None.
///
/// ## Errors
///  - [OperationError::InvalidArgumentType] if the provided argument is not an [ArgumentScheme::NoArgument],
pub fn skip_check(cpu: &mut Cpu, scheme: InstructionScheme) -> OperationResult<()> {
    scheme.argument.get_no_argument()?;
    if cpu.bank_get(scheme.target) != FALSE {
        cpu.state.flag_skip = true;
    }
    Ok(())
}

/// * `0x01FF` [halt]
///
/// ## Target
///  - None.
///
/// ## Arguments
///  - None.
///
/// ## Operation
///  - `HALT_FLAG = true`
///
/// ## Errors
///  - [OperationError::InvalidArgumentType] if the provided argument is not an [ArgumentScheme::NoArgument],
pub fn halt(cpu: &mut Cpu, scheme: InstructionScheme) -> OperationResult<()> {
    scheme.argument.get_no_argument()?;
    cpu.halt();
    Ok(())
}

/// Returns control operations.
///
/// ## Operations
///
/// * `0x0101` [jump]:`address`
/// * `0x0102` [call]:`address`
/// * `0x0103` return ([call_return])
/// * `0x0104` [goto] `direct:32`
/// * `0x0105` [gosub] `direct:32`
/// * `0x0108` loop:`counter_init` ([loop_init])
/// * `0x0109` [next] `direct:32`
/// * `0x010A` [goto_if]:`CMP` `direct:32`
/// * `0x010B` [gosub_if]:`CMP` `direct:32`
/// * `0x010C` [goto_check]:`checked` `direct:32`
/// * `0x010D` [gosub_check]:`checked` `direct:32`
/// * `0x010E` [skip_if]:`CMP`
/// * `0x010F` [skip_check]:`checked`
/// * `0x01FF` [halt]
pub fn operation_set() -> OperationSet {
    let mut set: OperationSet = HashMap::new();
    set.insert(
        JUMP,
        Operation::new(JUMP, "jump".to_string(), true, ArgumentType::NoArgument, jump),
    );
    set.insert(
        CALL,
        Operation::new(CALL, "call".to_string(), true, ArgumentType::NoArgument, call),
    );
    set.insert(
        CALL_RETURN,
        Operation::new(CALL_RETURN, "return".to_string(), false, ArgumentType::NoArgument, call_return),
    );
    set.insert(
        GOTO,
        Operation::new(GOTO, "goto".to_string(), false, ArgumentType::OneU32, goto),
    );
    set.insert(
        GOSUB,
        Operation::new(GOSUB, "gosub".to_string(), false, ArgumentType::OneU32, gosub),
    );
    set.insert(
        LOOP,
        Operation::new(LOOP, "loop".to_string(), true, ArgumentType::NoArgument, loop_init),
    );
    set.insert(
        NEXT,
        Operation::new(NEXT, "next".to_string(), false, ArgumentType::OneU32, next),
    );
    set.insert(
        GOTO_IF,
        Operation::new(GOTO_IF, "goto-if".to_string(), true, ArgumentType::OneU32, goto_if),
    );
    set.insert(
        GOSUB_IF,
        Operation::new(GOSUB_IF, "gosub-if".to_string(), true, ArgumentType::OneU32, gosub_if),
    );
    set.insert(
        GOTO_CHECK,
        Operation::new(GOTO_CHECK, "goto-check".to_string(), true, ArgumentType::OneU32, goto_check),
    );
    set.insert(
        GOSUB_CHECK,
        Operation::new(GOSUB_CHECK, "gosub-check".to_string(), true, ArgumentType::OneU32, gosub_check),
    );
    set.insert(
        SKIP_IF,
        Operation::new(SKIP_IF, "skip-if".to_string(), true, ArgumentType::NoArgument, skip_if),
    );
    set.insert(
        SKIP_CHECK,
        Operation::new(SKIP_CHECK, "skip-check".to_string(), true, ArgumentType::NoArgument, skip_check),
    );
    set.insert(
        HALT,
        Operation::new(HALT, "halt".to_string(), false, ArgumentType::NoArgument, halt),
    );
    set
}