use glib::Value;
use glib::translate::*;
use gegl_ffi as ffi;
use std::ptr;
use std::ffi::CString;
use std::ffi::CStr;
use libc;

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); }
    }
}

pub trait GeglOperations {
    fn load(&self, path: &str) -> GeglNode;
}

impl GeglOperations for GeglNode {
    fn load(&self, path: &str) -> GeglNode {
        let result = self.create_child("gegl:load");
        unsafe {
            ffi::gegl_node_set_property(
                result.0,
                CString::new("path").unwrap().as_ptr(),
                Value::from(path).to_glib_none().0
                    as *const libc::c_void);
        }
        result
    }
}

pub fn list_operations() -> Vec<String> {
    let mut num_operations: usize = 0;
    let mut result = vec!();
    unsafe {
        let operations =
            ffi::gegl_list_operations(&mut num_operations as *mut _);
        for i in 0..(num_operations as isize) {
            result.push(CStr::from_ptr(*operations.offset(i))
                        .to_string_lossy().to_string());
        }
        ffi::g_free(operations as *mut libc::c_void);
    }
    result
}

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

    #[test]
    fn implements_all_operations() {
        let context = GeglContext::new();
        // assert_eq!(Vec::<String>::new(), list_operations());
    }

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