use lazy_static::lazy_static;
use rocket::http::Status;
use rocket::response::{status, Redirect};
use rspotify::spotify::client::{ApiError, Spotify};
use rspotify::spotify::oauth2::{SpotifyClientCredentials, SpotifyOAuth};
use rspotify::spotify::util::process_token;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};

lazy_static! {
    static ref CACHE: Arc<Mutex<HashMap<String, SpotifyOAuth>>> =
        Arc::new(Mutex::new(HashMap::new()));
}

#[get("/callback/<name>/<url>")]
pub fn get_tracks(name: String, url: String) -> String {
    let mut guard = CACHE.lock().unwrap();
    let mut oauth = guard.remove(&name).unwrap();
    println!("auth: {:?} url: {}", oauth, url);
    let token_info = process_token(&mut oauth, &mut ("?code=".to_owned() + url.as_ref()));
    let client_credential = SpotifyClientCredentials::default()
        .token_info(token_info.unwrap())
        .build();

    let spotify = Spotify::default()
        .client_credentials_manager(client_credential)
        .build();
    let user_id = spotify.current_user().unwrap().id;
    let chunk_size = 50;
    let mut playlist_index = 0;
    loop {
        match spotify.user_playlists(user_id.as_ref(), Some(chunk_size), Some(playlist_index)) {
            Ok(playlists) => {
                playlist_index += chunk_size;
                if playlists.items.is_empty() {
                    break;
                }
                for playlist in playlists.items {
                    println!("playlist: {:?}", playlist.name);
                    let mut track_index = 0;

                    loop {
                        match spotify.user_playlist_tracks(
                            user_id.as_ref(),
                            &playlist.id,
                            None,
                            Some(chunk_size),
                            Some(track_index),
                            None,
                        ) {
                            Ok(tracks) => {
                                track_index += chunk_size;
                                if tracks.items.is_empty() {
                                    break;
                                }
                                for track in tracks.items {
                                    println!("{:?}", track.track.name);
                                }
                            }
                            Err(e) => match e.downcast::<ApiError>() {
                                Ok(ApiError::RateLimited(x)) => std::thread::sleep(
                                    std::time::Duration::from_secs(x.unwrap_or(5) as u64),
                                ),

                                cause => {
                                    println!("Error: {:?}", cause);
                                    break;
                                }
                            },
                        }
                    }
                }
            }
            Err(e) => match e.downcast::<ApiError>() {
                Ok(ApiError::RateLimited(x)) => {
                    std::thread::sleep(std::time::Duration::from_secs(x.unwrap_or(5) as u64))
                }

                cause => {
                    println!("Error: {:?}", cause);
                    break;
                }
            },
        }
    }
    name
}
#[get("/token/<name>")]
pub fn token(name: String) -> Result<Redirect, status::Custom<String>> {
    let state = rspotify::spotify::util::generate_random_string(16);
    let oauth = SpotifyOAuth::default();
    //let callback = oauth.redirect_uri.clone();
    let oauth = oauth
        .scope("playlist-read-private, playlist-read-collaborative, user-read-private, user-follow-read, user-library-read")
        //.redirect_uri(format!("{}/{}", callback, &state).as_ref())
        .build();
    let auth_url = oauth.get_authorize_url(Some(&state), None);
    match CACHE.lock() {
        Ok(mut guard) => {
            guard.insert(name, oauth);
            Ok(Redirect::to(auth_url))
        }
        Err(_) => Err(status::Custom(
            Status::ImATeapot,
            "Internal Server Error".to_owned(),
        )),
    }
    /*match get_token(&mut oauth) {
        Some(token_info) => {
            let client_credential = SpotifyClientCredentials::default()
                .token_info(token_info)
                .build();
            // Or set client_id and client_secret explictly
            // let client_credential = SpotifyClientCredentials::default()
            //     .client_id("this-is-my-client-id")
            //     .client_secret("this-is-my-client-secret")
            //     .build();
            let spotify = Spotify::default()
                .client_credentials_manager(client_credential)
                .build();
        }
        None => {}
    }*/
}