librsmsx 0.4.1

use std::collections::HashMap;

use sdl3::keyboard::Scancode;

const MSX_KEYS: [Scancode; 64] = [
    Scancode::_0,
    Scancode::_1,
    Scancode::_2,
    Scancode::_3,
    Scancode::_4,
    Scancode::_5,
    Scancode::_6,
    Scancode::_7,
    Scancode::_8,
    Scancode::_9,
    Scancode::A,
    Scancode::B,
    Scancode::Backspace,
    Scancode::C,
    Scancode::Comma,
    Scancode::D,
    Scancode::Delete,
    Scancode::Down,
    Scancode::E,
    Scancode::Equals,
    Scancode::F,
    Scancode::F1,
    Scancode::F11,
    Scancode::F11,
    Scancode::F2,
    Scancode::F3,
    Scancode::F4,
    Scancode::F5,
    Scancode::F8,
    Scancode::G,
    Scancode::H,
    Scancode::Home,
    Scancode::I,
    Scancode::Insert,
    Scancode::J,
    Scancode::K,
    Scancode::L,
    Scancode::LCtrl,
    Scancode::Left,
    Scancode::LeftBracket,
    Scancode::LShift,
    Scancode::M,
    Scancode::Minus,
    Scancode::N,
    Scancode::O,
    Scancode::P,
    Scancode::Period,
    Scancode::Q,
    Scancode::R,
    Scancode::Return,
    Scancode::Right,
    Scancode::RightBracket,
    Scancode::S,
    Scancode::Semicolon,
    Scancode::Slash,
    Scancode::Space,
    Scancode::T,
    Scancode::U,
    Scancode::Up,
    Scancode::V,
    Scancode::W,
    Scancode::X,
    Scancode::Y,
    Scancode::Z,
];

use sdl3::EventPump;

fn is_key_pressed(e: &sdl3::EventPump, scancode: Scancode) -> bool {
    e.keyboard_state().is_scancode_pressed(scancode)
}

pub struct KeyBuffer {
    buffer: HashMap<Scancode, bool>,
}

impl Default for KeyBuffer {
    fn default() -> Self {
        Self::new()
    }
}

impl KeyBuffer {
    pub fn new() -> Self {
        let mut buffer = HashMap::with_capacity(64);
        for code in MSX_KEYS {
            buffer.insert(code, false);
        }
        Self { buffer }
    }
    pub fn check(&mut self, event_pump: &EventPump) {
        for code in MSX_KEYS {
            self.buffer.insert(code, is_key_pressed(event_pump, code));
        }
    }
    pub fn is_key_down(&self, code: Scancode) -> bool {
        if self.buffer.contains_key(&code) {
            return *self.buffer.get(&code).unwrap();
        }
        false
    }
}
pub fn key_matrix(row: usize, key_buffer: &KeyBuffer) -> u8 {
    static KEYCODES_DATA: [&[Scancode]; 11] = [
        &[
            Scancode::_7,
            Scancode::_6,
            Scancode::_5,
            Scancode::_4,
            Scancode::_3,
            Scancode::_2,
            Scancode::_1,
            Scancode::_0,
        ],
        &[
            Scancode::Semicolon,
            Scancode::RightBracket,
            Scancode::LeftBracket,
            Scancode::F11,
            Scancode::Equals,
            Scancode::Minus,
            Scancode::_9,
            Scancode::_8,
        ],
        &[
            Scancode::B,
            Scancode::A,
            Scancode::F11,
            Scancode::Slash,
            Scancode::Period,
            Scancode::Comma,
            Scancode::F11,
            Scancode::F8,
        ],
        &[
            Scancode::J,
            Scancode::I,
            Scancode::H,
            Scancode::G,
            Scancode::F,
            Scancode::E,
            Scancode::D,
            Scancode::C,
        ],
        &[
            Scancode::R,
            Scancode::Q,
            Scancode::P,
            Scancode::O,
            Scancode::N,
            Scancode::M,
            Scancode::L,
            Scancode::K,
        ],
        &[
            Scancode::Z,
            Scancode::Y,
            Scancode::X,
            Scancode::W,
            Scancode::V,
            Scancode::U,
            Scancode::T,
            Scancode::S,
        ],
        &[
            Scancode::F3,
            Scancode::F2,
            Scancode::F1,
            Scancode::F11,
            Scancode::F11,
            Scancode::F11,
            Scancode::LCtrl,
            Scancode::LShift,
        ],
        &[
            Scancode::Return,
            Scancode::F11,
            Scancode::Backspace,
            Scancode::F11,
            Scancode::F11,
            Scancode::F11,
            Scancode::F5,
            Scancode::F4,
        ],
        &[
            Scancode::Right,
            Scancode::Down,
            Scancode::Up,
            Scancode::Left,
            Scancode::Delete,
            Scancode::Insert,
            Scancode::Home,
            Scancode::Space,
        ],
        &[
            Scancode::F11,
            Scancode::F11,
            Scancode::F11,
            Scancode::F11,
            Scancode::F11,
            Scancode::F11,
            Scancode::F11,
            Scancode::F11,
        ],
        &[
            Scancode::F11,
            Scancode::F11,
            Scancode::F11,
            Scancode::F11,
            Scancode::F11,
            Scancode::F11,
            Scancode::F11,
            Scancode::F11,
        ],
    ];

    let mut result = 0xff_u8;
    if row < 11 {
        for i in 0..8 {
            if key_buffer.is_key_down(KEYCODES_DATA[row][i]) {
                result &= !(1 << (7 - i));
            }
        }
    } else {
        log::error!("KeyMatrix: Tried to scan row > 10");
    }
    result
}