use std::{mem::transmute, net::{self, SocketAddr}, slice, sync::{Mutex, OnceLock}};

use openh264::decoder::Decoder;

#[no_mangle]
pub extern fn add(a: u64, b: u64) -> u64 {
    a + b
}

static DECODER: OnceLock<Mutex<Decoder>> = OnceLock::new();

#[no_mangle]
/// reset h264 decoder
///
/// call before opening new stream
pub extern fn reset_decoder() -> u64 {
    // calls constructor twice in the reset case, not big deal
    if let Err(_) = DECODER.set(Mutex::new(Decoder::new().unwrap())) {
        *DECODER.get().unwrap().lock().unwrap() = Decoder::new().unwrap();
    }

    0
}

#[no_mangle]
/// decode h264 packet of given length
///
/// returns 1 if the packet contained a new frame, otherwise 0
pub extern fn decode_h264(image: &mut u32, packet: &u8, length: u32) -> u64 {
    let decoder = DECODER.get_or_init(|| Mutex::new(Decoder::new().unwrap()));
    let mut decoder = decoder.lock().unwrap();

    let packet = unsafe {slice::from_raw_parts(packet, length as usize)};
    let image: &mut [u8; 4*320*240] = unsafe{transmute(image)};

    if let Ok(Some(frame)) = decoder.decode(packet) {
        frame.write_rgba8(image);
        return 1;
    }

    0
}

#[no_mangle]
pub extern fn blit_pattern(arr: &mut u32) -> u64 {
    let arr: &mut [u32; 320*240] = unsafe{transmute(arr)};
    let arr: &mut [[u32; 320];240] = unsafe{transmute(arr)};
    for x in 0..320 {
        for y in 0..240 {
            let color = y%256
                + (x%256) * 256;
            //*i = 0x00FF0000;
            arr[y][x] = color as u32;
        }
    }

    0
}

#[cfg(test)]
mod tests {
}