extern crate taglib;

use std::env;
use serde::Serialize;

#[derive(Serialize)]
struct Tags {
	track_name: String,
	artist_name: String,
	album_name: String,
	// duration: i32,
}

impl Default for Tags {
	fn default() -> Self {
		Tags{
			track_name: "".to_string(),
			artist_name: "".to_string(),
			album_name: "".to_string()
		}
	}
}

fn get_tag(file: taglib::File) -> Result<Tags, taglib::FileError> {

	// *** filenae ***
	// println!("*** {} ***", file.audioproperties().);
	// params.clear();

	match file.tag() {
		Ok(t) => {
			println!("--- TAG ---");
			println!("title  - {}", t.title().unwrap_or_default());
			println!("artist - {}", t.artist().unwrap_or_default());
			println!("album  - {}", t.album().unwrap_or_default());
			// println!("duration- {}", t.duration().unwrap_or_default());

			let params = Tags {
				track_name: t.title().unwrap_or_default(),
				artist_name: t.artist().unwrap_or_default(),
				album_name: t.album().unwrap_or_default(),
			};

			return Ok(params);
		}
		Err(e) => {
			return Err(e);
		}
	}
}

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
	let args: Vec<String> = env::args().collect();
	let client = reqwest::Client::new();

	for i in 1..args.len() {
		let ref arg = args[i];
		let file = match taglib::File::new(arg) {
			Ok(f) => f,
			Err(e) => {
				println!("Invalid file {} (error: {:?})", arg, e);
				continue;
			}
		};

		let params = match get_tag(file) {
			Ok(p) => p,
			Err(e) => {
				println!("No available tags for {} (error: {:?})", arg, e);
				continue;
			}
		};

		let res = client
			.get("https://lrclib.net/api/get")
			.query(&params)
			.send()
			.await?;
		
		println!("compiled url: {:?}", res.url().as_str());
		let json_value = res.json::<serde_json::Value>().await?;
		// println!("{}", serde_json::to_string_pretty(&json_value).unwrap());
		println!("plain lyrics: {}", json_value["plainLyrics"]);

		// TODO:
		// The current method sends HTTP requests sequentially, one after another.
		// This can be slower if you have many files, as each request waits for the previous one to finish.
		// To speed it up, you could collect all futures and use `futures::future::join_all` to run them concurrently.
	}

	Ok(())
}