use io_prompt_prototype::prompt;
use itertools::Itertools;

mod flags;
mod parse;
mod player;
mod seq;
mod syn;
mod tone;

fn main() {
    let flags = flags::Flags::new();
    if flags.debug {
        eprintln!("{:?}", flags);
    }

    let once = flags.play.iter().filter(|x| x.len() > 0).count() > 0;
    let mut player = player::new(flags.sample_rate.clone(), flags.bpm.clone());
    loop {
        play_with_flags(&flags, &mut player);
        if once {
            break;
        }
    }
}

fn play_with_flags(flags: &flags::Flags, player: &mut player::Player) {
    let mut syn_seq = seq::new_syn(syn::Syn::new(
        flags.debug.clone(),
        flags.sound_font.clone(),
        flags.sample_rate.clone(),
    ));

    let mut i = 0;
    for p in flags.play.iter() {
        for p in parse::new(p.clone()) {
            syn_seq.append(i as i32, p);
            i += 1;
        }
    }

    let sync = i > 0;
    if !sync {
        let mut to_break = false;
        let mut payload = vec![];
        loop {
            let mut s: String = prompt!("> ").parse().expect("failed to readline");
            s = s.split_whitespace().join(" ");
            payload.push(s.clone());
            match s.as_ref() {
                "" => match to_break {
                    false => {
                        to_break = true;
                    }
                    true => {
                        break;
                    }
                },
                _ => {
                    to_break = false;
                }
            };
        }

        for p in parse::new(payload.join("\n")) {
            syn_seq.append(i as i32, p);
            i += 1;
        }
    }

    match sync {
        true => player.play(syn_seq),
        false => player.play_async(syn_seq),
    };
}