Co grało radio?

library(tidyverse)
library(forcats)
library(stringr)
library(lubridate)
library(rvest)

# lista stacji
playlists_urls <- list(
   stacja = c("RMF FM", "Zet", "Jedynka", "ESKA", "Trójka"),
   url = c("https://radiospis.pl/stacja/rmf-fm",
           "https://radiospis.pl/stacja/zet",
           "https://radiospis.pl/stacja/jedynka",
           "https://radiospis.pl/stacja/eska",
           "https://radiospis.pl/stacja/trojka")) %>%
   transpose()

# funkcja pobierająca playlisty
getPlaylistTable <- function(verbose = TRUE) {
   playlist_tab <- tibble()
   
   # dla każdej stacji
   for(i in seq_len(length(playlists_urls))) {
      
      # bierzemy podstawowy url i nazwę stacji
      page_base_url <- playlists_urls[[i]]$url
      stacja <- playlists_urls[[i]]$stacja
      
      end <- FALSE
      page_no <- 1
      
      # dopóki jest link do następnej strony - przetwarzamy kolejne strony
      while(!end) {
         
         # progress bas :)
         if(verbose)
            cat(sprintf("%s - %02d\n", stacja, page_no))
         
         # wczytujemy stronę
         page_html <- read_html(sprintf("%s/page/%d", page_base_url, page_no))
         
         # data i godzina emisji utworu
         datetime <- page_html %>% html_nodes("div.hentry") %>% html_node("p") %>% html_text() %>% dmy_hm()
         
         # wykonawca i tytuł utwory
         song <- page_html %>% html_nodes("div.hentry") %>% html_node("h2") %>% html_text()
         
         # budujemy tymczasową tabele z wynikow
         temp_tab <- tibble(datetime, song, stacja) %>%
            # rozdzielamy piosenkę na tytul i wykonawce
            rowwise() %>%
            mutate(artist = str_split(song, " - ")[[1]][1],
                   title = str_split(song, " - ")[[1]][2]) %>%
            ungroup()
         
         # dołączamy tymczasowa tabele do pelnych wynikow
         playlist_tab <- bind_rows(playlist_tab, temp_tab)
         
         # czy to koniec? nie ma przycisku "Wcześniej" na stronie
         end <- page_html %>% html_nodes("div.morebtnall") %>% .[[2]] %>% html_text() %>% nchar() == 0
         
         # chwilę ajemy odsapnąć serwerom
         Sys.sleep(0.5)
         page_no <- page_no + 1
      }
   
   }
   
   return(playlist_tab)
}

playlist_tab <- getPlaylistTable()
saveRDS(playlist_tab, file = "grabbed_data.RDS")

playlist_tab %>%
   count(artist, stacja) %>%
   ungroup() %>%
   group_by(stacja) %>%
   top_n(10, n) %>%
   ungroup() %>% 
   ggplot() + 
   geom_tile(aes(stacja, artist, fill = n), color = "gray10") +
   scale_fill_distiller(palette = "YlOrRd") +
   theme(legend.position = "bottom")

playlist_tab %>%
   mutate(hour = hour(datetime), day = wday(datetime)) %>%
   count(stacja, day, hour) %>%
   ungroup() %>%
   group_by(stacja, hour) %>%
   summarise(mean_n = mean(n)) %>%
   ungroup() %>%
   ggplot() +
   geom_col(aes(hour, mean_n, fill = stacja), show.legend = FALSE) +
   facet_wrap(~stacja, ncol = 5)

playlist_tab %>%
   count(stacja) %>%
   ungroup() %>%
   mutate(n = color_tile("white", "orange")(n)) %>%
   kable(escape = FALSE) %>%
   kable_styling(bootstrap_options = c("striped", "hover", "condensed", "responsive"),
                 full_width = FALSE)

playlist_tab %>%
   distinct(stacja, title, artist) %>%
   count(stacja) %>%
   ungroup() %>%
   mutate(n = color_tile("white", "orange")(n)) %>%
   kable(escape = FALSE) %>%
   kable_styling(bootstrap_options = c("striped", "hover", "condensed", "responsive"),
                 full_width = FALSE)

left_join(
   playlist_tab %>% count(stacja, sort = T) %>% ungroup() %>% rename(total=n),
   playlist_tab %>% distinct(stacja, title, artist) %>% count(stacja, sort = T) %>% ungroup() %>% rename(uniq = n),
   by = "stacja") %>%
   mutate(p = round(100*uniq/total, 1)) %>%
   arrange(desc(p)) %>% 
   mutate(p = color_tile("white", "orange")(p)) %>%
   kable(escape = FALSE) %>%
   kable_styling(bootstrap_options = c("striped", "hover", "condensed", "responsive"),
                 full_width = FALSE)

most_popular_songs <- playlist_tab %>%
   count(song, sort = T) %>%
   ungroup() %>% 
   .$song %>%
   .[1:9]

playlist_tab %>%
   filter(song %in% most_popular_songs) %>%
   ggplot() +
   geom_point(aes(datetime, stacja, color = stacja), size = 2, show.legend = FALSE) +
   facet_wrap(~song, ncol = 3)

playlist_tab %>%
   count(song, stacja, sort = T) %>%
   ungroup() %>%
   group_by(stacja) %>% 
   top_n(5, n) %>% 
   left_join(playlist_tab, by = c("song" = "song", "stacja" = "stacja")) %>% 
   ggplot() + 
   geom_point(aes(datetime, song, color = stacja), show.legend = FALSE) + 
   facet_wrap(~stacja, scales = "free_y", ncol=1)

playlist_tab %>%
   filter(stacja == "ESKA") %>%
   mutate(day = wday(datetime)) %>%
   count(song, day) %>%
   ungroup() %>%
   top_n(10, n) %>%
   arrange(desc(n)) %>%
   mutate(n = color_tile("white", "orange")(n)) %>%
   kable(escape = FALSE) %>%
   kable_styling(bootstrap_options = c("striped", "hover", "condensed", "responsive"),
                 full_width = FALSE)

playlist_tab %>%
   filter(stacja == "ESKA", song == "Shanguy - La louze") %>%
   mutate(day = wday(datetime), hour = hour(datetime)) %>%
   filter(day == 6) %>%
   count(hour) %>%
   ggplot() +
   geom_col(aes(hour, n), fill = "lightgreen", color = "darkgreen")

playlist_tab %>%
   mutate(day = wday(datetime), hour = hour(datetime)) %>%
   filter(day == 6, stacja == "ESKA", hour %in% c(6, 7, 8)) %>%
   arrange(desc(datetime)) %>%
   mutate(song = fct_inorder(song)) %>%
   ggplot() +
   geom_point(aes(datetime, song))

playlist_tab %>%
   mutate(day = wday(datetime), hour = hour(datetime)) %>%
   filter(day == 6, stacja == "ESKA", hour %in% c(6, 7, 8)) %>%
   arrange(datetime) %>% 
   select(datetime, artist, title) %>%
   mutate(artist = ifelse(artist == "Shanguy",
                          cell_spec(artist, "html", color = "red", bold = T),
                          cell_spec(artist, "html", color = "black")),
          title = ifelse(title == "La louze",
                          cell_spec(title, "html", color = "red", italic = T),
                          cell_spec(title, "html", color = "black"))) %>%
   kable(escape = FALSE) %>%
   kable_styling(bootstrap_options = c("striped", "hover"))

library(httr)
library(jsonlite)
library(RCurl)

load("spotify_cred.rda") # zmienne client_id i client_secret - do uzyskania na https://developer.spotify.com/

# funkcja zwraca token
getSpotifyToken <- function() {
   res <- POST("https://accounts.spotify.com/api/token",
               body = list(grant_type = "client_credentials"),
               config = add_headers("Authorization" = paste0("Basic ", base64(paste(client_id,client_secret,sep=':'))[[1]])),
               encode = "form")
   
   if(res$status_code == 200) {
      return(content(res)$access_token)
   } else {
      return(NA)
   }
}

# funkcja szuka ID utworu na postawie wykonawcy i tytuły
getSpotifyTrackID <- function(track_artist, track_title) {
   
   # na potrzeby zapytania podmieniamy znaki typu spacja
   track_title <- gsub("[^a-zA-Z0-9]", "+", as.character(track_title))
   track_artist <- gsub("[^a-zA-Z0-9]", "+", as.character(track_artist))
   
   # wywołujemy API - wyszukiwanie utworu
   response <- GET(paste0("https://api.spotify.com/v1/search?q=", track_title, "+", track_artist, "&type=track"),
                   add_headers("Authorization:" = paste("Bearer", spotify_token),
                               "Content-Type:" = "application/json",
                               "Accept:" = "application/json"))
   
   # jeśli API coś zwróciło...
   if(response$status_code == 200) {
      
      # parsujemy JSONa z odpowiedzią
      response_json <- rawToChar(response$content)
      query_results <- fromJSON(response_json, flatten = TRUE)

      # jeśli w odpowiedzi jest więcej niż jeden utwór - bierzemy ten najbardziej popularny
      if(query_results$tracks$total != 0) {
         track_id <- query_results$tracks$items %>%
            filter(popularity == max(popularity)) %>% 
            .$id %>% 
            .[[1]]
      } else {
         track_id <- NA
      }
      
      return(track_id)
   } else {
      return(NA)
   }
}

# Funkcja pobiera cechy audio utworu track_id
getSporifyTrackFeatures <- function(track_id) {
   
   # zapytanie o cechy
   response <- GET(paste0("https://api.spotify.com/v1/audio-features/", as.character(track_id)),
                   add_headers("Authorization:" = paste("Bearer", spotify_token),
                               "Content-Type:" = "application/json",
                               "Accept:" = "application/json"))
   
   # udało się?
   if(response$status_code == 200) {
      
      # parsujemy JSONa, odpowiednio zmieniając kodowanie liter
      # (bez tego całość lubi się wywalić w np. polskim Windowsie)
      response_json <- rawToChar(response$content) %>% iconv(from = "UTF-8", to = Sys.getenv("CHARSET"))
      query_results <- fromJSON(response_json, flatten = TRUE)
      
      # budujemy ramkę (dokładniej - wiersz) danych z cechami
      track_features <- tibble(
         id = query_results$id,
         danceability = query_results$danceability,
         energy = query_results$energy,
         loudness = query_results$loudness,
         mode = query_results$mode,
         speechiness = query_results$speechiness,
         acousticness = query_results$acousticness,
         instrumentalness = query_results$instrumentalness,
         liveness = query_results$liveness,
         valence = query_results$valence,
         tempo = query_results$tempo,
         time_signature = query_results$time_signature)
   } else {
      return(tibble())
   }
   
   return(track_features)
}

# token Spotify
spotify_token <- getSpotifyToken()

# bierzemy unikalne piosenki, żeby nie przetwarzać kilkukrotnie tych samych danych
unique_tracks <- playlist_tab %>% distinct(title, artist)
n_unique_tracks <- nrow(unique_tracks)

# szukamy dla nich ID w Sporify
# na pewno da się to zrobić w purrr-way :)
for(i in 1:n_unique_tracks) {
   cat(sprintf("\r%04d / %d", i, n_unique_tracks))
   unique_tracks[i, "trackID"] <- getSpotifyTrackID(unique_tracks[i, "artist"], unique_tracks[i, "title"])
}

# dla tych, które w Spotify się znalazły szukamy cech
unique_tracks <- filter(unique_tracks, !is.na(trackID))
nrow(unique_tracks)

# purrr way:
# unique_tracks_features <- unique_tracks$trackID %>% map_df(getSporifyTrackFeatures)

# odswiezamy token, gdyby wszystko za długo trwało
spotify_token <- getSpotifyToken()

# szukamy dla unkialnych piosenek ich cech w Spotify
tracks_features <- tibble()
n_unique_tracks <- nrow(unique_tracks)

for(i in 1:n_unique_tracks) {
   cat(sprintf("\r%04d / %d", i, n_unique_tracks))
   
   tmp_tracks_features <- getSporifyTrackFeatures(unique_tracks[i, "trackID"])

   tracks_features <- bind_rows(tracks_features, tmp_tracks_features)
}

# łączymy listę piosenek z cechami
unique_tracks_features <- left_join(unique_tracks,
                                    tracks_features, 
                                    by = c("trackID" = "id")) %>%
   filter(!is.na(energy)) %>%
   distinct()


# łączymy playlistę z cechami
playlist_tab_features <- left_join(playlist_tab,
                                   unique_tracks_features,
                                   by = c("title" = "title",
                                          "artist" = "artist")) %>%
   filter(!is.na(energy))
   

# zapisujemy sobie na później
saveRDS(playlist_tab_features, "playlist_tab_features.RDS")

playlist_tab_features %>% 
   group_by(stacja) %>% 
   summarise_at(.cols = vars(danceability:tempo), .funs = mean) %>% 
   ungroup() %>%
   gather("feature", "value", -stacja) %>% 
   ggplot() + 
   geom_col(aes(stacja, value, fill = stacja), show.legend = FALSE) + 
   coord_flip() +
   facet_wrap(~feature, scales = "free_x", ncol = 5)

playlist_tab_features %>%
   filter(acousticness == min(acousticness) | acousticness == max(acousticness)) %>% 
   count(song, stacja, acousticness) %>%
   ungroup() %>%
   mutate(acousticness = color_tile("white", "orange")(acousticness)) %>%
   kable(escape = FALSE) %>%
   kable_styling(bootstrap_options = c("striped", "hover"))

playlist_tab_features %>%
   filter(danceability == min(danceability) | danceability == max(danceability)) %>% 
   count(song, stacja, danceability) %>%
   ungroup() %>%
   mutate(danceability = color_tile("white", "orange")(danceability)) %>%
   kable(escape = FALSE) %>%
   kable_styling(bootstrap_options = c("striped", "hover"))

playlist_tab_features %>%
   filter(energy == min(energy) | energy == max(energy)) %>% 
   count(song, stacja, energy) %>%
   ungroup() %>%
   mutate(energy = color_tile("white", "orange")(energy)) %>%
   kable(escape = FALSE) %>%
   kable_styling(bootstrap_options = c("striped", "hover"))

playlist_tab_features %>%
   mutate(hour = hour(datetime)) %>%
   group_by(stacja, hour) %>% 
   summarise(m_energy = mean(energy)) %>% 
   ungroup() %>%
   ggplot() + 
   geom_area(aes(hour, m_energy, fill = stacja), alpha = 0.6, show.legend = FALSE) + 
   geom_line(aes(hour, m_energy, color = stacja), size = 2, show.legend = FALSE) + 
   facet_wrap(~stacja, ncol = 5)