use crate::{
    containers::ByteSlice,
    macros::{wrap_clone, wrap_free, wrap_methods},
    mem::{heap_move_nonnull, heap_move_ok, heap_move_some, heap_remove},
};
use servicepoint::{
    Bitmap, BitmapCommand, CompressionCode, DataRef, DisplayBitVec, Grid,
    Origin, Packet,
};
use std::ptr::NonNull;

/// Creates a new [Bitmap] with the specified dimensions.
///
/// # Arguments
///
/// - `width`: size in pixels in x-direction
/// - `height`: size in pixels in y-direction
///
/// returns: [Bitmap] initialized to all pixels off, or NULL in case of an error.
///
/// # Errors
///
/// In the following cases, this function will return NULL:
///
/// - when the width is not dividable by 8
///
/// # Examples
///
/// ```C
/// Cp437Grid grid = sp_bitmap_new(8, 3);
/// sp_bitmap_fill(grid, true);
/// sp_bitmap_set(grid, 0, 0, false);
/// sp_bitmap_free(grid);
/// ```
#[no_mangle]
pub unsafe extern "C" fn sp_bitmap_new(
    width: usize,
    height: usize,
) -> *mut Bitmap {
    heap_move_some(Bitmap::new(width, height))
}

/// Creates a new [Bitmap] with a size matching the screen.
///
/// returns: [Bitmap] initialized to all pixels off.
#[no_mangle]
pub unsafe extern "C" fn sp_bitmap_new_max_sized() -> NonNull<Bitmap> {
    heap_move_nonnull(Bitmap::max_sized())
}

/// Loads a [Bitmap] with the specified dimensions from the provided data.
///
/// # Arguments
///
/// - `width`: size in pixels in x-direction
/// - `height`: size in pixels in y-direction
///
/// returns: [Bitmap] that contains a copy of the provided data, or NULL in case of an error.
#[no_mangle]
pub unsafe extern "C" fn sp_bitmap_load(
    width: usize,
    height: usize,
    data: ByteSlice,
) -> *mut Bitmap {
    let data = unsafe { data.as_slice() };
    heap_move_ok(Bitmap::load(width, height, data))
}

/// Tries to convert the BitVec to a Bitmap.
///
/// The provided BitVec gets consumed.
///
/// Returns NULL in case of error.
#[no_mangle]
pub unsafe extern "C" fn sp_bitmap_from_bitvec(
    width: usize,
    bitvec: NonNull<DisplayBitVec>,
) -> *mut Bitmap {
    let bitvec = unsafe { heap_remove(bitvec) };
    heap_move_ok(Bitmap::from_bitvec(width, bitvec))
}

wrap_clone!(sp_bitmap::Bitmap);
wrap_free!(sp_bitmap::Bitmap);

wrap_methods!(
    sp_bitmap::Bitmap;

    /// Gets 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) -> bool;

    /// Sets the value of the specified position.
    ///
    /// # Arguments
    ///
    /// - `x` and `y`: position of the cell
    /// - `value`: the value to write to the cell
    ///
    /// # Panics
    ///
    /// - when accessing `x` or `y` out of bounds
    mut fn set(x: usize, y: usize, value: bool);

    /// Sets the state of all pixels in the [Bitmap].
    ///
    /// # Arguments
    ///
    /// - `value`: the value to set all pixels to
    mut fn fill(value: bool);

    /// Gets the width in pixels.
    ref fn width() -> usize;

    /// Gets the height in pixels.
    ref fn height() -> usize;

    /// Gets an unsafe reference to the data of the [Bitmap] instance.
    ///
    /// The returned memory is valid for the lifetime of the bitmap.
    mut fn data_ref_mut() -> ByteSlice {

        return(slice) { unsafe { ByteSlice::from_slice(slice) } };
    };
);

/// Consumes the Bitmap and returns the contained BitVec.
#[no_mangle]
pub unsafe extern "C" fn sp_bitmap_into_bitvec(
    bitmap: NonNull<Bitmap>,
) -> NonNull<DisplayBitVec> {
    let bitmap = unsafe { heap_remove(bitmap) };
    heap_move_nonnull(bitmap.into())
}

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