extern crate libc;

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

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