main.cpp

#include <iostream>
#include <cstring>
#include <vector>
#include <random>
#include <limits>
#include <cmath>
#include <algorithm>
#include <memory>

#include "Song.h"
#include "Artist.h"
#include "Album.h"
#include "Playlist.h"
#include "Audio.h"
#include "Vector.hpp"

int main()
{
    std::cout << "My Playlist:" << '\n';
    Playlist p;
    p.load_from_file("playlist.txt");

    for (int i = 0; i < p.size(); i++)
        std::cout << i + 1 << ") " << p[i] << '\n';

    std::cout << '\n';
    std::cout << "Choose what you want to do:" << '\n';
    std::cout << "Play a song (1)" << '\n';
    std::cout << "Shuffle playlist (2)" << '\n';
    std::cout << "Add a song (3)" << '\n';
    std::cout << "Download playlist (4)" << '\n';
    std::cout << "Make the playlist collaborative (5)" << '\n';
    std::cout << "Listen to a podcast instead (6)" << '\n';
    std::cout << "Search for a song (7)" << '\n';
    std::cout << "Sort playlist (8)" << '\n';
    std::cout << "Queue management (9)" << '\n';
    std::cout << "Show Top Stats (10)" << '\n';
    std::cout << "Exit (0)" << '\n';

    int choice;
    std::vector<Song> play_queue;
    while (std::cout << "\nChoice: " && std::cin >> choice && choice != 0)
    {
        if (choice == 1)
        {
            std::cout << "Choose the song number (1-" << p.size() << "):" << '\n';
            int index;
            std::cin >> index;
            index--;
            if (index < 0 || index >= p.size())
            {
                std::cout << "Invalid index" << std::endl;
            }
            else
            {
                std::cout << "Now Playing: " << p[index] << '\n';
                std::cout << "By: ";
                p[index].get_artist().print();
                std::cout << '\n';
                std::cout << "From album: " << p[index].get_album() << '\n';
                std::cout << "Duration: " << p[index].get_time() / 60 << ":" << (p[index].get_time() % 60 < 10 ? "0" : "") << p[index].get_time() % 60 << " minutes" << '\n';
                p[index].increment_play_count();

                std::cout << "Skip song? y/n" << '\n';

                char answer;
                std::cin >> answer;

                while (answer == 'y')
                {
                    try {
                        p.skip_song(index);
                        index++;
                        std::cout << "Skip song? y/n" << '\n';
                        std::cin >> answer;
                    } catch (const std::out_of_range& e) {
                        std::cout << e.what() << std::endl;
                        break;
                    }
                }
            }
        }
        else if (choice == 2)
        {
            if (p.size() == 0) {
                std::cout << "Playlist is empty" << std::endl;
            } else {
                std::random_device r;
                std::default_random_engine e1(r());
                std::uniform_int_distribution<int> uniform_dist(0, p.size() - 1);
                int random_index = uniform_dist(e1);

                std::cout << "Now Playing: " << p[random_index] << '\n';
                std::cout << "By: ";
                p[random_index].get_artist().print();
                std::cout << '\n';
                std::cout << "From album: " << p[random_index].get_album() << '\n';
                int t = p[random_index].get_time();
                std::cout << "Duration: " << t / 60 << ":" << (t % 60 < 10 ? "0" : "") << t % 60 << " minutes" << '\n';
            }
        }

        else if (choice == 3)
        {
            std::string input_song;
            std::cout << "Enter song name:" << '\n';
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            std::getline(std::cin, input_song);

            std::string artist_name;
            std::cout << "Enter artist name:" << '\n';
            std::getline(std::cin, artist_name);
            Artist artist9(artist_name);

            std::string album_name;
            std::cout << "Enter album name:" << '\n';
            std::getline(std::cin, album_name);
            Album album9(album_name);

            Song song9(input_song, artist9, album9);

            float input_time;
            std::cout << "Enter the song's duration (ex 4.20 for 4 min 20 sec):" << '\n';
            std::cin >> input_time;
            
            int minutes = (int)input_time;
            int seconds = (int)round((input_time - minutes) * 100);
            song9.set_time(minutes * 60 + seconds);

            try {
                p.add_song(song9);
                std::cout << "Song added successfully" << std::endl;
            } catch (const std::exception& e) {
                std::cout << "Error: " << e.what() << std::endl;
            }
        }
        else if (choice == 4)
        {
            std::cout << "--Playlist downloaded--" << '\n';
            p.save_to_file("playlist.txt");
            std::cout << "Changes saved to playlist.txt" << std::endl;
            std::cout << "Number of songs in playlist: " << p.size() << '\n';
            int total = Playlist::total_duration(p);
            std::cout << "Playlist duration: " << total / 60 << " minutes and " << total % 60 << " seconds" << std::endl;
        }

        else if (choice == 5)
        {
            std::string your_name;
            std::cout << "Enter your name: " << '\n';
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            std::getline(std::cin, your_name);
            if (your_name == "")
            {
                 std::cout << "Username cannot be empty" << std::endl;
            }
            else
            {
                CollaborativePlaylist cp;
                cp.share_song(your_name);
            }
        }
        else if (choice == 6)
        {
            std::string podcast_name;
            std::string podcast_host;
            int nr_of_eps;
            std::cout << "Enter the name of the podcast: " << '\n';
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            std::getline(std::cin, podcast_name);

            std::cout << "Enter the host of the podcast: " << '\n';
            std::getline(std::cin, podcast_host);

            std::cout << "Enter the number of episodes: " << '\n';
            if (!(std::cin >> nr_of_eps)) {
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                std::cout << "Invalid input for episodes" << std::endl;
            } else {
                try
                {
                    if (nr_of_eps < 1)
                    {
                        throw std::invalid_argument("Number of episodes must be >= 1");
                    }

                    Podcast pod(podcast_name, podcast_host, nr_of_eps);
                    std::cout << "--Now listening to: " << '\n';
                    pod.print_details();
                    std::cout << std::endl;
                    int pod_index = 1;

                    std::cout << " Episode " << pod_index << "/" << pod.get_nr_of_ep() << '\n';
                    std::cout << "Next episode? (y/n)" << '\n';

                    char pod_answer;
                    std::cin >> pod_answer;
                    while (pod_answer == 'y')
                    {
                        pod_index++;
                        if (pod_index > pod.get_nr_of_ep())
                        {
                            std::cout << "There are no more episodes left" << std::endl;
                            break;
                        }
                        else
                        {
                            std::cout << "Now playing episode " << pod_index << "/" << pod.get_nr_of_ep() << '\n';
                            std::cout << "Next episode? (y/n)" << '\n';
                            std::cin >> pod_answer;
                        }
                    }
                }
                catch (const std::invalid_argument &e)
                {
                    std::cout << "Error: " << e.what() << std::endl;
                }
            }
        }
        else if (choice == 7)
        {
            std::string query;
            std::cout << "Enter search query: ";
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            std::getline(std::cin, query);
            
            std::vector<int> results = p.search_song(query);
            if (results.empty()) {
                std::cout << "No songs found" << std::endl;
            } else {
                std::cout << "Found " << results.size() << " songs:" << std::endl;
                for (int idx : results) {
                    std::cout << idx + 1 << ") " << p[idx] << " by " << p[idx].get_artist() << std::endl;
                }
            }
        }
        else if (choice == 8)
        {
            std::cout << "Sort by: (1) Title, (2) Duration: ";
            int sort_choice;
            std::cin >> sort_choice;
            if (sort_choice == 1) {
                p.sort_by_title();
                std::cout << "Playlist sorted by title" << std::endl;
            } else if (sort_choice == 2) {
                p.sort_by_duration();
                std::cout << "Playlist sorted by duration" << std::endl;
            } else {
                std::cout << "Invalid sort choice" << std::endl;
            }
            
            std::cout << "\nUpdated Playlist" << std::endl;
            for (int i = 0; i < p.size(); i++)
                std::cout << i + 1 << ") " << p[i] << " by " << p[i].get_artist() << '\n';
        }
        else if (choice == 9)
        {
            std::cout << "Queue Management:\n (1) Add to queue\n (2) View queue\n (3) Play next\n (4) Clear queue\n";
            int q_choice;
            std::cin >> q_choice;
            if (q_choice == 1) {
                std::cout << "Enter song number to add (1-" << p.size() << "): ";
                int idx;
                std::cin >> idx;
                if (idx >= 1 && idx <= p.size()) {
                    play_queue.push_back(p[idx-1]);
                    std::cout << "Added to queue: " << p[idx-1] << std::endl;
                } else {
                    std::cout << "Invalid song number" << std::endl;
                }
            } else if (q_choice == 2) {
                if (play_queue.empty()) {
                    std::cout << "Queue is empty" << std::endl;
                } else {
                    std::cout << "Current Queue:" << std::endl;
                    for (size_t i = 0; i < play_queue.size(); i++) {
                        std::cout << i + 1 << ") " << play_queue[i] << " by " << play_queue[i].get_artist() << std::endl;
                    }
                }
            } else if (q_choice == 3) {
                if (play_queue.empty()) {
                    std::cout << "Queue is empty" << std::endl;
                } else {
                    Song next = play_queue[0];
                    play_queue.erase(play_queue.begin());
                    std::cout << "Now Playing from Queue: " << next << std::endl;
                    std::cout << "By: ";
                    next.get_artist().print();
                    std::cout << "\nDuration: " << next.get_time() / 60 << ":" << (next.get_time() % 60 < 10 ? "0" : "") << next.get_time() % 60 << std::endl;
                    
                    std::vector<int> results = p.search_song(next.get_name());
                    if (!results.empty()) {
                        p[results[0]].increment_play_count();
                    }
                }
            } else if (q_choice == 4) {
                play_queue.clear();
                std::cout << "Queue cleared" << std::endl;
            } else {
                std::cout << "Invalid choice" << std::endl;
            }
        }
        else if (choice == 10)
        {
            p.show_top_songs(5);
            p.show_top_artists(5);
        }
        else {
            std::cout << "Invalid choice" << std::endl;
        }
    }
    return 0;
}