state.hpp

Go to the documentation of this file.

#pragma once
 
#include "../../dirsort/songmap.hpp"
#include "../../helpers/trie.hpp"
#include <ftxui/component/component.hpp>
#include <mutex>
#include <string>
#include <unordered_map>
 
using namespace ftxui;
 
using namespace std;

struct ComponentState
{
  Component artists_list;      
  Component songs_list;        
  Component songs_queue_comp;  
  Component lyrics_scroller;   
  Component MainRenderer;      
  Component ThumbnailRenderer; 
  Component audioDeviceMenu;   
};

struct PlayingState
{
  std::string  artist;      
  std::string  title;       
  std::string  genre;       
  std::string  album;       
  bool         has_comment; 
  bool         has_lyrics;  
  int          duration;    
  int          bitrate;     
  unsigned int year;        
  unsigned int track;       
  unsigned int discNumber;  
  std::string  lyrics;      
  std::string  comment;     
  std::unordered_map<std::string, std::string>
              additionalProperties; 
  std::string filePath;             

  void copyMetadata(const Metadata& metadata)
  {
    artist               = metadata.artist;
    title                = metadata.title;
    album                = metadata.album;
    genre                = metadata.genre;
    comment              = metadata.comment;
    year                 = metadata.year;
    track                = metadata.track;
    discNumber           = metadata.discNumber;
    lyrics               = metadata.lyrics;
    has_comment          = (metadata.comment != "No Comment");
    has_lyrics           = (metadata.lyrics != "No Lyrics");
    filePath             = metadata.filePath;
    bitrate              = metadata.bitrate;
    additionalProperties = metadata.additionalProperties;
 
    return;
  }

  auto HasLyrics() -> bool { return has_lyrics; }
  auto HasComments() -> bool { return has_comment; }
  auto formatLyrics() -> vector<string>
  {
    vector<string> lines;
    std::string    currentLine;
    bool           insideSquareBrackets = false;
    bool           insideCurlBrackets   = false;
    bool           lastWasUppercase     = false;
    bool           lastWasSpecialChar   = false; // Tracks special characters within words
    char           previousChar         = '\0';
 
    for (char c : lyrics)
    {
      if (c == '[' || c == '(')
      {
        if (!currentLine.empty())
        {
          lines.push_back(currentLine);
          currentLine.clear();
        }
        if (c == '[')
          insideSquareBrackets = true;
        else
          insideCurlBrackets = true;
        currentLine += c;
        continue;
      }
 
      if (insideSquareBrackets || insideCurlBrackets)
      {
        currentLine += c;
        if (c == ']' && insideSquareBrackets)
        {
          lines.push_back(currentLine);
          currentLine.clear();
          insideSquareBrackets = false;
        }
 
        else if (c == ')' && insideCurlBrackets)
        {
          lines.push_back(currentLine);
          currentLine.clear();
          insideCurlBrackets = false;
        }
        continue;
      }
 
      if (c == '\'' || c == '-')
      {
        currentLine += c;
        lastWasSpecialChar = true;
        continue;
      }
 
      if (std::isupper(c) && !lastWasUppercase && !lastWasSpecialChar && !currentLine.empty() &&
          previousChar != '\n' && previousChar != ' ')
      {
        lines.push_back(currentLine);
        currentLine.clear();
      }
 
      currentLine += c;
 
      if (c == '\n')
      {
        if (!currentLine.empty())
        {
          lines.push_back(currentLine);
          currentLine.clear();
        }
      }
 
      lastWasUppercase   = std::isupper(c);
      lastWasSpecialChar = false;
      previousChar       = c;
    }
 
    if (!currentLine.empty())
    {
      lines.push_back(currentLine);
    }
 
    // Trim empty lines (optional)
    lines.erase(std::remove_if(lines.begin(), lines.end(),
                               [](const std::string& line) { return line.empty(); }),
                lines.end());
 
    // assign formmated lyrics to member
    return lines;
  }
};

struct SearchState
{
  Trie   ArtistSearchTrie; 
  Trie   SongSearchTrie;   
  int    artistIndex = 0;  
  int    songIndex   = 0;  
  string input       = ""; 
  int    albumsIndex = 0;  
  mutex  mtx;              
};

 
struct QueueState
{
  vector<Song>   song_queue;       
  vector<string> song_queue_names; 
  int            qIndex       = 0; 
  int            qScreenIndex = 0; 

  void clearQueue()
  {
    song_queue.clear();
    qIndex = 0;
  }

  void incrementQIndex() { qIndex++; }
  void decrementQIndex() { qIndex--; }
  void insertSongToIndex(const Song& newSong)
  {
    song_queue.insert(song_queue.begin() + qIndex + 1, newSong);
  }

  void qPush(const Song& song) { song_queue.push_back(song); }
  void qPopIndex() { song_queue.erase(song_queue.begin() + qScreenIndex); }
  auto getQueueSize() -> int { return song_queue.size(); }
  auto GetCurrentSongFromQueue() -> Song*
  {
    if (!song_queue.empty() && qIndex < song_queue.size())
    {
      return &song_queue[qIndex];
    }
 
    return nullptr;
  }

  void UpdateSongQueueList()
  {
    song_queue_names.clear();
 
    for (long unsigned int i = qIndex; i < song_queue.size(); i++)
    {
      std::string eleName = song_queue[i].metadata.title + " by " + song_queue[i].metadata.artist;
      if (i == qIndex)
        eleName += "  *";
      song_queue_names.push_back(eleName);
    }
 
    return;
  }
};