extern crate libc;
extern crate glib;
extern crate gobject_sys as gobject_ffi;
extern crate glib_sys as glib_ffi;
use std::ffi::CString;
use std::ptr;
use glib::translate::*;
use glib::Value;
use gobject_ffi::G_TYPE_POINTER;

#[derive(Debug)]
pub struct GeglBuffer(*mut libc::c_void);

#[repr(C)]
#[derive(Debug)]
struct GeglRectangle {
    x: i32,
    y: i32,
    width: i32,
    height: i32,
}

impl GeglBuffer {
    pub fn new() -> GeglBuffer {
        GeglBuffer(ptr::null_mut())
        // let mut bounds = GeglRectangle{x: 0, y: 0, width: 32, height: 32};
        // GeglBuffer(unsafe {
        //     gegl_buffer_new(&mut bounds as *mut _ as *mut libc::c_void,
        //                     ptr::null_mut()) })
    }

    pub fn get_value(&self) -> Value {
        unsafe {
            let mut ret = Value::uninitialized();
            gobject_ffi::g_value_init(ret.to_glib_none_mut().0, G_TYPE_POINTER);
            gobject_ffi::g_value_set_pointer(ret.to_glib_none_mut().0,
                                             self.0 as *mut libc::c_void);
            ret
        }
    }

    pub fn get_value_ptr(&mut self) -> Value {
        unsafe {
            let mut ret = Value::uninitialized();
            gobject_ffi::g_value_init(ret.to_glib_none_mut().0, G_TYPE_POINTER);
            gobject_ffi::g_value_set_pointer(ret.to_glib_none_mut().0,
                                             &mut self.0 as *mut _ as *mut libc::c_void);
            ret
        }
    }
}

impl Drop for GeglBuffer {
    fn drop(&mut self) {
        println!("Dropping geglbuffer: {:?}", self.0);
        unsafe { g_object_unref(self.0); }
        println!("Dropped");
    }
}

#[link(name="gegl-0.3")]
extern {
    fn gegl_init(argc: *mut i32, argv: *mut *mut libc::c_char);
    fn gegl_node_new() -> *mut libc::c_void;
    fn gegl_node_create_child(parent: *mut libc::c_void,
                              operation: *const libc::c_char)
                              -> *mut libc::c_void;
    fn gegl_node_set_property(node: *mut libc::c_void,
                              property_name: *const libc::c_char,
                              value: *const libc::c_void);
    fn gegl_node_link(source: *mut libc::c_void,
                      sink: *mut libc::c_void);
    fn gegl_node_process(node: *mut libc::c_void);
    fn g_object_unref(node: *mut libc::c_void);
    fn gegl_exit();
    fn gegl_buffer_new(extent: *mut libc::c_void, format: *mut libc::c_void)
        -> *mut libc::c_void;
    fn gegl_buffer_get_extent(buffer: *const libc::c_void) ->
        *const GeglRectangle;
}

fn main() {
    let mut graph : *mut libc::c_void;
    unsafe {
        let mut argc : i32 = 0;
        gegl_init(&mut argc as *mut i32, ptr::null_mut());
        graph = gegl_node_new();
        let src = gegl_node_create_child(
            graph, CString::new("gegl:load").unwrap().as_ptr());
        gegl_node_set_property(
            src,
            CString::new("path").unwrap().as_ptr(),
            Value::from("/tmp/test.jpg").to_glib_none().0
                as *const libc::c_void);
        let sink = gegl_node_create_child(graph,
                                          CString::new("gegl:buffer-sink")
                                          .unwrap().as_ptr());
        let mut buffer = GeglBuffer::new();
        println!("before set property: {:?}", buffer);
        gegl_node_set_property(
            sink,
            CString::new("buffer").unwrap().as_ptr(),
            buffer.get_value_ptr().to_glib_none().0 as *mut libc::c_void);

        println!("before processing: {:?}", buffer);
        gegl_node_link(src, sink);
        gegl_node_process(sink);

        println!("before extent: {:?}", buffer);
        let extent = gegl_buffer_get_extent(buffer.0
                                            as *mut libc::c_void);
        println!("after extent: {:?}", buffer);
        println!("height: {:?}", (*extent).height);

        println!("got here");
    }
    unsafe {
        g_object_unref(graph);
        gegl_exit();
    }
}