extern crate mpd;

mod noise;
use noise::{commands::Noise, parser::*};

use clap::{Command, CommandFactory, Parser};
use clap_complete::{generate, Generator};
use mpd::{error::Error, Client};
use std::io;

fn print_completions<G: Generator>(generator: G, cmd: &mut Command) {
    generate(
        generator,
        cmd,
        cmd.get_name().to_string(),
        &mut io::stdout(),
    );
}

fn main() -> Result<(), Error> {
    let cli = Cli::parse();

    if let Some(completions) = cli.completions {
        let mut cmd = Cli::command();
        eprintln!("Generatig completion file for {completions:?}...");
        print_completions(completions, &mut cmd);
        return Ok(());
    }

    let host = cli.host.unwrap_or("localhost:6600".into());

    let mut conn = match Client::connect(host) {
        Ok(client) => client,
        Err(err) => return Err(err),
    };

    if let Some(cmd) = &cli.command {
        match cmd {
            Commands::Play { track } => Noise::play(&mut conn, *track),
            Commands::Stop => conn.stop().unwrap(),
            Commands::Toggle => conn.toggle(),
            Commands::Next => conn.next().unwrap(),
            Commands::Prev => conn.prev().unwrap(),
            Commands::List { file } => conn.list_queue(*file, cli.verbose),
            Commands::Current => (),
            Commands::Clear => conn.clear().unwrap(),
            Commands::Search { query, max } => Noise::search(&mut conn, query, *max),
            Commands::Find { query, max, append } => Noise::find(&mut conn, query, *max, *append),
            Commands::Crossfade { seconds } => Noise::crossfade(&mut conn, *seconds),
            Commands::Shuffle => conn.shuf(),
            Commands::Repeat => conn.toggle_repeat(),
            Commands::Random => conn.toggle_random(),
            Commands::Single => conn.toggle_single(),
            Commands::Consume => conn.toggle_consume(),
            Commands::Volume { percentage } => conn.vol(*percentage),
            Commands::Munch => conn.munch(),
            Commands::Length => conn.length(),
        }

        if let Commands::Stop
        | Commands::List { .. }
        | Commands::Clear
        | Commands::Search { .. }
        | Commands::Find { .. }
        | Commands::Crossfade { .. }
        | Commands::Volume { .. }
        | Commands::Shuffle = cmd
        {
            return Ok(());
        }
    }
    let _things: Vec<String> = conn
        .queue()
        .unwrap()
        .iter()
        .map(|x| x.place.unwrap().pos.to_string())
        .collect();
    println!("{}", conn.get_status(cli.verbose));
    return Ok(());
}