#[macro_use] extern crate log;
#[macro_use(s)] extern crate ndarray;
mod visualhaar;
mod heatmap;


use std::slice;
use image;

use std::{ffi::CStr};
use libc::c_char;

static mut IMAGENR: i32 = 0;

#[no_mangle]
pub extern "C" fn test(x: i32) -> i32 {
    x * 2
}


/// partly inspired by https://bheisler.github.io/post/calling-rust-in-python/
#[no_mangle]
pub extern "C" fn classifier_new(s: *const  c_char)
                            -> *mut visualhaar::HaarClassifier {
    let c_str = unsafe {
        assert!(!s.is_null());

        CStr::from_ptr(s)
    };

    let filename = c_str.to_str().unwrap();

    println!("Using cascade file: {}", filename);
    let haar = visualhaar::HaarClassifier::from_xml(filename).unwrap();
    let boxed_haar = Box::new(haar);
    Box::into_raw(boxed_haar)
}


#[no_mangle]
pub extern "C" fn scan_image(haar: *mut visualhaar::HaarClassifier,
                            width: usize, height: usize,
                            input: *const u8,
                            buffer: *mut u8,
                            length: usize,
                            min_face_factor: usize,
                            debug: bool) {
    if haar.is_null() || input.is_null() || buffer.is_null() {
        return;
    }
    let haar = unsafe { Box::from_raw(haar) };
    // let input = unsafe { slice::from_raw_parts_mut(input, length) };
    let buffer = unsafe { slice::from_raw_parts_mut(buffer, length) };
    let input = unsafe { slice::from_raw_parts(input, length) };
    let input = Vec::from(input);


    let mut buf_img: image::ImageBuffer<image::Rgb<u8>, &mut [u8]> = image::ImageBuffer::from_raw(width as u32, height as u32, buffer).unwrap();
    let input_frame: image::ImageBuffer<image::Rgb<u8>, Vec<u8>> = image::ImageBuffer::from_raw(width as u32, height as u32, input).unwrap();

    // let frame = image::open("/home/ruben/Documents/Projecten/2020/rust/lena_orig.png").unwrap();
    // let input_frame = frame.as_rgb8().unwrap().clone();
 
    let hm = Some(heatmap::Heatmap::new(heatmap::ColorMaps::Plasma));
    // let hm = None;

    if debug {
        unsafe{
            IMAGENR+=1;
            let filename = format!("/tmp/last_frame{}.png",IMAGENR);
            println!("Saving debug! {}", filename);
            input_frame.save(filename);
        }
    }

    let image = haar.scan_image(input_frame, &hm,min_face_factor as u32).unwrap().dynamic_img;
    let rgb_img = image.to_rgb();
    // image.save("/home/ruben/Documents/Projecten/2020/rust/lena_orig-output-lib.png");
    info!("Scanning for faces took done");

    for x in 0..(width as u32){
        for y in 0..(height as u32){
            buf_img.put_pixel(x, y, rgb_img.get_pixel(x,y).clone());
        }
    }

    // buffer =6 image.to_rgb().into_raw();


        // haar.scan_image(input_frame, &hm);
        // raytracer::render_into(block, &*scene, &mut image);
    

    //Don't free the haar
    Box::into_raw(haar);
}