arg-handler.hpp

Go to the documentation of this file.

#pragma once
 
#include "./cmd-line-args.hpp"
#include "dirsort/songmap.hpp"
#include <filesystem>
#include <iostream>
#include <string_view>
#include <unordered_map>
 
// Constants
constexpr const char* DBUS_SERVICE_NAME =
  "org.mpris.MediaPlayer2.inLimbo"; 
constexpr const char* VERSION_FILE_NAME = "VERSION";
constexpr const char* REPOSITORY_URL    = "https://github.com/nots1dd/inLimbo";
 
bool shouldRunApp =
  false; 
bool parseSongTree = false;
 
struct SongTreeState
{
  bool        printSongTree      = false;
  bool        printArtistsAll    = false;
  bool        printSongsByArtist = false;
  bool        printSongsGenreAll = false;
  bool printSongInfo = false;
  std::string artist;
  std::string song;
};

enum class ConsoleColor
{
  Reset,  
  Green,  
  Blue,   
  Yellow, 
  Red,    
  Cyan,   
  Magenta 
};

class ColorManager
{
public:
  static auto getColor(ConsoleColor color) -> std::string_view
  {
    static const std::unordered_map<ConsoleColor, std::string_view> colorCodes = {
      {ConsoleColor::Reset, "\033[0m"},   {ConsoleColor::Green, "\033[32m"},
      {ConsoleColor::Blue, "\033[34m"},   {ConsoleColor::Yellow, "\033[33m"},
      {ConsoleColor::Red, "\033[31m"},    {ConsoleColor::Cyan, "\033[36m"},
      {ConsoleColor::Magenta, "\033[35m"}};
    return colorCodes.at(color);
  }
};

class ArgumentHandler
{
public:
  struct Paths
  {
    std::string configPath; 
    std::string libBinPath; 
    std::string cacheDir;   
  };
 
  static inline SongTreeState song_tree_parse_state = {};

  static void handleArguments(const CommandLineArgs& cmdArgs, const std::string& programName,
                              const Paths& paths)
  {
    const std::unordered_map<std::string, std::function<void()>> argumentHandlers = {
      {"--help", [&]() { handleHelp(cmdArgs, programName); }},
      {"--version", [&]() { handleVersion(); }},
      {"--clear-cache", [&]() { handleClearCache(paths.libBinPath); }},
      {"--show-config-file", [&]() { handleShowConfig(paths.configPath); }},
      {"--show-log-dir", [&]() { handleShowLogDir(paths.cacheDir); }},
      {"--show-dbus-name", [&]() { handleShowDBusName(); }},
      {"--update-cache-run", [&]() { handleUpdateCacheRun(paths.libBinPath); }},
      {"--print-song-tree", [&]() { handlePrintSongTree(); }},
      {"--print-artists-all", [&]() { handlePrintArtistsAll(); }},
      {"--print-songs-by-genre-all", [&]() { handlePrintSongsByGenreAll(); }},
      {"--print-songs-by-artist",
       [&]() { handlePrintSongsByArtist(cmdArgs.get("--print-songs-by-artist")); }},
      {"--print-song-info", [&]() { handleSongInfo(cmdArgs.get("--print-song-info")); }}};
 
    for (const auto& [flag, handler] : argumentHandlers)
    {
      if (cmdArgs.hasFlag(flag))
      {
        handler();
        if (!shouldRunApp)
          exit(0);
      }
    }
  }
 
  static auto processSongTreeArguments(SongTree& song_tree) -> void
  {
    if (ArgumentHandler::song_tree_parse_state.printSongTree)
    {
      song_tree.display();
    }
 
    if (ArgumentHandler::song_tree_parse_state.printArtistsAll)
    {
      song_tree.printAllArtists();
    }
 
    if (ArgumentHandler::song_tree_parse_state.printSongsByArtist)
    {
      song_tree.getSongsByArtist(ArgumentHandler::song_tree_parse_state.artist);
    }
 
    if (ArgumentHandler::song_tree_parse_state.printSongsGenreAll)
    {
      song_tree.getSongsByGenreAndPrint();
    }
    if (ArgumentHandler::song_tree_parse_state.printSongInfo)
    {
      song_tree.printSongInfo(ArgumentHandler::song_tree_parse_state.song);
    }
  }
 
private:
  static void colorPrint(ConsoleColor color, std::string_view label, std::string_view value = "")
  {
    std::cout << ColorManager::getColor(color) << label
              << ColorManager::getColor(ConsoleColor::Reset) << value << "\n";
  }

  static void handleHelp(const CommandLineArgs& cmdArgs, const std::string& programName)
  {
    cmdArgs.printUsage(programName);
  }
 
  static auto readVersionFromFile() -> std::string
  {
    std::ifstream versionFile(VERSION_FILE_NAME); // Open the VERSION file
    if (!versionFile)
    {
      std::cerr << "Error: Unable to open VERSION file!" << std::endl;
      return "Unknown Version"; // Return default version if file can't be opened
    }
 
    std::stringstream buffer;
    buffer << versionFile.rdbuf(); // Read the file content into a string stream
    return buffer.str();           // Return the string content
  }

  static void handleVersion()
  {
    std::string version = readVersionFromFile();
    colorPrint(ConsoleColor::Cyan, "inLimbo version: ", version);
  }

  static void handleShowConfig(const std::string& configPath)
  {
    colorPrint(ConsoleColor::Green, "Config file location: ", configPath);
  }

  static void handleShowLogDir(const std::string& cacheDir)
  {
    colorPrint(ConsoleColor::Blue, "Log directory: ", cacheDir);
  }

  static void handleShowDBusName()
  {
    colorPrint(ConsoleColor::Magenta, "DBus name: ", DBUS_SERVICE_NAME);
  }

  static void handleClearCache(const std::string& libBinPath)
  {
    try
    {
      if (std::filesystem::exists(libBinPath))
      {
        std::filesystem::remove(libBinPath);
        colorPrint(ConsoleColor::Green, "Cache cleared successfully: ", libBinPath);
      }
      else
      {
        colorPrint(ConsoleColor::Yellow, "No cache file found to clear: ", libBinPath);
      }
    }
    catch (const std::filesystem::filesystem_error& e)
    {
      colorPrint(ConsoleColor::Red, "Error clearing cache: ", e.what());
    }
  }

  static void handleUpdateCacheRun(const std::string& libBinPath)
  {
    std::cout << ColorManager::getColor(ConsoleColor::Blue)
              << "-- Updating Cache and running app..."
              << ColorManager::getColor(ConsoleColor::Reset) << std::endl;
    handleClearCache(libBinPath);
    shouldRunApp = true;
  }
 
  static void parseSongMap()
  {
    parseSongTree = true;
    shouldRunApp = true;
  }
 
  static void handlePrintSongTree()
  {
    song_tree_parse_state.printSongTree = true;
    parseSongMap();
  }
 
  static void handlePrintArtistsAll()
  {
    parseSongMap();
    song_tree_parse_state.printArtistsAll = true;
  }
 
  static void handlePrintSongsByArtist(std::string artistName)
  {
    parseSongMap();
    song_tree_parse_state.printSongsByArtist = true;
    song_tree_parse_state.artist             = artistName;
  }
  static void handlePrintSongsByGenreAll()
  {
    parseSongMap();
    song_tree_parse_state.printSongsGenreAll = true;
  }
  static void handleSongInfo(std::string songName)
  {
    parseSongMap();
    song_tree_parse_state.printSongInfo = true;
    song_tree_parse_state.song = songName;
  }
};