extern crate libc;

use gegl_ffi as ffi;
use std::ptr;
use std::ffi::CString;

pub struct GeglContext {
    _private: ()
}

unsafe fn unref<T>(object: *mut T) {
    ffi::g_object_unref(object as *mut libc::c_void);
}

impl GeglContext {
    pub fn new() -> GeglContext {
        unsafe { ffi::gegl_init(&mut 0, ptr::null_mut()) }
        GeglContext { _private: () }
    }

    pub fn new_node(&self) -> GeglNode {
        GeglNode(unsafe { ffi::gegl_node_new() })
    }
}

impl Drop for GeglContext {
    fn drop(&mut self) {
        unsafe { ffi::gegl_exit(); }
    }
}

pub struct GeglNode(*mut ffi::CGeglNode);

impl GeglNode {
    pub fn create_child(self, operation: &str) -> GeglNode {
        GeglNode(unsafe {
            let operation0 = CString::new(operation).unwrap();
            ffi::gegl_node_create_child(self.0, operation0.as_ptr())
        })
    }
}

impl Drop for GeglNode {
    fn drop(&mut self) {
        unsafe { unref(self.0); }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use gegl_ffi as ffi;

    #[test]
    fn can_create_nodes() {
        let context = GeglContext::new();
        let node = context.new_node();
        let node2 = context.new_node();
    }
}