include!("lib.rs");
use tek_core::clap::{self, Parser};
pub fn main () -> Usually<()> { ArrangerCli::parse().run() }

/// Parses CLI arguments to the `tek_arranger` invocation.
#[derive(Debug, Parser)]
#[command(version, about, long_about = None)]
pub struct ArrangerCli {
    /// Name of JACK client
    #[arg(short, long)]
    name:      Option<String>,
    /// Whether to include a transport toolbar (default: true)
    #[arg(short, long, default_value_t = true)]
    transport: bool,
    /// Number of tracks
    #[arg(short = 'x', long, default_value_t = 8)]
    tracks:    usize,
    /// Number of scenes
    #[arg(short, long, default_value_t = 8)]
    scenes:    usize,
}

impl ArrangerCli {
    /// Run the arranger TUI from CLI arguments.
    fn run (&self) -> Usually<()> {
        let jack = JackClient::Inactive(
            Client::new("tek_arranger", ClientOptions::NO_START_SERVER)?.0
        );
        let jack_transport = jack.transport();
        let mut transport = TransportToolbar::new(Some(jack_transport));
        transport.set_focused(true);
        let transport = Arc::new(RwLock::new(transport));
        let phrases = Arc::new(RwLock::new(PhrasePool::new()));
        let mut arrangement = Arrangement::new("", &phrases);
        if let Some(name) = self.name.as_ref() {
            *arrangement.name.write().unwrap() = name.clone();
        }
        for _ in 0..self.tracks {
            let track = arrangement.track_add(None)?;
            for _ in 0..self.scenes {
                track.phrases.push(
                    Arc::new(RwLock::new(Phrase::new("", true, PPQ * 4, None)))
                );
            }
        }
        for _ in 0..self.scenes {
            let _scene = arrangement.scene_add(None)?;
            //for i in 0..self.tracks {
                //scene.clips[i] = Some(i);
            //}
        }
        transport.write().unwrap().jack = Some(
            jack.activate(
                &transport.clone(),
                |state: &Arc<RwLock<TransportToolbar<Tui>>>, client, scope| {
                    state.write().unwrap().process(client, scope)
                }
            )?
        );
        Tui::run(Arc::new(RwLock::new(Arranger {
            transport:      self.transport.then_some(transport),
            show_sequencer: Some(tek_core::Direction::Down),
            focus:          0,
            modal:          None,
            editor:         PhraseEditor::new(),
            arrangement,
            phrases,
        })))?;
        Ok(())
    }
}