use crate::*;

/// A LV2 plugin.
#[derive(Debug)]
pub struct Lv2 {
    /// JACK client handle (needs to not be dropped for standalone mode to work).
    pub jack:       Jack<'static>,
    pub name:       Arc<str>,
    pub path:       Option<Arc<str>>,
    pub selected:   usize,
    pub mapping:    bool,
    pub midi_ins:   Vec<Port<MidiIn>>,
    pub midi_outs:  Vec<Port<MidiOut>>,
    pub audio_ins:  Vec<Port<AudioIn>>,
    pub audio_outs: Vec<Port<AudioOut>>,

    pub lv2_world:        livi::World,
    pub lv2_instance:     livi::Instance,
    pub lv2_plugin:       livi::Plugin,
    pub lv2_features:     Arc<livi::Features>,
    pub lv2_port_list:    Vec<livi::Port>,
    pub lv2_input_buffer: Vec<livi::event::LV2AtomSequence>,
    pub lv2_ui_thread:    Option<JoinHandle<()>>,
}

impl Lv2 {

    pub fn new (
        jack: &Jack<'static>,
        name: &str,
        uri:  &str,
    ) -> Usually<Self> {
        let lv2_world = livi::World::with_load_bundle(&uri);
        let lv2_features = lv2_world.build_features(livi::FeaturesBuilder {
            min_block_length: 1,
            max_block_length: 65536,
        });
        let lv2_plugin = lv2_world.iter_plugins().nth(0)
            .unwrap_or_else(||panic!("plugin not found: {uri}"));
        Ok(Self {
            jack:       jack.clone(),
            name:       name.into(),
            path:       Some(String::from(uri).into()),
            selected:   0,
            mapping:    false,
            midi_ins:   vec![],
            midi_outs:  vec![],
            audio_ins:  vec![],
            audio_outs: vec![],
            lv2_instance: unsafe {
                lv2_plugin
                    .instantiate(lv2_features.clone(), 48000.0)
                    .expect(&format!("instantiate failed: {uri}"))
            },
            lv2_port_list: lv2_plugin.ports().collect::<Vec<_>>(),
            lv2_input_buffer: Vec::with_capacity(Self::INPUT_BUFFER),
            lv2_ui_thread: None,
            lv2_world,
            lv2_features,
            lv2_plugin,
        })
    }

    const INPUT_BUFFER: usize = 1024;

}


    //fn jack_from_lv2 (name: &str, plugin: &::livi::Plugin) -> Usually<Jack> {
        //let counts = plugin.port_counts();
        //let mut jack = Jack::new(name)?;
        //for i in 0..counts.atom_sequence_inputs {
            //jack = jack.midi_in(&format!("midi-in-{i}"))
        //}
        //for i in 0..counts.atom_sequence_outputs {
            //jack = jack.midi_out(&format!("midi-out-{i}"));
        //}
        //for i in 0..counts.audio_inputs {
            //jack = jack.audio_in(&format!("audio-in-{i}"));
        //}
        //for i in 0..counts.audio_outputs {
            //jack = jack.audio_out(&format!("audio-out-{i}"));
        //}
        //Ok(jack)
    //}

audio!(|self: Lv2, _client, scope|{
    let Self {
        midi_ins,
        midi_outs,
        audio_ins,
        audio_outs,
        lv2_features,
        lv2_instance,
        lv2_input_buffer,
        ..
    } = self;
    let urid = lv2_features.midi_urid();
    lv2_input_buffer.clear();
    for port in midi_ins.iter() {
        let mut atom = ::livi::event::LV2AtomSequence::new(
            &lv2_features,
            scope.n_frames() as usize
        );
        for event in port.iter(scope) {
            match event.bytes.len() {
                3 => atom.push_midi_event::<3>(
                    event.time as i64,
                    urid,
                    &event.bytes[0..3]
                ).unwrap(),
                _ => {}
            }
        }
        lv2_input_buffer.push(atom);
    }
    let mut outputs = vec![];
    for _ in midi_outs.iter() {
        outputs.push(::livi::event::LV2AtomSequence::new(
            lv2_features,
            scope.n_frames() as usize
        ));
    }
    let ports = ::livi::EmptyPortConnections::new()
        .with_atom_sequence_inputs(lv2_input_buffer.iter())
        .with_atom_sequence_outputs(outputs.iter_mut())
        .with_audio_inputs(audio_ins.iter().map(|o|o.as_slice(scope)))
        .with_audio_outputs(audio_outs.iter_mut().map(|o|o.as_mut_slice(scope)));
    unsafe {
        lv2_instance.run(scope.n_frames() as usize, ports).unwrap()
    };
    Control::Continue
});

impl Draw<TuiOut> for Lv2 {
    fn draw (&self, to: &mut TuiOut) {
        let area = to.area();
        let [x, y, _, height] = area;
        let mut width = 20u16;
        let start = self.selected.saturating_sub((height as usize / 2).saturating_sub(1));
        let end   = start + height as usize - 2;
        //draw_box(buf, Rect { x, y, width, height });
        for i in start..end {
            if let Some(port) = self.lv2_port_list.get(i) {
                let value = if let Some(value) = self.lv2_instance.control_input(port.index) {
                    value
                } else {
                    port.default_value
                };
                //let label = &format!("C·· M·· {:25} = {value:.03}", port.name);
                let label = &format!("{:25} = {value:.03}", port.name);
                width = width.max(label.len() as u16 + 4);
                let style = if i == self.selected {
                    Some(Style::default().green())
                } else {
                    None
                } ;
                to.blit(&label, x + 2, y + 1 + i as u16 - start as u16, style);
            } else {
                break
            }
        }
        draw_header(self, to, x, y, width);
    }
}

fn draw_header (state: &Lv2, to: &mut TuiOut, x: u16, y: u16, w: u16) {
    let style  = Style::default().gray();
    let label1 = format!(" {}", state.name);
    to.blit(&label1, x + 1, y, Some(style.white().bold()));
    if let Some(ref path) = state.path {
        let label2 = format!("{}…", &path[..((w as usize - 10).min(path.len()))]);
        to.blit(&label2, x + 2 + label1.len() as u16, y, Some(style.not_dim()));
    }
    //Ok(Rect { x, y, width: w, height: 1 })
}

//handle!(TuiIn: |self:Plugin, from|{
    //match from.event() {
        //kpat!(KeyCode::Up) => {
            //self.selected = self.selected.saturating_sub(1);
            //Ok(Some(true))
        //},
        //kpat!(KeyCode::Down) => {
            //self.selected = (self.selected + 1).min(match &self.plugin {
                //Some(PluginKind::LV2(LV2Plugin { port_list, .. })) => port_list.len() - 1,
                //_ => unimplemented!()
            //});
            //Ok(Some(true))
        //},
        //kpat!(KeyCode::PageUp) => {
            //self.selected = self.selected.saturating_sub(8);
            //Ok(Some(true))
        //},
        //kpat!(KeyCode::PageDown) => {
            //self.selected = (self.selected + 10).min(match &self.plugin {
                //Some(PluginKind::LV2(LV2Plugin { port_list, .. })) => port_list.len() - 1,
                //_ => unimplemented!()
            //});
            //Ok(Some(true))
        //},
        //kpat!(KeyCode::Char(',')) => {
            //match self.plugin.as_mut() {
                //Some(PluginKind::LV2(LV2Plugin { port_list, ref mut instance, .. })) => {
                    //let index = port_list[self.selected].index;
                    //if let Some(value) = instance.control_input(index) {
                        //instance.set_control_input(index, value - 0.01);
                    //}
                //},
                //_ => {}
            //}
            //Ok(Some(true))
        //},
        //kpat!(KeyCode::Char('.')) => {
            //match self.plugin.as_mut() {
                //Some(PluginKind::LV2(LV2Plugin { port_list, ref mut instance, .. })) => {
                    //let index = port_list[self.selected].index;
                    //if let Some(value) = instance.control_input(index) {
                        //instance.set_control_input(index, value + 0.01);
                    //}
                //},
                //_ => {}
            //}
            //Ok(Some(true))
        //},
        //kpat!(KeyCode::Char('g')) => {
            //match self.plugin {
                ////Some(PluginKind::LV2(ref mut plugin)) => {
                    ////plugin.ui_thread = Some(run_lv2_ui(LV2PluginUI::new()?)?);
                ////},
                //Some(_) => unreachable!(),
                //None => {}
            //}
            //Ok(Some(true))
        //},
        //_ => Ok(None)
    //}
//});

//from_atom!("plugin/lv2" => |jack: &Jack, args| -> Plugin {
    //let mut name = String::new();
    //let mut path = String::new();
    //atom!(atom in args {
        //Atom::Map(map) => {
            //if let Some(Atom::Str(n)) = map.get(&Atom::Key(":name")) {
                //name = String::from(*n);
            //}
            //if let Some(Atom::Str(p)) = map.get(&Atom::Key(":path")) {
                //path = String::from(*p);
            //}
        //},
        //_ => panic!("unexpected in lv2 '{name}'"),
    //});
    //Plugin::new_lv2(jack, &name, &path)
//});

//pub struct LV2PluginUI {
    //write:      (),
    //controller: (),
    //widget:     (),
    //features:   (),
    //transfer:   (),
//}


#[cfg(feature = "lv2_gui")]
pub fn run_lv2_ui (mut ui: LV2PluginUI) -> Usually<JoinHandle<()>> {
    Ok(spawn(move||{
        let event_loop = EventLoop::builder().with_x11().with_any_thread(true).build().unwrap();
        event_loop.set_control_flow(ControlFlow::Wait);
        event_loop.run_app(&mut ui).unwrap()
    }))
}

#[cfg(feature = "lv2_gui")]
/// A LV2 plugin's X11 UI.
pub struct LV2PluginUI {
    pub window: Option<Window>
}

#[cfg(feature = "lv2_gui")]
impl LV2PluginUI {
    pub fn new () -> Usually<Self> {
        Ok(Self { window: None })
    }
}

#[cfg(feature = "lv2_gui")]
impl ApplicationHandler for LV2PluginUI {
    fn resumed (&mut self, event_loop: &ActiveEventLoop) {
        self.window = Some(event_loop.create_window(Window::default_attributes()).unwrap());
    }
    fn window_event (&mut self, event_loop: &ActiveEventLoop, id: WindowId, event: WindowEvent) {
        match event {
            WindowEvent::CloseRequested => {
                self.window.as_ref().unwrap().set_visible(false);
                event_loop.exit();
            },
            WindowEvent::RedrawRequested => {
                self.window.as_ref().unwrap().request_redraw();
            }
            _ => (),
        }
    }
}

#[cfg(feature = "lv2_gui")]
fn lv2_ui_instantiate (kind: &str) {
    //let host = Suil
}