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;

pub struct GeglBuffer(*mut libc::c_void);

impl GeglBuffer {
    pub fn new() -> GeglBuffer {
        GeglBuffer(unsafe {
            gegl_buffer_new(ptr::null_mut(), 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);
            ret
        }
    }
}

impl Drop for GeglBuffer {
    fn drop(&mut self) {
        println!("Dropping geglbuffer");
        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 main() {
    unsafe {
        let mut argc : i32 = 0;
        gegl_init(&mut argc as *mut i32, ptr::null_mut());
        let 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(),
            // ptr::null_mut()
            Value::from("/tmp/test.jpg").to_glib_none().0
                as *const libc::c_void);
        // let sink = gegl_node_create_child(
        //     graph, CString::new("gegl:save").unwrap().as_ptr());
        // gegl_node_set_property(
        //     sink,
        //     CString::new("path").unwrap().as_ptr(),
        //     Value::from("/tmp/test-output.jpg").to_glib_none().0
        //         as *const libc::c_void);
        // gegl_node_link(src, sink);
        // let mut buffer : *mut libc::c_void = ptr::null_mut();
        let buffer = gegl_buffer_new(ptr::null_mut(), ptr::null_mut());
        let sink = gegl_node_create_child(graph,
                                          CString::new("gegl:buffer-sink")
                                          .unwrap().as_ptr());
        // gegl_node_set_property(
        //     sink,
        //     CString::new("buffer").unwrap().as_ptr(),
        //     Value::from(buffer).to_glib_none().0);
        {
            let buffer = GeglBuffer::new();
            println!("buffer: {:?}", buffer.get_value());
            gegl_node_set_property(
                sink,
                CString::new("buffer").unwrap().as_ptr(),
                buffer.get_value().to_glib_none().0 as *mut libc::c_void);

            gegl_node_link(src, sink);
            gegl_node_process(sink);
        }
        g_object_unref(graph);
        gegl_exit();
    }
}