use crate::{
    containers::ByteSlice,
    macros::{wrap_clone, wrap_free, wrap_methods},
    mem::{heap_move_nonnull, heap_move_ok, heap_remove},
};
use servicepoint::{CharGrid, CharGridCommand, Grid, Origin, Packet};
use std::ptr::NonNull;

/// Creates a new [CharGrid] with the specified dimensions.
///
/// returns: [CharGrid] initialized to 0.
///
/// # Examples
///
/// ```C
/// CharGrid grid = sp_char_grid_new(4, 3);
/// sp_char_grid_fill(grid, '?');
/// sp_char_grid_set(grid, 0, 0, '!');
/// sp_char_grid_free(grid);
/// ```
#[no_mangle]
pub unsafe extern "C" fn sp_char_grid_new(
    width: usize,
    height: usize,
) -> NonNull<CharGrid> {
    heap_move_nonnull(CharGrid::new(width, height))
}

/// Loads a [CharGrid] with the specified dimensions from the provided data.
///
/// returns: new CharGrid or NULL in case of an error
#[no_mangle]
pub unsafe extern "C" fn sp_char_grid_load(
    width: usize,
    height: usize,
    data: ByteSlice,
) -> *mut CharGrid {
    let data = unsafe { data.as_slice() };
    heap_move_ok(CharGrid::load_utf8(width, height, data.to_vec()))
}

wrap_clone!(sp_char_grid::CharGrid);
wrap_free!(sp_char_grid::CharGrid);

wrap_methods!(
    sp_char_grid::CharGrid;
    
    /// Returns the current value at the specified position.
    ///
    /// # Arguments
    ///
    /// - `x` and `y`: position of the cell to read
    ///
    /// # Panics
    ///
    /// - when accessing `x` or `y` out of bounds
    ref fn get(x: usize, y: usize) -> u32;
    | char | char as u32;
    
    /// Sets the value of the specified position in the grid.
    ///
    /// # Arguments
    ///
    /// - `x` and `y`: position of the cell
    /// - `value`: the value to write to the cell
    ///
    /// returns: old value of the cell
    ///
    /// # Panics
    ///
    /// - when accessing `x` or `y` out of bounds
    /// - when providing values that cannot be converted to Rust's `char`.
    mut fn set(x: usize, y: usize, value: u32);
    let value = char::from_u32(value).unwrap();
    
    /// Sets the value of all cells in the grid.
    ///
    /// # Arguments
    ///
    /// - `value`: the value to set all cells to
    /// - when providing values that cannot be converted to Rust's `char`.
    mut fn fill(value: u32);
    let value = char::from_u32(value).unwrap();
    
    /// Gets the width of the grid.
    ref fn width() -> usize;
    
    /// Gets the height of the grid.
    ref fn height() -> usize;
);

/// Creates a [CharGridCommand] and immediately turns that into a [Packet].
///
/// The provided [CharGrid] gets consumed.
///
/// Returns NULL in case of an error.
#[no_mangle]
pub unsafe extern "C" fn sp_char_grid_into_packet(
    grid: NonNull<CharGrid>,
    x: usize,
    y: usize,
) -> *mut Packet {
    let grid = unsafe { heap_remove(grid) };
    heap_move_ok(Packet::try_from(CharGridCommand {
        grid,
        origin: Origin::new(x, y),
    }))
}