use crate::database;
use crate::errors::Error;
use lazy_static::lazy_static;
use rand::{Rng, RngCore};
use rspotify::client::{ClientError, Spotify};
use rspotify::model::enums::TimeRange;
use rspotify::model::playlist::*;
use rspotify::model::track::*;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};

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

static CHUNK_SIZE: u32 = 50;

macro_rules! get_items {
    ($t: ty, $index:ident, $spotify_call:expr) => {{
        $index = 0;
        let mut result: Vec<$t> = Vec::new();
        loop {
            match $spotify_call.await {
                Ok(mut page) => {
                    $index += CHUNK_SIZE;
                    if page.items.is_empty() {
                        break;
                    }
                    result.append(&mut page.items);
                }
                Err(e) => match e {
                    ClientError::RateLimited(x) => {
                        std::thread::sleep(std::time::Duration::from_secs(x.unwrap_or(5) as u64))
                    }

                    cause => {
                        println!("Error: {:?}", cause);
                        break;
                    }
                },
            }
        }
        result
    }};
}

pub async fn load_profile(db_uid: i32, spotify_uid: &str, spotify: Spotify) -> Result<(), Error> {
    let mut index;
    let playlists = get_items!(
        SimplifiedPlaylist,
        index,
        spotify.current_user_playlists(CHUNK_SIZE, index)
    );
    let library = get_items!(
        SavedTrack,
        index,
        spotify.current_user_saved_tracks(CHUNK_SIZE, index)
    );
    let top_tracks = get_items!(
        FullTrack,
        index,
        spotify.current_user_top_tracks(CHUNK_SIZE, index, TimeRange::MediumTerm)
    );
    for track in library {
        if let Err(e) = database::insert_track(db_uid, track.track, 5).await {
            println!("failed to load track to db: {:?}", e)
        };
    }
    for (pos, track) in top_tracks.iter().enumerate() {
        let weight = ((50.0 - pos as f64) / 50.0 * 10.0).floor() as i32;
        if let Err(e) = database::insert_track(db_uid, track.clone(), 5 + weight).await {
            println!("failed to load track to db: {:?}", e)
        };
    }
    let playlists = playlists.iter().map(|x| x.clone());
    for playlist in playlists {
        let tracks = get_items!(
            PlaylistItem,
            index,
            spotify.playlist_tracks(
                //spotify_uid.as_ref(),
                &playlist.id,
                None,
                CHUNK_SIZE,
                index,
                None,
            )
        );
        let tracks: Vec<FullTrack> = tracks.iter().map(|x| x.track.clone()).flatten().collect();
        for track in tracks {
            if let Err(e) = database::insert_track(db_uid, track, 1).await {
                println!("failed to load track to db: {:?}", e)
            };
        }
    }
    Ok(())
}

use rspotify::client::SpotifyBuilder;
use rspotify::oauth2::{CredentialsBuilder, OAuthBuilder};

/// Generate `length` random chars
fn generate_random_uuid(length: usize) -> String {
    let alphanum: &[u8] =
        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".as_bytes();
    let mut buf = vec![0u8; length];
    rand::thread_rng().fill_bytes(buf.as_mut_slice());
    let range = alphanum.len();

    buf.iter()
        .map(|byte| alphanum[*byte as usize % range] as char)
        .collect()
}

pub async fn auth_user(name: &str, code: &str) -> Result<(String, Spotify), Error> {
    let (user, mut spotify) = {
        let mut guard = (*CACHE).lock()?;
        guard
            .remove(name)
            .ok_or(Error::Misc("failed to remove user from waitlist".into()))?
    };
    println!("auth: {:?} url: {}", name, code);
    spotify.request_user_token(code).await?;
    //let token_info = process_token(&mut oauth, &mut token_string);
    /*let client_credential = SpotifyClientCredentials::default()
        .token_info(token_info.await?)
        .build();

    let spotify = Spotify::default()
    .client_credentials_manager(client_credential)
    .build();*/
    /*let user_id = spotify
    .current_user()
    .await
    .map_err(|e| format!("failed to load currentuser {:?}", e))?
    .id;*/
    Ok((user, spotify))
}

pub fn token(name: String, token: String) -> Result<String, Error> {
    let scope = "playlist-read-private playlist-read-collaborative user-read-private user-follow-read user-library-read";

    let oauth = OAuthBuilder::from_env()
        .scope(scope.split_whitespace().map(|x| x.to_owned()).collect())
        .build()
        .unwrap();
    let creds = CredentialsBuilder::from_env().build().unwrap();

    let spotify = SpotifyBuilder::default()
        .credentials(creds)
        .oauth(oauth)
        .build()
        .unwrap();

    let auth_url = spotify.get_authorize_url(false).unwrap();

    //let token = spotify.token.as_ref().unwrap();

    /*let state = rspotify::util::generate_random_string(16);
    let oauth = SpotifyOAuth::default();
    let oauth = oauth
        .scope("playlist-read-private, playlist-read-collaborative, user-read-private, user-follow-read, user-library-read")
        .build();
    */
    //let auth_url = oauth.get_authorize_url(Some(&state), None);
    let mut guard = (*CACHE).lock()?;
    guard.insert(token, (name, spotify));
    Ok(auth_url)
}