songmap.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "taglib_parser.h"
#include "../helpers/levenshtein.hpp"
#include <cereal/archives/binary.hpp>
#include <cereal/types/map.hpp>
#include <cereal/types/string.hpp>
#include <cereal/types/vector.hpp>
#include <fstream>
#include <iostream>
#include <map>
#include <optional>
#include <set>
#include <string>
#include <vector>

struct Song
{
  unsigned int inode;    
  Metadata     metadata; 

  Song(unsigned int inode, const Metadata& metadata) : inode(inode), metadata(metadata) {}

  Song() : inode(0), metadata() {}

  template <class Archive> void serialize(Archive& ar) { ar(inode, metadata); }
};
struct Song {…};

class SongTree
{
private:
  std::map<std::string, std::map<std::string, std::map<unsigned int, std::map<unsigned int, Song>>>>
    tree;
 
public:
  void addSong(const Song& song)
  {
    tree[song.metadata.artist][song.metadata.album][song.metadata.discNumber][song.metadata.track] =
      song;
  }
  void addSong(const Song& song) {…}

  void display() const
  {
    int                   totalArtists = 0, totalAlbums = 0, totalDiscs = 0, totalSongs = 0;
    std::set<std::string> uniqueGenres; // To count unique genres
 
    std::cout << "\n=== Music Library Overview ===\n";
    std::cout << "─────────────────────────────────────────────────────────────────────────────\n";
 
    for (const auto& artistPair : tree)
    {
      totalArtists++;
      std::cout << "\n🎤 Artist: " << artistPair.first << "\n";
      for (const auto& albumPair : artistPair.second)
      {
        totalAlbums++;
        std::cout << "  ├─── 📀 Album: " << albumPair.first << "\n";
        for (const auto& discPair : albumPair.second)
        {
          totalDiscs++;
          std::cout << "  │    💿 Disc " << discPair.first << "\n";
          for (const auto& trackPair : discPair.second)
          {
            totalSongs++;
            const auto& song = trackPair.second;
            uniqueGenres.insert(song.metadata.genre);
            std::cout << "  │    │    Track " << std::setw(2) << trackPair.first << ": "
                      << song.metadata.title << "\n";
          }
        }
      }
    }
 
    std::cout << "\n=== Library Summary ===\n";
    std::cout << "─────────────────────────────────────────────────────────────────────────────\n";
    std::cout << "🎤 Total Artists: " << totalArtists << "\n";
    std::cout << "📀 Total Albums: " << totalAlbums << "\n";
    std::cout << "💿 Total Discs: " << totalDiscs << "\n";
    std::cout << "🎵 Total Songs: " << totalSongs << "\n";
    std::cout << "🎼 Unique Genres: " << uniqueGenres.size() << "\n";
    std::cout << "=========================\n";
  }
  void display() const {…}

  void printAllArtists() const
  {
    std::cout << "\n=== Artists List ===\n";
    for (const auto& artistPair : tree)
    {
      std::cout << "- " << artistPair.first << "\n";
    }
    std::cout << "=====================\n";
  }
  void printAllArtists() const {…}

  void printSongs(const std::vector<Song>& songs)
  {
    if (songs.empty())
    {
      std::cout << "No songs found.\n";
      return;
    }
 
    // Group songs by album
    std::map<std::string, std::vector<Song>> albums;
    for (const auto& song : songs)
    {
      albums[song.metadata.album].push_back(song);
    }
 
    std::cout << "\n" << "\033[1mSongs List\033[0m:\n";
    std::cout << "─────────────────────────────────────\n";
 
    for (const auto& albumPair : albums)
    {
      const auto& album      = albumPair.first;
      const auto& albumSongs = albumPair.second;
 
      std::cout << "├─── 📀 Album: " << album << "\n";
      std::cout << "└─ Total Songs: " << albumSongs.size() << "\n";
 
      for (const auto& song : albumSongs)
      {
        std::cout << "    │  Track: " << song.metadata.title << "\n";
      }
 
      std::cout << "─────────────────────────────────────\n";
    }
  }
  void printSongs(const std::vector<Song>& songs) {…}

  auto getSongsByArtist(const std::string& artist)
  {
    std::vector<Song> result;
    auto              artistIt = tree.find(artist);
    if (artistIt != tree.end())
    {
      for (const auto& albumPair : artistIt->second)
      {
        for (const auto& discPair : albumPair.second)
        {
          for (const auto& trackPair : discPair.second)
          {
            result.push_back(trackPair.second);
          }
        }
      }
    }
    printSongs(result);
    return result;
  }
  auto getSongsByArtist(const std::string& artist) {…}

  [[nodiscard]] auto getSongsByAlbum(const std::string& artist, const std::string& album) const
  {
    std::vector<Song> result;
    auto              artistIt = tree.find(artist);
    if (artistIt != tree.end())
    {
      auto albumIt = artistIt->second.find(album);
      if (albumIt != artistIt->second.end())
      {
        for (const auto& discPair : albumIt->second)
        {
          for (const auto& trackPair : discPair.second)
          {
            result.push_back(trackPair.second);
          }
        }
      }
    }
    return result;
  }
  [[nodiscard]] auto getSongsByAlbum(const std::string& artist, const std::string& album) const {…}

  void getSongsByGenreAndPrint() const
  {
    std::map<std::string, std::vector<Song>> genreMap;
 
    // Populate genreMap with songs grouped by genre
    for (const auto& artistPair : tree)
    {
      for (const auto& albumPair : artistPair.second)
      {
        for (const auto& discPair : albumPair.second)
        {
          for (const auto& trackPair : discPair.second)
          {
            genreMap[trackPair.second.metadata.genre].push_back(trackPair.second);
          }
        }
      }
    }
 
    std::cout << "\n=== Songs Grouped by Genre ===\n";
    std::cout << "──────────────────────────────────────\n";
 
    // Print each genre and its corresponding songs
    for (const auto& genrePair : genreMap)
    {
      const auto& genre = genrePair.first;
      const auto& songs = genrePair.second;
 
      std::cout << "\n🎶 Genre: " << genre << "\n";
      std::cout << "──────────────────────────────────────\n";
 
      for (const auto& song : songs)
      {
        std::cout << "├─── " << song.metadata.title << " by " << song.metadata.artist
                  << " (Album: " << song.metadata.album << ")\n";
      }
 
      std::cout << "──────────────────────────────────────\n";
    }
  }
  void getSongsByGenreAndPrint() const {…}

  [[nodiscard]] auto returnSongMap() const { return tree; }

  template <class Archive> void serialize(Archive& ar) { ar(tree); }

  void saveToFile(const std::string& filename) const
  {
    std::ofstream file(filename, std::ios::binary);
    if (!file)
    {
      throw std::runtime_error("Failed to open file for saving.");
    }
    cereal::BinaryOutputArchive archive(file);
    archive(*this); // Serialize the SongTree
  }
  void saveToFile(const std::string& filename) const {…}

  void loadFromFile(const std::string& filename)
  {
    std::ifstream file(filename, std::ios::binary);
    if (!file)
    {
      throw std::runtime_error("Failed to open file for loading.");
    }
    cereal::BinaryInputArchive archive(file);
    archive(*this); // Deserialize the SongTree
  }
  void loadFromFile(const std::string& filename) {…}

  void printSongInfo(const std::string& input)
  {
    bool isFilePath = input.find('/') != std::string::npos || input.find('\\') != std::string::npos;
 
    std::optional<Song> foundSong;
 
    if (isFilePath)
    {
      // If input is a file path, retrieve its metadata using inode
      std::cout << std::endl << "> Taking argument as a possible audio file path..." << std::endl;
      struct stat fileStat;
      if (stat(input.c_str(), &fileStat) == 0)
      {
        unsigned int inode = fileStat.st_ino;
        for (const auto& artistPair : tree)
        {
          for (const auto& albumPair : artistPair.second)
          {
            for (const auto& discPair : albumPair.second)
            {
              for (const auto& trackPair : discPair.second)
              {
                if (trackPair.second.inode == inode)
                {
                  foundSong = trackPair.second;
                  break;
                }
              }
            }
          }
        }
      }
    }
    else
    {
      // If input is a song name, search by title
      for (const auto& artistPair : tree)
      {
        for (const auto& albumPair : artistPair.second)
        {
          for (const auto& discPair : albumPair.second)
          {
            for (const auto& trackPair : discPair.second)
            {
              if (levenshteinDistance(trackPair.second.metadata.title, input) < 3) // Recommended limit of correction (else it will go bonkers)
              {
                foundSong = trackPair.second;
                break;
              }
            }
          }
        }
      }
    }
 
    if (foundSong)
    {
      const auto& song = *foundSong;
      std::cout << "\n🎵 Song Information:\n";
      std::cout << "──────────────────────────────────────\n";
      std::cout << "Title     : " << song.metadata.title << "\n";
      std::cout << "Artist    : " << song.metadata.artist << "\n";
      std::cout << "Album     : " << song.metadata.album << "\n";
      std::cout << "Disc      : " << song.metadata.discNumber << "\n";
      std::cout << "Track     : " << song.metadata.track << "\n";
      std::cout << "Genre     : " << song.metadata.genre << "\n";
      std::cout << "Inode     : " << song.inode << "\n";
 
      if (!song.metadata.additionalProperties.empty())
      {
        std::cout << "Additional Properties:\n";
        for (const auto& prop : song.metadata.additionalProperties)
        {
          if (prop.first == "LYRICS")
          {
            std::cout << "\n📜 Lyrics:\n";
            std::cout << "──────────────────────────────────────\n";
 
            // Wrap and format the lyrics
            const std::string& lyrics = prop.second;
            size_t lineLength = 80;
            size_t start = 0;
            while (start < lyrics.size())
            {
              size_t end = start + lineLength;
              if (end > lyrics.size()) end = lyrics.size();
              std::cout << lyrics.substr(start, end - start) << "\n";
              start = end;
            }
            std::cout << "──────────────────────────────────────\n";
          }
          else
          {
            std::cout << "  - " << prop.first << " : " << prop.second << "\n";
          }
        }
      }
      else
      {
        std::cout << "No additional properties found!" << std::endl;
      }
      std::cout << "──────────────────────────────────────\n";
    }
    else
    {
      std::cout << "⚠️  Song not found: " << input << "\n";
    }
  }
  void printSongInfo(const std::string& input) {…}
};
class SongTree {…};