Spotify API

SPOTIFY_CLIENT_ID
SPOTIFY_CLIENT_SECRET

fn get_spotify_client() -> ClientCredsSpotify {
    let client_id = env::var(SPOTIFY_CLIENT_ID)
        .expect("Expected a spotify client id in the environment");
    let client_secret = env::var(SPOTIFY_CLIENT_SECRET)
        .expect("Expected a spotify client secret in the environment");
    let credentials = Credentials {
        id: client_id,
        secret: Some(client_secret),
    };
    let spotify = ClientCredsSpotify::new(credentials);
    spotify
}

pub fn get_song_url(
    romaji_name: String,
    kana_name: Option<String>,
    artist_name: String,
) -> Option<String>

let romaji_search = send_search_request(&romaji_name, &artist_name);
match romaji_search {
    Ok(search_result) => {
        if let Some(url) = get_url_from_search_result(search_result) {
            return Some(url);
        } else if let Some(kana_name) = kana_name {
            let kana_search = send_search_request(&kana_name, &artist_name);
            // ... handle kana search result
        }
    }
}

fn send_search_request(
    song_name: &String,
    artist_name: &String,
) -> Result<SearchResult, ClientError> {
    let spotify = get_spotify_client();
    spotify.request_token().unwrap();
    spotify.search(
        format!("track:{song_name} artist:{artist_name}").as_str(),
        SearchType::Track,
        Some(Market::Country(Country::UnitedStates)),
        None,
        Some(5),  // Limit to top 5 results
        None,
    )
}

fn get_url_from_search_result(search_result: SearchResult) -> Option<String> {
    if let SearchResult::Tracks(page) = search_result {
        if !page.items.is_empty() {
            let track = &page.items[0];
            return Some(track.external_urls["spotify"].to_owned());
        }
        None
    } else {
        None
    }
}

let cache_key = format!("{romaji_name}:{kana_name:#?}:{artist_name}");
match check_cache(&cache_key) {
    Ok(value) => {
        return match value.as_str() {
            "None" => None,
            _ => Some(value),
        };
    }
    Err(e) => {
        // Cache miss, proceed with API search
    }
};

try_to_cache_response(&cache_key, &url);  // Cache successful result
try_to_cache_response(&cache_key, "None");  // Cache negative result

use crate::utils::spotify::get_song_url;

let romaji_name = "Guren no Yumiya".to_string();
let kana_name = Some("紅蓮の弓矢".to_string());
let artist_name = "Linked Horizon".to_string();

let spotify_url = get_song_url(romaji_name, kana_name, artist_name);

match spotify_url {
    Some(url) => {
        // Create clickable link in Discord embed
        let link = format!("[**{}**]({})", song_name, url);
    }
    None => {
        // Display song name without link
        let text = format!("**{}**", song_name);
    }
}

match romaji_search {
    Ok(search_result) => {
        // Process result
    }
    Err(err) => {
        info!("Could not find track: {err:#?}");
    }
}

[dependencies]
rspotify = { version = "0.15.3", default-features = false, features = ["client-ureq", "ureq-rustls-tls"] }

use rspotify::{
    ClientCredsSpotify, 
    ClientError, 
    Credentials,
    model::{Country, Market, SearchResult, SearchType},
    prelude::*,
};

info!("Spotify client established");
info!("Romaji Song Name: {:#?}", romaji_name);
info!("Kana Song Name: {:#?}", kana_name);
info!("Searched track: {search_result:#?}");
info!("Found track: {track:#?}");
info!("Spotify Url: {:#?}", spotify_url);
info!("Cache hit for {:#?}", cache_key);
info!("Cache miss for {:#?} with error {:#?}", cache_key, e);