Add youtube subscriptions, etc

7 files changed, 285 insertions, 24 deletions

diff --git a/src/Body.cpp b/src/Body.cpp
index a84256e..aa8d1d6 100644
--- a/src/Body.cpp
+++ b/src/Body.cpp
@@ -844,7 +844,8 @@ namespace QuickMedia {
             //struct tm *now_tm = localtime(&time_now);
 
             time_t message_timestamp = body_item->get_timestamp() / 1000;
-            struct tm *message_tm = localtime(&message_timestamp);
+            struct tm message_tm;
+            localtime_r(&message_timestamp, &message_tm);
 
             //bool is_same_year = message_tm->tm_year == now_tm->tm_year;
             
@@ -855,7 +856,7 @@ namespace QuickMedia {
             else
                 strftime(time_str, sizeof(time_str) - 1, "%a %b %d %H:%M:%S %Y", message_tm);
             */
-            strftime(time_str, sizeof(time_str) - 1, "%a %b %d %H:%M", message_tm);
+            strftime(time_str, sizeof(time_str) - 1, "%a %b %d %H:%M", &message_tm);
 
             if(body_item->timestamp_text)
                 body_item->timestamp_text->setString(time_str);
diff --git a/src/QuickMedia.cpp b/src/QuickMedia.cpp
index 16f19d4..456bdc6 100644
--- a/src/QuickMedia.cpp
+++ b/src/QuickMedia.cpp
@@ -918,6 +918,8 @@ namespace QuickMedia {
             auto recommended_body = create_body();
             fill_recommended_items_from_json(plugin_name, load_recommended_json(), recommended_body->items);
             tabs.push_back(Tab{std::move(recommended_body), std::make_unique<RecommendedPage>(this, tabs.front().page.get()), create_search_bar("Search...", SEARCH_DELAY_FILTER)});
+
+            tabs.push_back(Tab{create_body(), std::make_unique<YoutubeSubscriptionsPage>(this), create_search_bar("Search...", SEARCH_DELAY_FILTER)});
         } else if(strcmp(plugin_name, "pornhub") == 0) {
             auto search_body = create_body();
             tabs.push_back(Tab{std::move(search_body), std::make_unique<PornhubSearchPage>(this), create_search_bar("Search...", 500)});
@@ -1066,7 +1068,7 @@ namespace QuickMedia {
             auto body_item = BodyItem::create(std::move(title_str));
             body_item->url = "https://www.youtube.com/watch?v=" + video_id_str;
             body_item->thumbnail_url = "https://img.youtube.com/vi/" + video_id_str + "/hqdefault.jpg";
-            body_item->set_description(timestamp_to_relative_time_str(std::max(0l, time_now - timestamp.asInt64())));
+            body_item->set_description("Watched " + timestamp_to_relative_time_str(std::max(0l, time_now - timestamp.asInt64())));
             body_item->thumbnail_size = sf::Vector2i(175, 131);
             body_items.push_back(std::move(body_item));
         }
@@ -1595,14 +1597,8 @@ namespace QuickMedia {
                     } else if(event.key.code == sf::Keyboard::T && event.key.control) {
                         BodyItem *selected_item = tabs[selected_tab].body->get_selected();
                         if(selected_item && tabs[selected_tab].page && tabs[selected_tab].page->is_trackable()) {
-                            TrackablePage *trackable_page = static_cast<TrackablePage*>(tabs[selected_tab].page.get());
-                            TrackResult track_result = trackable_page->track(selected_item->get_title());
-                            // TODO: Show proper error message when this fails. For example if we are already tracking the manga
-                            if(track_result == TrackResult::OK) {
-                                show_notification("QuickMedia", "You are now tracking \"" + trackable_page->content_title + "\" after \"" + selected_item->get_title() + "\"", Urgency::LOW);
-                            } else {
-                                show_notification("QuickMedia", "Failed to track media \"" + trackable_page->content_title + "\", chapter: \"" + selected_item->get_title() + "\"", Urgency::CRITICAL);
-                            }
+                            TrackablePage *trackable_page = dynamic_cast<TrackablePage*>(tabs[selected_tab].page.get());
+                            trackable_page->track(selected_item->get_title());
                         }
                     }
                 }
diff --git a/src/StringUtils.cpp b/src/StringUtils.cpp
index 56d746c..84e2ce5 100644
--- a/src/StringUtils.cpp
+++ b/src/StringUtils.cpp
@@ -16,6 +16,17 @@ namespace QuickMedia {
         }
     }
 
+    size_t string_replace_all(std::string &str, char old_char, char new_char) {
+        size_t num_replaced_substrings = 0;
+        for(char &c : str) {
+            if(c == old_char) {
+                c = new_char;
+                ++num_replaced_substrings;
+            }
+        }
+        return num_replaced_substrings;
+    }
+
     size_t string_replace_all(std::string &str, char old_char, const std::string &new_str) {
         size_t num_replaced_substrings = 0;
         size_t index = 0;
diff --git a/src/plugins/Manga.cpp b/src/plugins/Manga.cpp
index f3c6814..2c7bae0 100644
--- a/src/plugins/Manga.cpp
+++ b/src/plugins/Manga.cpp
@@ -1,13 +1,17 @@
 #include "../../plugins/Manga.hpp"
 #include "../../include/Program.hpp"
+#include "../../include/Notification.hpp"
 
 namespace QuickMedia {
     TrackResult MangaChaptersPage::track(const std::string &str) {
         const char *args[] = { "automedia", "add", "html", content_url.data(), "--start-after", str.data(), "--name", content_title.data(), nullptr };
-        if(exec_program(args, nullptr, nullptr) == 0)
+        if(exec_program(args, nullptr, nullptr) == 0) {
+            show_notification("QuickMedia", "You are now tracking \"" + content_title + "\" after \"" + str + "\"", Urgency::LOW);
             return TrackResult::OK;
-        else
+        } else {
+            show_notification("QuickMedia", "Failed to track media \"" + content_title + "\", chapter: \"" + str + "\"", Urgency::CRITICAL);
             return TrackResult::ERR;
+        }
     }
 
     void MangaChaptersPage::on_navigate_to_page(Body *body) {
diff --git a/src/plugins/Matrix.cpp b/src/plugins/Matrix.cpp
index 3c4a6dd..4a414da 100644
--- a/src/plugins/Matrix.cpp
+++ b/src/plugins/Matrix.cpp
@@ -64,7 +64,10 @@ namespace QuickMedia {
 
     std::string extract_first_line_remove_newline_elipses(const std::string &str, size_t max_length) {
         std::string result = str;
-        string_replace_all(result, '\n', " ");
+        string_replace_all(result, '\n', ' ');
+        string_replace_all(result, '\t', ' ');
+        string_replace_all(result, '\v', ' ');
+        string_replace_all(result, '\r', ' ');
         size_t index = result.find('\n');
         if(index == std::string::npos) {
             if(result.size() > max_length)
diff --git a/src/plugins/Soundcloud.cpp b/src/plugins/Soundcloud.cpp
index 90fe144..e0a4d24 100644
--- a/src/plugins/Soundcloud.cpp
+++ b/src/plugins/Soundcloud.cpp
@@ -299,14 +299,14 @@ namespace QuickMedia {
             if(result != 0)
                 return PluginResult::ERR;
 
-            async_download_threads.clear();
+            async_download_tasks.clear();
             for(std::string &script_source : script_sources) {
                 if(string_starts_with(script_source, "//"))
                     script_source = "https://" + script_source.substr(2);
                 else if(string_starts_with(script_source, "/"))
                     script_source = "https://soundcloud.com/" + script_source.substr(1);
 
-                async_download_threads.push_back(AsyncTask<std::string>([script_source]() -> std::string {
+                async_download_tasks.push_back(AsyncTask<std::string>([script_source]() -> std::string {
                     std::string website_data;
                     DownloadResult download_result = download_to_string(script_source, website_data, {}, true);
                     if(download_result != DownloadResult::OK) return "";
@@ -321,9 +321,9 @@ namespace QuickMedia {
                 }));
             }
 
-            for(auto &download_thread : async_download_threads) {
-                if(download_thread.valid()) {
-                    std::string fetched_client_id = download_thread.get();
+            for(auto &download_task : async_download_tasks) {
+                if(download_task.valid()) {
+                    std::string fetched_client_id = download_task.get();
                     if(client_id.empty() && !fetched_client_id.empty())
                         client_id = std::move(fetched_client_id);
                 }
diff --git a/src/plugins/Youtube.cpp b/src/plugins/Youtube.cpp
index f7d38aa..9e07400 100644
--- a/src/plugins/Youtube.cpp
+++ b/src/plugins/Youtube.cpp
@@ -3,6 +3,10 @@
 #include "../../include/NetUtils.hpp"
 #include "../../include/StringUtils.hpp"
 #include "../../include/Scale.hpp"
+#include "../../include/Notification.hpp"
+extern "C" {
+#include <HtmlParser.h>
+}
 #include <json/writer.h>
 #include <string.h>
 #include <unistd.h>
@@ -138,9 +142,10 @@ namespace QuickMedia {
                 return nullptr;
 
             time_t start_time = strtol(start_time_json.asCString(), nullptr, 10);
-            struct tm *message_tm = localtime(&start_time);
+            struct tm message_tm;
+            localtime_r(&start_time, &message_tm);
             char time_str[128] = {0};
-            strftime(time_str, sizeof(time_str) - 1, "%a %b %d %H:%M", message_tm);
+            strftime(time_str, sizeof(time_str) - 1, "%a %b %d %H:%M", &message_tm);
             string_replace_all(upcoming_event_text.value(), "DATE_PLACEHOLDER", time_str);
             scheduled_text = std::move(upcoming_event_text.value());
         }
@@ -344,8 +349,8 @@ namespace QuickMedia {
             };
 
             // TODO: Is there any way to bypass this? this is needed to set VISITOR_INFO1_LIVE which is required to read comments
-            std::string response;
-            DownloadResult result = download_to_string("https://youtube.com/subscription_manager?disable_polymer=1", response, std::move(additional_args), true);
+            std::string website_data;
+            DownloadResult result = download_to_string("https://youtube.com/subscription_manager?disable_polymer=1", website_data, std::move(additional_args), true);
             if(result != DownloadResult::OK)
                 fprintf(stderr, "Failed to fetch cookies to view youtube comments\n");
         }
@@ -1143,6 +1148,247 @@ namespace QuickMedia {
         return PluginResult::OK;
     }
 
+    TrackResult YoutubeChannelPage::track(const std::string&) {
+        size_t channel_id_start = url.find("/channel/");
+        if(channel_id_start == std::string::npos) {
+            show_notification("QuickMedia", "Unable to get channel id from " + url, Urgency::CRITICAL);
+            return TrackResult::ERR;
+        }
+
+        channel_id_start += 9;
+        size_t channel_id_end = url.find('/', channel_id_start);
+        if(channel_id_end == std::string::npos) channel_id_end = url.size();
+        std::string channel_id = url.substr(channel_id_start, channel_id_end - channel_id_start);
+        if(channel_id.empty()) {
+            show_notification("QuickMedia", "Unable to get channel id from " + url, Urgency::CRITICAL);
+            return TrackResult::ERR;
+        }
+
+        Path subscriptions_path = get_storage_dir().join("subscriptions");
+        if(create_directory_recursive(subscriptions_path) != 0) {
+            show_notification("QuickMedia", "Failed to create directory: " + subscriptions_path.data, Urgency::CRITICAL);
+            return TrackResult::ERR;
+        }
+
+        subscriptions_path.join("youtube.txt");
+        std::unordered_set<std::string> channel_ids;
+        std::string subscriptions_str;
+
+        if(file_get_content(subscriptions_path, subscriptions_str) == 0) {
+            string_split(subscriptions_str, '\n', [&channel_ids](const char *str, size_t size) {
+                std::string line(str, size);
+                line = strip(line);
+                if(!line.empty())
+                    channel_ids.insert(std::move(line));
+                return true;
+            });
+        }
+
+        auto it = channel_ids.find(channel_id);
+        if(it == channel_ids.end()) {
+            channel_ids.insert(channel_id);
+            show_notification("QuickMedia", "Subscribed", Urgency::LOW);
+        } else {
+            channel_ids.erase(it);
+            show_notification("QuickMedia", "Unsubscribed", Urgency::LOW);
+        }
+
+        std::string channel_ids_str;
+        for(auto &it : channel_ids) {
+            if(!channel_ids_str.empty())
+                channel_ids_str += '\n';
+            channel_ids_str += std::move(it);
+        }
+
+        if(file_overwrite_atomic(subscriptions_path, channel_ids_str) != 0) {
+            show_notification("QuickMedia", "Failed to update subscriptions list with " + channel_id, Urgency::CRITICAL);
+            return TrackResult::ERR;
+        }
+
+        return TrackResult::OK;
+    }
+
+    PluginResult YoutubeSubscriptionsPage::submit(const std::string&, const std::string &url, std::vector<Tab> &result_tabs) {
+        result_tabs.push_back(Tab{nullptr, std::make_unique<YoutubeVideoPage>(program, url), nullptr});
+        return PluginResult::OK;
+    }
+
+    struct SubscriptionEntry {
+        std::string title;
+        std::string video_id;
+        time_t published = 0;
+    };
+
+    struct SubscriptionData {
+        SubscriptionEntry subscription_entry;
+        bool inside_entry = false;
+    };
+
+    static int string_view_equals(HtmlStringView *self, const char *sub) {
+        const size_t sub_len = strlen(sub);
+        return self->size == sub_len && memcmp(self->data, sub, sub_len) == 0;
+    }
+
+    // Returns relative time as a string (approximation)
+    static std::string timestamp_to_relative_time_str(time_t seconds) {
+        time_t minutes = seconds / 60;
+        time_t hours = minutes / 60;
+        time_t days = hours / 24;
+        time_t months = days / 30;
+        time_t years = days / 365;
+
+        if(years >= 1)
+            return std::to_string(years) + " year" + (years == 1 ? "" : "s") + " ago";
+        else if(months >= 1)
+            return std::to_string(months) + " month" + (months == 1 ? "" : "s") + " ago";
+        else if(days >= 1)
+            return std::to_string(days) + " day" + (days == 1 ? "" : "s") + " ago";
+        else if(hours >= 1)
+            return std::to_string(hours) + " hour" + (hours == 1 ? "" : "s") + " ago";
+        else if(minutes >= 1)
+            return std::to_string(minutes) + " minute" + (minutes == 1 ? "" : "s") + " ago";
+        else
+            return std::to_string(seconds) + " second" + (seconds == 1 ? "" : "s") + " ago";
+    }
+
+    PluginResult YoutubeSubscriptionsPage::lazy_fetch(BodyItems &result_items) {
+        Path subscriptions_path = get_storage_dir().join("subscriptions").join("youtube.txt");
+        std::string subscriptions_str;
+        if(file_get_content(subscriptions_path, subscriptions_str) != 0)
+            return PluginResult::OK;
+
+        // TODO: Make a async task pool to handle this more efficiently
+        std::vector<std::string> channel_ids;
+        string_split(subscriptions_str, '\n', [&channel_ids](const char *str, size_t size) {
+            std::string line(str, size);
+            line = strip(line);
+            if(!line.empty())
+                channel_ids.push_back(std::move(line));
+            return true;
+        });
+
+        std::vector<YoutubeSubscriptionTaskResult> task_results;
+        size_t async_task_index = 0;
+        const time_t time_now = time(nullptr);
+
+        for(const std::string &channel_id : channel_ids) {
+            subscription_load_tasks[async_task_index] = AsyncTask<std::vector<YoutubeSubscriptionTaskResult>>([&channel_id, time_now]() -> std::vector<YoutubeSubscriptionTaskResult> {
+                std::string website_data;
+                DownloadResult result = download_to_string("https://www.youtube.com/feeds/videos.xml?channel_id=" + url_param_encode(channel_id), website_data, {}, false);
+                if(result != DownloadResult::OK) {
+                    auto body_item = BodyItem::create("Failed to fetch videos for channel: " + channel_id);
+                    return {YoutubeSubscriptionTaskResult{body_item, 0}};
+                }
+
+                std::vector<SubscriptionData> subscription_data_list;
+
+                HtmlParser html_parser;
+                html_parser_init(&html_parser, website_data.data(), website_data.size(), [](HtmlParser *html_parser, HtmlParseType parse_type, void *userdata) {
+                    std::vector<SubscriptionData> &subscription_data_list = *(std::vector<SubscriptionData>*)userdata;
+
+                    if(parse_type == HTML_PARSE_TAG_START && string_view_equals(&html_parser->tag_name, "entry")) {
+                        subscription_data_list.push_back({});
+                        subscription_data_list.back().inside_entry = true;
+                        return;
+                    } else if(parse_type == HTML_PARSE_TAG_END && string_view_equals(&html_parser->tag_name, "entry")) {
+                        subscription_data_list.back().inside_entry = false;
+                        return;
+                    }
+
+                    if(subscription_data_list.empty() || !subscription_data_list.back().inside_entry)
+                        return;
+
+                    if(string_view_equals(&html_parser->tag_name, "title") && parse_type == HTML_PARSE_TAG_END) {
+                        subscription_data_list.back().subscription_entry.title.assign(html_parser->text_stripped.data, html_parser->text_stripped.size);
+                    } else if(string_view_equals(&html_parser->tag_name, "yt:videoId") && parse_type == HTML_PARSE_TAG_END) {
+                        subscription_data_list.back().subscription_entry.video_id.assign(html_parser->text_stripped.data, html_parser->text_stripped.size);
+                    } else if(string_view_equals(&html_parser->tag_name, "published") && parse_type == HTML_PARSE_TAG_END) {
+                        std::string published_str(html_parser->text_stripped.data, html_parser->text_stripped.size);
+
+                        int year = 0;
+                        int month = 0;
+                        int day = 0;
+                        int hour = 0;
+                        int minute = 0;
+                        int second = 0;
+                        sscanf(published_str.c_str(), "%d-%d-%dT%d:%d:%d", &year, &month, &day, &hour, &minute, &second);
+                        if(year == 0) return;
+                        
+                        struct tm time;
+                        memset(&time, 0, sizeof(time));
+                        time.tm_year = year - 1900;
+                        time.tm_mon = month - 1;
+                        time.tm_mday = day;
+                        time.tm_hour = hour;
+                        time.tm_min = minute;
+                        time.tm_sec = second;
+                        time_t unixtime = mktime(&time);
+
+                        struct tm entry_time;
+                        localtime_r(&unixtime, &entry_time);
+                        time_t unixtime_local = mktime(&entry_time);
+
+                        subscription_data_list.back().subscription_entry.published = unixtime_local;
+                    }
+                }, &subscription_data_list);
+                html_parser_parse(&html_parser);
+                html_parser_deinit(&html_parser);
+
+                /*std::sort(subscription_data_list.begin(), subscription_data_list.end(), [](const SubscriptionData &sub_data1, const SubscriptionData &sub_data2) {
+                    return sub_data1.subscription_entry.published > sub_data2.subscription_entry.published;
+                });*/
+
+                std::vector<YoutubeSubscriptionTaskResult> results;
+                for(SubscriptionData &subscription_data : subscription_data_list) {
+                    if(subscription_data.subscription_entry.title.empty() || subscription_data.subscription_entry.video_id.empty() || subscription_data.subscription_entry.published == 0)
+                        continue;
+
+                    html_unescape_sequences(subscription_data.subscription_entry.title);
+                    auto body_item = BodyItem::create(std::move(subscription_data.subscription_entry.title));
+                    body_item->set_description("Uploaded " + timestamp_to_relative_time_str(time_now - subscription_data.subscription_entry.published));
+                    body_item->set_description_color(sf::Color(179, 179, 179));
+                    body_item->url = "https://www.youtube.com/watch?v=" + subscription_data.subscription_entry.video_id;
+                    body_item->thumbnail_url = "https://img.youtube.com/vi/" + subscription_data.subscription_entry.video_id + "/hqdefault.jpg";
+                    body_item->thumbnail_size = sf::Vector2i(175, 131);
+                    results.push_back({std::move(body_item), subscription_data.subscription_entry.published});
+                }
+                return results;
+            });
+            ++async_task_index;
+            
+            if(async_task_index == subscription_load_tasks.size()) {
+                async_task_index = 0;
+                for(auto &load_task : subscription_load_tasks) {
+                    if(!load_task.valid())
+                        continue;
+
+                    auto new_task_results = load_task.get();
+                    task_results.insert(task_results.end(), std::move_iterator(new_task_results.begin()), std::move_iterator(new_task_results.end()));
+                }
+            }
+        }
+
+        for(size_t i = 0; i < async_task_index; ++i) {
+            auto &load_task = subscription_load_tasks[i];
+            if(!load_task.valid())
+                continue;
+
+            auto new_task_results = load_task.get();
+            task_results.insert(task_results.end(), std::move_iterator(new_task_results.begin()), std::move_iterator(new_task_results.end()));
+        }
+
+        std::sort(task_results.begin(), task_results.end(), [](const YoutubeSubscriptionTaskResult &sub_data1, const YoutubeSubscriptionTaskResult &sub_data2) {
+            return sub_data1.timestamp > sub_data2.timestamp;
+        });
+
+        result_items.reserve(task_results.size());
+        for(auto &task_result : task_results) {
+            result_items.push_back(std::move(task_result.body_item));
+        }
+
+        return PluginResult::OK;
+    }
+
     PluginResult YoutubeRelatedVideosPage::submit(const std::string&, const std::string &url, std::vector<Tab> &result_tabs) {
         result_tabs.push_back(Tab{nullptr, std::make_unique<YoutubeVideoPage>(program, url), nullptr});
         return PluginResult::OK;
@@ -1292,7 +1538,7 @@ namespace QuickMedia {
         return std::make_unique<YoutubeRelatedVideosPage>(program);
     }
 
-    std::unique_ptr<LazyFetchPage> YoutubeVideoPage::create_channels_page(Program *program, const std::string &channel_url) {
+    std::unique_ptr<Page> YoutubeVideoPage::create_channels_page(Program *program, const std::string &channel_url) {
         return std::make_unique<YoutubeChannelPage>(program, channel_url, "", "Channel videos");
     }
 }
\ No newline at end of file