/* generated by rust_qt_binding_generator */
use libc::{c_char, c_ushort, c_int};
use std::slice;
use std::char::decode_utf16;

use std::sync::Arc;
use std::sync::atomic::{AtomicPtr, Ordering};
use std::ptr::null;

use implementation::*;


pub enum QString {}

fn set_string_from_utf16(s: &mut String, str: *const c_ushort, len: c_int) {
    let utf16 = unsafe { slice::from_raw_parts(str, to_usize(len)) };
    let characters = decode_utf16(utf16.iter().cloned())
        .map(|r| r.unwrap());
    s.clear();
    s.extend(characters);
}



fn to_usize(n: c_int) -> usize {
    if n < 0 {
        panic!("Cannot cast {} to usize", n);
    }
    n as usize
}


fn to_c_int(n: usize) -> c_int {
    if n > c_int::max_value() as usize {
        panic!("Cannot cast {} to c_int", n);
    }
    n as c_int
}


pub struct GroupQObject {}

pub struct GroupEmitter {
    qobject: Arc<AtomicPtr<GroupQObject>>,
}

unsafe impl Send for GroupEmitter {}

impl GroupEmitter {
    /// Clone the emitter
    ///
    /// The emitter can only be cloned when it is mutable. The emitter calls
    /// into C++ code which may call into Rust again. If emmitting is possible
    /// from immutable structures, that might lead to access to a mutable
    /// reference. That is undefined behaviour and forbidden.
    pub fn clone(&mut self) -> GroupEmitter {
        GroupEmitter {
            qobject: self.qobject.clone(),
        }
    }
    fn clear(&self) {
        let n: *const GroupQObject = null();
        self.qobject.store(n as *mut GroupQObject, Ordering::SeqCst);
    }
}

pub trait GroupTrait {
    fn new(emit: GroupEmitter,
        person: Person) -> Self;
    fn emit(&mut self) -> &mut GroupEmitter;
    fn person(&self) -> &Person;
    fn person_mut(&mut self) -> &mut Person;
}

#[no_mangle]
pub extern "C" fn group_new(
    group: *mut GroupQObject,
    person: *mut PersonQObject,
    object: *mut InnerObjectQObject,
    object_description_changed: fn(*mut InnerObjectQObject),
) -> *mut Group {
    let object_emit = InnerObjectEmitter {
        qobject: Arc::new(AtomicPtr::new(object)),
        description_changed: object_description_changed,
    };
    let d_object = InnerObject::new(object_emit);
    let person_emit = PersonEmitter {
        qobject: Arc::new(AtomicPtr::new(person)),
    };
    let d_person = Person::new(person_emit,
        d_object);
    let group_emit = GroupEmitter {
        qobject: Arc::new(AtomicPtr::new(group)),
    };
    let d_group = Group::new(group_emit,
        d_person);
    Box::into_raw(Box::new(d_group))
}

#[no_mangle]
pub unsafe extern "C" fn group_free(ptr: *mut Group) {
    Box::from_raw(ptr).emit().clear();
}

#[no_mangle]
pub unsafe extern "C" fn group_person_get(ptr: *mut Group) -> *mut Person {
    (&mut *ptr).person_mut()
}

pub struct InnerObjectQObject {}

pub struct InnerObjectEmitter {
    qobject: Arc<AtomicPtr<InnerObjectQObject>>,
    description_changed: fn(*mut InnerObjectQObject),
}

unsafe impl Send for InnerObjectEmitter {}

impl InnerObjectEmitter {
    /// Clone the emitter
    ///
    /// The emitter can only be cloned when it is mutable. The emitter calls
    /// into C++ code which may call into Rust again. If emmitting is possible
    /// from immutable structures, that might lead to access to a mutable
    /// reference. That is undefined behaviour and forbidden.
    pub fn clone(&mut self) -> InnerObjectEmitter {
        InnerObjectEmitter {
            qobject: self.qobject.clone(),
            description_changed: self.description_changed,
        }
    }
    fn clear(&self) {
        let n: *const InnerObjectQObject = null();
        self.qobject.store(n as *mut InnerObjectQObject, Ordering::SeqCst);
    }
    pub fn description_changed(&mut self) {
        let ptr = self.qobject.load(Ordering::SeqCst);
        if !ptr.is_null() {
            (self.description_changed)(ptr);
        }
    }
}

pub trait InnerObjectTrait {
    fn new(emit: InnerObjectEmitter) -> Self;
    fn emit(&mut self) -> &mut InnerObjectEmitter;
    fn description(&self) -> &str;
    fn set_description(&mut self, value: String);
}

#[no_mangle]
pub extern "C" fn inner_object_new(
    inner_object: *mut InnerObjectQObject,
    inner_object_description_changed: fn(*mut InnerObjectQObject),
) -> *mut InnerObject {
    let inner_object_emit = InnerObjectEmitter {
        qobject: Arc::new(AtomicPtr::new(inner_object)),
        description_changed: inner_object_description_changed,
    };
    let d_inner_object = InnerObject::new(inner_object_emit);
    Box::into_raw(Box::new(d_inner_object))
}

#[no_mangle]
pub unsafe extern "C" fn inner_object_free(ptr: *mut InnerObject) {
    Box::from_raw(ptr).emit().clear();
}

#[no_mangle]
pub unsafe extern "C" fn inner_object_description_get(
    ptr: *const InnerObject,
    p: *mut QString,
    set: fn(*mut QString, *const c_char, c_int),
) {
    let o = &*ptr;
    let v = o.description();
    let s: *const c_char = v.as_ptr() as (*const c_char);
    set(p, s, to_c_int(v.len()));
}

#[no_mangle]
pub unsafe extern "C" fn inner_object_description_set(ptr: *mut InnerObject, v: *const c_ushort, len: c_int) {
    let o = &mut *ptr;
    let mut s = String::new();
    set_string_from_utf16(&mut s, v, len);
    o.set_description(s);
}

pub struct PersonQObject {}

pub struct PersonEmitter {
    qobject: Arc<AtomicPtr<PersonQObject>>,
}

unsafe impl Send for PersonEmitter {}

impl PersonEmitter {
    /// Clone the emitter
    ///
    /// The emitter can only be cloned when it is mutable. The emitter calls
    /// into C++ code which may call into Rust again. If emmitting is possible
    /// from immutable structures, that might lead to access to a mutable
    /// reference. That is undefined behaviour and forbidden.
    pub fn clone(&mut self) -> PersonEmitter {
        PersonEmitter {
            qobject: self.qobject.clone(),
        }
    }
    fn clear(&self) {
        let n: *const PersonQObject = null();
        self.qobject.store(n as *mut PersonQObject, Ordering::SeqCst);
    }
}

pub trait PersonTrait {
    fn new(emit: PersonEmitter,
        object: InnerObject) -> Self;
    fn emit(&mut self) -> &mut PersonEmitter;
    fn object(&self) -> &InnerObject;
    fn object_mut(&mut self) -> &mut InnerObject;
}

#[no_mangle]
pub extern "C" fn person_new(
    person: *mut PersonQObject,
    object: *mut InnerObjectQObject,
    object_description_changed: fn(*mut InnerObjectQObject),
) -> *mut Person {
    let object_emit = InnerObjectEmitter {
        qobject: Arc::new(AtomicPtr::new(object)),
        description_changed: object_description_changed,
    };
    let d_object = InnerObject::new(object_emit);
    let person_emit = PersonEmitter {
        qobject: Arc::new(AtomicPtr::new(person)),
    };
    let d_person = Person::new(person_emit,
        d_object);
    Box::into_raw(Box::new(d_person))
}

#[no_mangle]
pub unsafe extern "C" fn person_free(ptr: *mut Person) {
    Box::from_raw(ptr).emit().clear();
}

#[no_mangle]
pub unsafe extern "C" fn person_object_get(ptr: *mut Person) -> *mut InnerObject {
    (&mut *ptr).object_mut()
}