tek/src/mixer.rs

use crate::*;

#[derive(Debug)]
pub struct Mixer {
    /// JACK client handle (needs to not be dropped for standalone mode to work).
    pub jack:            Arc<RwLock<JackConnection>>,
    pub name:            String,
    pub tracks:          Vec<MixerTrack>,
    pub selected_track:  usize,
    pub selected_column: usize,
}

/// A mixer track.
#[derive(Debug)]
pub struct MixerTrack {
    pub name:    String,
    /// Inputs of 1st device
    pub audio_ins: Vec<Port<AudioIn>>,
    /// Outputs of last device
    pub audio_outs: Vec<Port<AudioOut>>,
    /// Device chain
    pub devices: Vec<Box<dyn MixerTrackDevice>>,
}

audio!(|self: Mixer, _client, _scope|Control::Continue);

impl Mixer {
    pub fn new (jack: &Arc<RwLock<JackConnection>>, name: &str) -> Usually<Self> {
        Ok(Self {
            jack: jack.clone(),
            name: name.into(),
            selected_column: 0,
            selected_track:  1,
            tracks: vec![],
        })
    }
    pub fn track_add (&mut self, name: &str, channels: usize) -> Usually<&mut Self> {
        let track = MixerTrack::new(name)?;
        self.tracks.push(track);
        Ok(self)
    }
    pub fn track (&self) -> Option<&MixerTrack> {
        self.tracks.get(self.selected_track)
    }
}

impl MixerTrack {
    pub fn new (name: &str) -> Usually<Self> {
        Ok(Self {
            name:       name.to_string(),
            audio_ins:  vec![],
            audio_outs: vec![],
            devices:    vec![],
            //ports:   JackPorts::default(),
            //devices: vec![],
            //device:  0,
        })
    }
    //fn get_device_mut (&self, i: usize) -> Option<RwLockWriteGuard<Box<dyn AudioComponent<E>>>> {
        //self.devices.get(i).map(|d|d.state.write().unwrap())
    //}
    //pub fn device_mut (&self) -> Option<RwLockWriteGuard<Box<dyn AudioComponent<E>>>> {
        //self.get_device_mut(self.device)
    //}
    ///// Add a device to the end of the chain.
    //pub fn append_device (&mut self, device: JackDevice<E>) -> Usually<&mut JackDevice<E>> {
        //self.devices.push(device);
        //let index = self.devices.len() - 1;
        //Ok(&mut self.devices[index])
    //}
    //pub fn add_device (&mut self, device: JackDevice<E>) {
        //self.devices.push(device);
    //}
    //pub fn connect_first_device (&self) -> Usually<()> {
        //if let (Some(port), Some(device)) = (&self.midi_out, self.devices.get(0)) {
            //device.client.as_client().connect_ports(&port, &device.midi_ins()?[0])?;
        //}
        //Ok(())
    //}
    //pub fn connect_last_device (&self, app: &Track) -> Usually<()> {
        //Ok(match self.devices.get(self.devices.len().saturating_sub(1)) {
            //Some(device) => {
                //app.audio_out(0).map(|left|device.connect_audio_out(0, &left)).transpose()?;
                //app.audio_out(1).map(|right|device.connect_audio_out(1, &right)).transpose()?;
                //()
            //},
            //None => ()
        //})
    //}
}

pub struct TrackView<'a> {
    pub chain:     Option<&'a MixerTrack>,
    pub direction: Direction,
    pub focused:   bool,
    pub entered:   bool,
}

impl<'a> Content<TuiOut> for TrackView<'a> {
    fn render (&self, to: &mut TuiOut) {
        todo!();
        //let mut area = to.area();
        //if let Some(chain) = self.chain {
            //match self.direction {
                //Direction::Down  => area.width = area.width.min(40),
                //Direction::Right => area.width = area.width.min(10),
                //_ => { unimplemented!() },
            //}
            //to.fill_bg(to.area(), Nord::bg_lo(self.focused, self.entered));
            //let mut split = Stack::new(self.direction);
            //for device in chain.devices.as_slice().iter() {
                //split = split.add_ref(device);
            //}
            //let (area, areas) = split.render_areas(to)?;
            //if self.focused && self.entered && areas.len() > 0 {
                //Corners(Style::default().green().not_dim()).draw(to.with_rect(areas[0]))?;
            //}
            //Ok(Some(area))
        //} else {
            //let [x, y, width, height] = area;
            //let label = "No chain selected";
            //let x = x + (width - label.len() as u16) / 2;
            //let y = y + height / 2;
            //to.blit(&label, x, y, Some(Style::default().dim().bold()))?;
            //Ok(Some(area))
        //}
    }
}

//impl Content<TuiOut> for Mixer<Tui> {
    //fn content (&self) -> impl Content<TuiOut> {
        //Stack::right(|add| {
            //for channel in self.tracks.iter() {
                //add(channel)?;
            //}
            //Ok(())
        //})
    //}
//}

//impl Content<TuiOut> for Track<Tui> {
    //fn content (&self) -> impl Content<TuiOut> {
        //TrackView {
            //chain:     Some(&self),
            //direction: tek_core::Direction::Right,
            //focused:   true,
            //entered:   true,
            ////pub channels:          u8,
            ////pub input_ports:       Vec<Port<AudioIn>>,
            ////pub pre_gain_meter:    f64,
            ////pub gain:              f64,
            ////pub insert_ports:      Vec<Port<AudioOut>>,
            ////pub return_ports:      Vec<Port<AudioIn>>,
            ////pub post_gain_meter:   f64,
            ////pub post_insert_meter: f64,
            ////pub level:             f64,
            ////pub pan:               f64,
            ////pub output_ports:      Vec<Port<AudioOut>>,
            ////pub post_fader_meter:  f64,
            ////pub route:             String,
        //}
    //}
//}

handle!(TuiIn: |self: Mixer, engine|{
    if let crossterm::event::Event::Key(event) = engine.event() {

        match event.code {
            //KeyCode::Char('c') => {
                //if event.modifiers == KeyModifiers::CONTROL {
                    //self.exit();
                //}
            //},
            KeyCode::Down => {
                self.selected_track = (self.selected_track + 1) % self.tracks.len();
                println!("{}", self.selected_track);
                return Ok(Some(true))
            },
            KeyCode::Up => {
                if self.selected_track == 0 {
                    self.selected_track = self.tracks.len() - 1;
                } else {
                    self.selected_track -= 1;
                }
                println!("{}", self.selected_track);
                return Ok(Some(true))
            },
            KeyCode::Left => {
                if self.selected_column == 0 {
                    self.selected_column = 6
                } else {
                    self.selected_column -= 1;
                }
                return Ok(Some(true))
            },
            KeyCode::Right => {
                if self.selected_column == 6 {
                    self.selected_column = 0
                } else {
                    self.selected_column += 1;
                }
                return Ok(Some(true))
            },
            _ => {
                println!("\n{event:?}");
            }
        }

    }
    Ok(None)
});

handle!(TuiIn: |self:MixerTrack,from|{
    match from.event() {
        //,    NONE, "chain_cursor_up",   "move cursor up", || {
        kpat!(KeyCode::Up) => {
            Ok(Some(true))
        },
        // ,  NONE, "chain_cursor_down", "move cursor down", || {
        kpat!(KeyCode::Down) => {
            Ok(Some(true))
        },
        // Left,  NONE, "chain_cursor_left", "move cursor left", || {
        kpat!(KeyCode::Left) => {
            //if let Some(track) = app.arranger.track_mut() {
                //track.device = track.device.saturating_sub(1);
                //return Ok(true)
            //}
            Ok(Some(true))
        },
        // , NONE, "chain_cursor_right", "move cursor right", || {
        kpat!(KeyCode::Right) => {
            //if let Some(track) = app.arranger.track_mut() {
                //track.device = (track.device + 1).min(track.devices.len().saturating_sub(1));
                //return Ok(true)
            //}
            Ok(Some(true))
        },
        // , NONE, "chain_mode_switch", "switch the display mode", || {
        kpat!(KeyCode::Char('`')) => {
            //app.chain_mode = !app.chain_mode;
            Ok(Some(true))
        },
        _ => Ok(None)
    }
});

pub enum MixerTrackCommand {}

//impl MixerTrackDevice for LV2Plugin {}

pub trait MixerTrackDevice: Debug + Send + Sync {
    fn boxed (self) -> Box<dyn MixerTrackDevice> where Self: Sized + 'static {
        Box::new(self)
    }
}

impl MixerTrackDevice for Sampler {}

impl MixerTrackDevice for Plugin {}

const SYM_NAME:    &str = ":name";
const SYM_GAIN:    &str = ":gain";
const SYM_SAMPLER: &str = "sampler";
const SYM_LV2:     &str = "lv2";

from_edn!("mixer/track" => |jack: &Arc<RwLock<JackConnection>>, args| -> MixerTrack {
    let mut _gain = 0.0f64;
    let mut track = MixerTrack {
        name:       String::new(),
        audio_ins:  vec![],
        audio_outs: vec![],
        devices:    vec![],
    };
    edn!(edn in args {
        Edn::Map(map) => {
            if let Some(Edn::Str(n)) = map.get(&Edn::Key(SYM_NAME)) {
                track.name = n.to_string();
            }
            if let Some(Edn::Double(g)) = map.get(&Edn::Key(SYM_GAIN)) {
                _gain = f64::from(*g);
            }
        },
        Edn::List(args) => match args.first() {
            // Add a sampler device to the track
            Some(Edn::Symbol(SYM_SAMPLER)) => {
                track.devices.push(
                    Box::new(Sampler::from_edn(jack, &args[1..])?) as Box<dyn MixerTrackDevice>
                );
                panic!(
                    "unsupported in track {}: {:?}; tek_mixer not compiled with feature \"sampler\"",
                    &track.name,
                    args.first().unwrap()
                )
            },
            // Add a LV2 plugin to the track.
            Some(Edn::Symbol(SYM_LV2)) => {
                track.devices.push(
                    Box::new(Plugin::from_edn(jack, &args[1..])?) as Box<dyn MixerTrackDevice>
                );
                panic!(
                    "unsupported in track {}: {:?}; tek_mixer not compiled with feature \"plugin\"",
                    &track.name,
                    args.first().unwrap()
                )
            },
            None =>
                panic!("empty list track {}", &track.name),
            _ =>
                panic!("unexpected in track {}: {:?}", &track.name, args.first().unwrap())
        },
        _ => {}
    });
    Ok(track)
});

//impl ArrangerScene {

    ////TODO
    ////pub fn from_edn <'a, 'e> (args: &[Edn<'e>]) -> Usually<Self> {
        ////let mut name  = None;
        ////let mut clips = vec![];
        ////edn!(edn in args {
            ////Edn::Map(map) => {
                ////let key = map.get(&Edn::Key(":name"));
                ////if let Some(Edn::Str(n)) = key {
                    ////name = Some(*n);
                ////} else {
                    ////panic!("unexpected key in scene '{name:?}': {key:?}")
                ////}
            ////},
            ////Edn::Symbol("_") => {
                ////clips.push(None);
            ////},
            ////Edn::Int(i) => {
                ////clips.push(Some(*i as usize));
            ////},
            ////_ => panic!("unexpected in scene '{name:?}': {edn:?}")
        ////});
        ////Ok(ArrangerScene {
            ////name:  Arc::new(name.unwrap_or("").to_string().into()),
            ////color: ItemColor::random(),
            ////clips,
        ////})
    ////}
//}