#![allow(non_snake_case)]

use std::{num::ParseIntError, str::FromStr};

use musichoard::{
    collection::album::{Album, AlbumDate, AlbumId},
    external::musicbrainz::api::{client::MusicBrainzApiClient, MusicBrainzApi},
    interface::musicbrainz::{IMusicBrainz, Mbid},
};
use structopt::StructOpt;
use uuid::Uuid;

const USER_AGENT: &str = concat!(
    "MusicHoard---examples---musicbrainz-api---search-release-group/",
    env!("CARGO_PKG_VERSION"),
    " ( musichoard@thenineworlds.net )"
);

#[derive(StructOpt)]
struct Opt {
    #[structopt(help = "Release group's artist MBID")]
    arid: Uuid,

    #[structopt(help = "Release group title")]
    title: String,

    #[structopt(help = "Release group release date")]
    date: Option<Date>,
}

struct Date(AlbumDate);

impl FromStr for Date {
    type Err = ParseIntError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let mut elems = s.split('-');

        let elem = elems.next();
        let year = elem.map(|s| s.parse()).transpose()?;

        let elem = elems.next();
        let month = elem.map(|s| s.parse()).transpose()?;

        let elem = elems.next();
        let day = elem.map(|s| s.parse()).transpose()?;

        Ok(Date(AlbumDate::new(year, month, day)))
    }
}

impl From<Date> for AlbumDate {
    fn from(value: Date) -> Self {
        value.0
    }
}

fn main() {
    let opt = Opt::from_args();

    println!("USER_AGENT: {USER_AGENT}");

    let client = MusicBrainzApiClient::new(USER_AGENT).expect("failed to create API client");
    let mut api = MusicBrainzApi::new(client);

    let arid: Mbid = opt.arid.into();
    let date: AlbumDate = opt.date.map(Into::into).unwrap_or_default();
    let album = Album::new(AlbumId::new(opt.title), date, None, vec![]);
    let matches = api
        .search_release_group(&arid, album)
        .expect("failed to make API call");

    println!("{matches:#?}");
}