#![allow(non_snake_case)]

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

use musichoard::{
    collection::{album::AlbumDate, musicbrainz::Mbid},
    external::musicbrainz::{
        api::{
            search::{Expression, Query, SearchReleaseGroup},
            MusicBrainzClient,
        },
        http::MusicBrainzHttp,
    },
};
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(subcommand)]
    command: OptCommand,
}

#[derive(StructOpt)]
enum OptCommand {
    #[structopt(about = "Search by artist MBID, title(, and date)")]
    Title(OptTitle),
    #[structopt(about = "Search by release group MBID")]
    Rgid(OptRgid),
}

#[derive(StructOpt)]
struct OptTitle {
    #[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>,
}

#[derive(StructOpt)]
struct OptRgid {
    #[structopt(help = "Release group MBID")]
    rgid: Uuid,
}

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 http = MusicBrainzHttp::new(USER_AGENT).expect("failed to create API client");
    let mut client = MusicBrainzClient::new(http);

    let arid: Mbid;
    let date: AlbumDate;
    let title: String;
    let rgid: Mbid;

    let query: Query<SearchReleaseGroup> = match opt.command {
        OptCommand::Title(opt_title) => {
            arid = opt_title.arid.into();
            date = opt_title.date.map(Into::into).unwrap_or_default();
            title = opt_title.title;
            Query::expression(Expression::arid(&arid))
                .and(Expression::release_group(&title))
                .and(Expression::first_release_date(&date))
        }
        OptCommand::Rgid(opt_rgid) => {
            rgid = opt_rgid.rgid.into();
            Query::expression(Expression::rgid(&rgid))
        }
    };

    println!("Query: {query}");

    let matches = client
        .search_release_group(query)
        .expect("failed to make API call");

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