use std::{mem, ffi};
use libc::c_void;
use jack_sys::*;

use client::JackClient;

use error::ClientStatus;
use error::JackErr;

pub enum JackControl {
    Continue,
    Stop
}

impl JackControl {
    fn as_i32(&self) -> i32 {
        match *self {
            JackControl::Continue => 0,
            JackControl::Stop => -1
        }
    }
}   

pub trait JackHandler {
    fn activated<T: JackHandler>(&mut self, client: &mut JackClient<T>) {}
    fn thread_init(&mut self) {}
    fn shutdown(&mut self, status: ClientStatus, reason: &str) {}
    fn process(&mut self, n_frames:u32 ) -> JackControl {
        JackControl::Continue
    }
    fn freewheel(&mut self, is_freewheel_enabled: bool) {}
    fn buffer_size(&mut self, size: u32) -> JackControl
    {
        JackControl::Continue
    }
    fn sample_rate(&mut self, sample_rate: u32) -> JackControl
    {
        JackControl::Continue
    }
    fn client_registration(&mut self, name: &str, is_registered: bool) {}
    fn port_registration(&mut self, port_id: u32, is_registered:bool) {}
    fn port_rename(&mut self, port_id: u32, old_name: &str, new_name: &str) -> JackControl {
        JackControl::Continue
    }
    fn ports_connected(&mut self, port_ida: u32, port_idb: u32, are_connected: bool) {}

    fn graph_reorder(&mut self) -> JackControl {
        JackControl::Continue
    }

    fn xrun(&mut self) -> JackControl {
        JackControl::Continue
    }
    //fn latency(&mut self, mode: LatencyType) {}
}

unsafe fn from_void<'a, T: JackHandler>(ptr: *mut c_void) -> &'a mut T {
    if ptr.is_null() {
		panic!("Converting pointer in from_void failed!");
	}

	let obj_ptr: *mut T = mem::transmute(ptr);
    &mut *obj_ptr
}

extern "C" fn thread_init_callback<T: JackHandler>(data: *mut c_void) {
    let obj: &mut T = unsafe { from_void(data) };
    obj.thread_init()
}

extern "C" fn shutdown<T: JackHandler>(code: jack_status_t, reason: *const i8, data: *mut c_void) {
    let obj: &mut T = unsafe { from_void(data) };
    let reason_str = unsafe {
        let cstr = ffi::CStr::from_ptr(reason);
        match cstr.to_str() {
            Ok(s) => s,
            Err(_) => "Failed to interpret error.",
        }
    };

    obj.shutdown(ClientStatus(code), reason_str)
}

extern "C" fn process<T: JackHandler>(n_frames: u32, data: *mut c_void) -> i32 {
    let obj: &mut T = unsafe { from_void(data) };
    obj.process(n_frames).as_i32()
}

extern "C" fn freewheel<T: JackHandler>(starting: i32, data: *mut c_void) {
    let obj: &mut T = unsafe { from_void(data) };
    let is_starting = match starting {
        0 => false,
        _ => true,
    };
    obj.freewheel(is_starting)
}

extern "C" fn buffer_size<T: JackHandler>(n_frames: u32, data: *mut c_void) -> i32 {
    let obj: &mut T = unsafe { from_void(data) };
    obj.buffer_size(n_frames).as_i32()
}

extern "C" fn sample_rate<T: JackHandler>(n_frames: u32, data: *mut c_void) -> i32 {
    let obj: &mut T = unsafe { from_void(data) };
    obj.sample_rate(n_frames).as_i32()
}

extern "C" fn client_registration<T: JackHandler>(name: *const i8, register: i32, data: *mut c_void) {
    let obj: &mut T = unsafe { from_void(data) };
    let name = unsafe { ffi::CStr::from_ptr(name).to_str().unwrap() };
    let register = match register {
        0 => false,
        _ => true,
    };
    obj.client_registration(name, register)
}

extern "C" fn port_registration<T: JackHandler>(port_id: u32, register: i32, data: *mut c_void) {
    let obj: &mut T = unsafe { from_void(data) };
    let register = match register {
        0 => false,
        _ => true,
    };
    obj.port_registration(port_id, register)
}

#[allow(dead_code)] // TODO: remove once it can be registered
extern "C" fn port_rename<T: JackHandler>(port_id: u32, old_name: *const i8, new_name: *const i8, data: *mut c_void) -> i32 {
    let obj: &mut T = unsafe { from_void(data) };
    let old_name = unsafe { ffi::CStr::from_ptr(old_name).to_str().unwrap() };
    let new_name = unsafe { ffi::CStr::from_ptr(new_name).to_str().unwrap() };
    obj.port_rename(port_id, old_name, new_name).as_i32()
}

extern "C" fn port_connect<T: JackHandler>(port_id_a: u32,
                                           port_id_b: u32,
                                           connect: i32,
                                           data: *mut c_void) {
    let obj: &mut T = unsafe { from_void(data) };
    let are_connected = match connect {
        0 => false,
        _ => true,
    };
    obj.ports_connected(port_id_a, port_id_b, are_connected)
}

extern "C" fn graph_order<T: JackHandler>(data: *mut c_void) -> i32 {
    let obj: &mut T = unsafe { from_void(data) };
    obj.graph_reorder().as_i32()
}

extern "C" fn xrun<T: JackHandler>(data: *mut c_void) -> i32 {
    let obj: &mut T = unsafe { from_void(data) };
    obj.xrun().as_i32()
}

/*extern "C" fn latency<T: JackHandler>(mode: j::jack_latency_callback_mode_t, data: *mut c_void) {
    let obj: &mut T = unsafe { from_void(data) };
    let mode = match mode {
        j::JackCaptureLatency => LatencyType::Capture,
        j::JackPlaybackLatency => LatencyType::Playback,
        _ => unreachable!(),
    };
    obj.latency(mode)
}*/

/// Clears the callbacks registered to `client`.
///
/// Returns `Err(JackErr::CallbackDeregistrationError)` on failure.
///
/// # Unsafe
/// * Uses ffi calls, be careful.
///
/// # TODO
/// * Implement correctly. Freezes on my system.
pub unsafe fn clear_callbacks(_client: *mut jack_client_t) -> Result<(), JackErr> {
    // j::jack_set_thread_init_callback(client, None, ptr::null_mut());
    // j::jack_set_process_callback(client, None, ptr::null_mut());
    Ok(())
}

/// Registers methods from `handler` to be used by Jack with `client`.
///
/// Returns `Ok(handler_ptr)` on success, or
/// `Err(JackErr::CallbackRegistrationError)` on failure.
///
/// Registers `handler` with jack. All jack calls to `client` will be handled by
/// `handler`. `handler` is consumed, but it is not deallocated. `handler`
/// should be manually deallocated when jack will no longer make calls to it,
/// such as when registering new callbacks with the same client, or dropping the
/// client.
///
/// # TODO
/// * Handled failed registrations
/// * Fix `jack_set_port_rename_callback`
///
/// # Unsafe
/// * `handler` will not be automatically deallocated.
pub unsafe fn register_callbacks<T: JackHandler>(client: *mut jack_client_t, handler: T) -> Result<*mut T, ()> {
    let handler_ptr: *mut T = Box::into_raw(Box::new(handler));
    let data_ptr = mem::transmute(handler_ptr);
    jack_set_thread_init_callback(client, Some(thread_init_callback::<T>), data_ptr);
    jack_on_info_shutdown(client, Some(shutdown::<T>), data_ptr);
    jack_set_process_callback(client, Some(process::<T>), data_ptr);
    jack_set_freewheel_callback(client, Some(freewheel::<T>), data_ptr);
    jack_set_buffer_size_callback(client, Some(buffer_size::<T>), data_ptr);
    jack_set_sample_rate_callback(client, Some(sample_rate::<T>), data_ptr);
    jack_set_client_registration_callback(client, Some(client_registration::<T>), data_ptr);
    jack_set_port_registration_callback(client, Some(port_registration::<T>), data_ptr);
    // doesn't compile for testing
    //jack_set_port_rename_callback(client, Some(port_rename::<T>), data_ptr);
    jack_set_port_connect_callback(client, Some(port_connect::<T>), data_ptr);
    jack_set_graph_order_callback(client, Some(graph_order::<T>), data_ptr);
    jack_set_xrun_callback(client, Some(xrun::<T>), data_ptr);
    //jack_set_latency_callback(client, Some(latency::<T>), data_ptr);
    Ok(handler_ptr)
}