use chrono::Local;
use mpd::{Client, Query, Song};
use rand::prelude::*;
use rand::seq::SliceRandom;
use std::{thread, time};

fn main() {
    // We enable consume mode here
    let _ = Client::default().consume(true);

    // We launch an infinite loop
    loop {
        let mut c = Client::default();
        println!("{} checking playlist ", Local::now().format("%T"));

        let s = match c.status() {
            Ok(status) => status,
            Err(_) => panic!("blah"),
        };

        let ql = s.queue_len;

        if ql < 10u32 {
            populate_playlist(10u32 - ql);
        };

        let refresh_delay = time::Duration::from_secs(20);
        thread::sleep(refresh_delay);

        let _ = c.close();
    }
}

fn populate_playlist(a: u32) {
    if a == 1 {
        println!("need to add one song");
    } else {
        println!("need to add {} songs", a);
    }

    let mut x: u32 = 0;
    while x < a {
        add_track();
        x += 1;
        let remaining = a - x;
        match remaining {
            0 => println!("playlist refilled!"),
            1 => println!("need to add 1 more song"),
            _ => println!("need to add {} more songs", remaining),
        }
    }
}

fn add_track() {
    let mut c = Client::default();

    let res: Song = get_random_track();
    println!("adding: {:?}", res.file);

    let _ = c.push(res);
    let _ = c.close();
}

fn get_random_track() -> Song {
    let mut c = Client::default();

    const CHARSET: &[u8] = b"abcdefghijklmnopqrstuvwxyz";
    const CHARS_LEN: usize = 2;
    let mut rng = rand::thread_rng();

    let chars: String = (0..CHARS_LEN)
        .map(|_| {
            let idx = rng.gen_range(0, CHARSET.len());
            CHARSET[idx] as char
        })
        .collect();

    let mut query = Query::new();
    let query = query.and(mpd::Term::Any, chars);

    let songs = c.search(query, None).unwrap_or_default();

    if songs.is_empty() {
        return get_random_track();
    } else {
        let mut rng = rand::thread_rng();
        let track = match songs.choose(&mut rng) {
            Some(song) => song,
            None => panic!("Impossible de choisir un morceau"),
        };
        track.clone()
    }
}