use std::ptr;
use std::marker::PhantomData;
use std::fmt;
use std::slice;

#[derive(Debug, Copy, Clone)]
enum ChannelType{
    CONTROL,
    AUDIO,
    STR,
}

enum Writable{}
enum Readable{}
enum AudioChannel{}
enum ControlChannel{}
enum StrChannel{}

trait InputChannelPtr<T: ?Sized>{
    fn write(&self, inp: T);
}

trait OutputChannelPtr<'a, T: ?Sized>{
    fn read(&'a self) -> &'a T;
}


#[derive(Debug)]
pub struct ControlChannelPtr<'a, C, T> {
    ptr: *mut f64,
    len: usize,
    phantom: PhantomData<&'a T>,
    phantomC: PhantomData<C>,
}


impl<'a> OutputChannelPtr<'a, f64> for ControlChannelPtr<'a, ControlChannel, Readable>{
    fn read(&'a self) -> &'a f64{
        unsafe{
            &*self.ptr
        }
    }

}

impl<'a> InputChannelPtr<f64> for ControlChannelPtr<'a, ControlChannel, Writable>{
    fn write(&self, inp: f64){
        unsafe{
            *self.ptr = inp;
            println!("input {}", *self.ptr);
        }
    }
}

impl<'a> OutputChannelPtr<'a, [f64]> for ControlChannelPtr<'a, AudioChannel, Readable>{

    fn read(&'a self) -> &[f64]{
        unsafe {
            slice::from_raw_parts(self.ptr as *const f64, self.len)
        }
    }
}

impl<'a> InputChannelPtr<&[f64]> for ControlChannelPtr<'a, AudioChannel, Writable>{
    fn write(&self, inp: &[f64]){
        let mut len = inp.len();
        let size = self.len;
        if size < len {
            len = size;
        }
        unsafe {
            std::ptr::copy(inp.as_ptr(), self.ptr, len);
        }
    }
}

impl<'a> OutputChannelPtr<'a, [u8]> for ControlChannelPtr<'a, StrChannel, Readable>{
    fn read(&'a self) -> &'a [u8]{
        unsafe {
            slice::from_raw_parts(self.ptr as *const u8, self.len)
        }
    }
}

impl<'a> InputChannelPtr<&[u8]> for ControlChannelPtr<'a, StrChannel, Writable>{
    fn write(&self, inp: &[u8]){
        let mut len = inp.len();
        let size = self.len;
        if size < len {
            len = size;
        }
        unsafe {
            std::ptr::copy(inp.as_ptr(), self.ptr as *mut u8, len);
        }
    }
}


impl<'a, C> ControlChannelPtr<'a, C, Writable>{

    fn writable(ctype: ChannelType)-> Self {
       ControlChannelPtr::new(ctype)
    }
}

impl<'a, C> ControlChannelPtr<'a, C, Readable>{

    fn readable(ctype: ChannelType)-> Self {
        ControlChannelPtr::new(ctype)
    }
}

impl<'a,C, T> ControlChannelPtr<'a, C, T>{

    fn new(ctype: ChannelType)-> Self {
        let mut len = 0usize;
        let ptr = match ctype {
            ChannelType::CONTROL => {
                println!("control channel");
                len = 1;
                Box::into_raw(Box::new(0.0)) as *mut f64
            }
            ChannelType::AUDIO   => {
                println!("audio channel");
                len = 6;
                let vec = vec![0.0f64; 6];
                Box::into_raw( vec.into_boxed_slice() ) as *mut f64
            }
            ChannelType::STR     => {
                println!("string channel");
                let string = "Hello World".to_owned().into_bytes();
                len = string.len(); // longitud numero de elementos del tipo u8
                Box::into_raw( string.into_boxed_slice() ) as *mut f64
            }
        };
        let phantom = PhantomData;
        let phantomC = PhantomData;
        Self{
            ptr,
            len,
            phantom,
            phantomC,
        }
    }
}

impl<'a, C, T> Drop for ControlChannelPtr<'a, C, T> {
    fn drop(&mut self) {
        unsafe{
            let _ = Box::from_raw(self.ptr);
        }
        println!("Dropping!");
    }
}

fn get_input_channel<'a, C>(ctype: ChannelType) -> ControlChannelPtr<'a, C, Writable> {
    ControlChannelPtr::writable(ctype)
}


fn main() {

    let audio = get_input_channel::<AudioChannel>(ChannelType::AUDIO);
    let mut slice = vec![10.25, 145.2, 0.002, 0.014, 235.8, 134.25];
    let mut sl = [0.5; 6];
    audio.write(slice.as_slice());

    let string = get_input_channel::<StrChannel>(ChannelType::STR);
    let str = "Hello natam".to_owned();
    string.write(str.as_bytes());

    let control = get_input_channel::<ControlChannel>(ChannelType::CONTROL);
    let data = 15.25;
    control.write(data);

}