use core::fmt::{self, Write};

use sc::syscall;

const STDIN: i32 = 0;
const STDOUT: i32 = 1;

pub fn write(msg: &str) {
    unsafe {
        syscall!(WRITE, STDOUT, msg.as_ptr(), msg.len());
    }
}

pub fn read(buf_ptr: *const u8, buf_len: usize) {
    unsafe {
        syscall!(READ, STDIN, buf_ptr, buf_len);
    }
}

pub struct Format<'a> {
    buf: &'a mut [u8],
    len: usize,
}

impl<'a> Format<'a> {
    pub fn new(buf: &'a mut [u8]) -> Self {
        Self { buf, len: 0 }
    }
}

impl<'a> fmt::Write for Format<'a> {
    fn write_str(&mut self, s: &str) -> fmt::Result {
        if self.len > self.buf.len() {
            return Err(fmt::Error);
        }
        let remaining_buf = &mut self.buf[self.len..];
        let bytes = s.as_bytes();
        let write_num = core::cmp::min(bytes.len(), remaining_buf.len());
        remaining_buf[..write_num].copy_from_slice(&bytes[..write_num]);
        self.len += bytes.len();
        if write_num < bytes.len() {
            return Err(fmt::Error);
        }

        Ok(())
    }
}

pub fn format(buf: &mut [u8], args: fmt::Arguments<'_>) {
    let mut f = Format::new(buf);
    f.write_fmt(args).unwrap();
}

pub fn format_str<'a>(buf: &'a mut [u8], args: fmt::Arguments<'_>) -> &'a str {
    let mut f = Format::new(buf);
    f.write_fmt(args).unwrap();
    str::from_utf8(buf).unwrap()
}

#[macro_export]
macro_rules! print {
    ($len:expr, $($args:tt)*) => {
        let mut buf = [0u8; $len];
        common::write(common::format_str(&mut buf, core::format_args!($($args)*)));
    };
}