use crate::*;

pub struct Mixer<E: Engine> {
    pub name:            String,
    pub tracks:          Vec<Track<E>>,
    pub selected_track:  usize,
    pub selected_column: usize,
}
impl<E: Engine> Mixer<E> {
    pub fn new (name: &str) -> Usually<Self> {
        let (client, _status) = Client::new(name, ClientOptions::NO_START_SERVER)?;
        Ok(Self {
            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 = Track::new(name)?;
        self.tracks.push(track);
        Ok(self)
    }
    pub fn track (&self) -> Option<&Track<E>> {
        self.tracks.get(self.selected_track)
    }
}
impl<E: Engine> Audio for Mixer<E> {
    fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
        Control::Continue
    }
}
impl Content for Mixer<Tui> {
    type Engine = Tui;
    fn content (&self) -> impl Widget<Engine = Tui> {
        Stack::right(|add| {
            for channel in self.tracks.iter() {
                add(channel)?;
            }
            Ok(())
        })
    }
}

impl Handle<Tui> for Mixer<Tui> {
    fn handle (&mut self, engine: &TuiInput) -> Perhaps<bool> {
        if let TuiEvent::Input(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)
    }
}

//pub const ACTIONS: [(&'static str, &'static str);2] = [
    //("+/-",     "Adjust"),
    //("Ins/Del", "Add/remove track"),
//];