use std::{fmt, slice};
use std::ffi::{CString, CStr};
use libc::{c_void, EEXIST};
use jack_sys::*;

use client::JackClient;
use error::PortError;

#[derive(Debug,Clone)]
pub enum Direction {
    Input,
    Output,
    NoInOrOut
}

impl Direction {
    pub fn is_input(&self) -> bool {
        match *self {
            Direction::Input => true,
            _ => false
        }
    }

    pub fn is_output(&self) -> bool {
        match *self {
            Direction::Output => true,
            _ => false
        }
    }
}

#[derive(Debug, Clone)]
pub enum Kind {
    Physical,
    Virtual
}

impl Kind {
    pub fn is_physical(&self) -> bool {
        match *self {
            Kind::Physical => true,
            _ => false
        }
    }
}

pub struct JackPort {
    pub client: *mut jack_client_t,
    pub name: Option<String>,
    pub direction: Option<Direction>,
    pub kind: Option<Kind>,
    pub port: Option<*mut jack_port_t>
}

impl JackPort {
    pub fn new(client: *mut jack_client_t) -> JackPort  {
        JackPort { client: client, direction: None, kind: None, name: None, port: None }
    }

    pub fn from_name(client: *mut jack_client_t, name: &str) -> Option<JackPort> {
        let c_name = match CString::new(name) {
            Ok(s) => s,
            Err(_) => return None
        };
        
        let port = unsafe { jack_port_by_name(client, c_name.as_ptr()) };
        if port.is_null() {
            return None;
        }

        // get the full name with client prefix
        let full_name = unsafe { CStr::from_ptr(jack_port_name(port)).to_str().unwrap() };

        return Some(JackPort { client: client, direction: None, kind: None, name: Some(full_name.into()), port: Some(port) });
    }

    pub fn get_port(&mut self) ->  *mut jack_port_t {
        if self.port.is_none() {
            let name = match self.name {
                Some(ref n) => n.as_str(),
                None => panic!("Port has no name!")
            };

            let c_name = match CString::new(name) {
                Ok(s) => s,
                Err(_) => panic!("Cannot conert client name!")
            };
        
            let port = unsafe { jack_port_by_name(self.client, c_name.as_ptr()) };
            if port.is_null() {
                panic!("Invalid port name!");
            }

            self.port = Some(port);
        }

        self.port.unwrap()
    }

    pub fn name<T>(mut self, name: T) -> JackPort
    where T: Into<String> {
        self.name = Some(name.into());
        self
    }

    pub fn get_name(&self) -> Option<String> {
        self.name.clone()
    }

    pub fn direction(mut self, direction: Direction) -> JackPort {
        self.direction = Some(direction);
        self
    }

    pub fn get_direction(&mut self) -> Direction {
        let dir = match self.direction.clone() {
            Some(d) => d,
            None => {
                let flags = unsafe { jack_port_flags(self.port.unwrap()) as u32 };
                if (flags & JackPortIsInput) != 0 {
                    Direction::Input
                } else if (flags & JackPortIsOutput) != 0 {
                    Direction::Output
                } else {
                    Direction::NoInOrOut
                }
            }
        };

        if self.direction.is_none() {
            self.direction = Some(dir.clone());
        }
        
        dir
    }

    pub fn kind(mut self, kind: Kind) -> JackPort {
        self.kind = Some(kind);
        self
    }

    pub fn get_kind(&mut self) -> Kind {
        let kind = match self.kind.clone() {
            Some(k) => k,
            None => { 
                let flags = unsafe { jack_port_flags(self.port.unwrap()) as u32 };
                if (flags & JackPortIsPhysical) != 0 {
                    Kind::Physical
                }  else {
                    Kind::Virtual
                }
            }
        };

        if self.kind.is_none() {
            self.kind = Some(kind.clone());
        }

        kind

    }

    pub fn register(mut self) -> Result<JackPort, PortError> {
        let c_name = {
            let name = match self.name {
                Some(ref name) => name.as_str(),
                None => "unknown_client"
            };
        
            match CString::new(name) {
                Ok(s) => s,
                Err(e) => panic!("..")
            }
        };

        let c_type = {
            CString::new("32 bit float mono audio").unwrap()
        };

        let mut flags: u32 = 0;
        if let Some(ref direction) = self.direction {
            flags = match direction {
                &Direction::Input => JackPortIsInput,
                &Direction::Output => JackPortIsOutput,
                &Direction::NoInOrOut => 0
            };
        };

        let port = unsafe {
            jack_port_register(self.client, c_name.as_ptr(), c_type.as_ptr(), flags as u64, 0)
        };

        if port.is_null() {
            return Err(PortError::Unknown);
        }
        // get the full name with client prefix
        let full_name = unsafe { CStr::from_ptr(jack_port_name(port)).to_str().unwrap() };
        self.name = Some(full_name.into());
        self.port = Some(port);

        Ok(self)
    }

    pub fn connect_to(&mut self, port: &JackPort) -> Result<(), PortError> {
        let name1 = {
            if let Some(name) = self.get_name() {
                CString::new(name).unwrap()
            } else {
                return Err(PortError::NotRegistered);
            }
        };
        let name2 = {
            if let Some(name) = port.name.clone() {
                CString::new(name).unwrap()
            } else {
                return Err(PortError::NotRegistered);
            }
        };

        let code;
        unsafe {
            code = jack_connect(self.client, name1.as_ptr(), name2.as_ptr());
        }

        if code == EEXIST {
            Err(PortError::AlreadyExist)
        } else if code != 0 {
            Err(PortError::Unknown)
        } else {
            Ok(())
        }
    }

    pub unsafe fn buffer(&self, nframes: u32) -> *mut c_void {
        jack_port_get_buffer(self.port.unwrap(), nframes)
    }

    pub unsafe fn get_slice<T>(&self, nframes: u32) -> &[T] {
        let buffer = self.buffer(nframes) as *const  T;
        slice::from_raw_parts(buffer, nframes as usize)
    }

    pub unsafe fn get_slice_mut<T>(&self, nframes: u32) -> &mut [T] {
        let buffer = self.buffer(nframes) as *mut T;
        slice::from_raw_parts_mut(buffer, nframes as usize)
    }

}

impl fmt::Debug for JackPort {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Name: {:?}, Direction: {:?}, Kind: {:?}", self.get_name(), self.direction, self.kind)
    }
}