Song.h

#ifndef SONG_H
#define SONG_H
 
#include "Etterna/Models/Misc/Difficulty.h"
#include "RageUtil/Misc/RageTypes.h"
#include "RageUtil/Utils/RageUtil_CachedObject.h"
#include "Etterna/Models/StepsAndStyles/Steps.h"
#include "Etterna/Models/Misc/TimingData.h"
#include "Etterna/Models/Misc/DateTime.h"
 
#include <set>
 
class Calc;
class Style;
class StepsID;
struct lua_State;
struct BackgroundChange;
 
void
FixupPath(std::string& path, const std::string& sSongPath);
auto
GetSongAssetPath(const std::string& sPath, const std::string& sSongPath)
  -> std::string;
 
const static float STEPFILE_VERSION_NUMBER = 0.83F;
 
enum BackgroundLayer
{
    BACKGROUND_LAYER_1,
    BACKGROUND_LAYER_2,
    // BACKGROUND_LAYER_3, // StepCollection get
    NUM_BackgroundLayer,
    BACKGROUND_LAYER_Invalid
};
 
#define FOREACH_BackgroundLayer(bl) FOREACH_ENUM(BackgroundLayer, bl)
 
enum InstrumentTrack
{
    InstrumentTrack_Guitar,
    InstrumentTrack_Rhythm,
    InstrumentTrack_Bass,
    NUM_InstrumentTrack,
    InstrumentTrack_Invalid
};
auto
InstrumentTrackToString(InstrumentTrack it) -> const std::string&;
auto
StringToInstrumentTrack(const std::string& s) -> InstrumentTrack;
 
struct LyricSegment
{
    float m_fStartTime;   
    std::string m_sLyric; 
    RageColor m_Color;    
};
 
class Song
{
    std::string m_sSongDir;
 
  public:
    void SetSongDir(const std::string& sDir) { m_sSongDir = sDir; }
    auto GetSongDir() -> const std::string& { return m_sSongDir; }
 
    enum SelectionDisplay
    {
        SHOW_ALWAYS, 
        SHOW_NEVER   
    } m_SelectionDisplay;
 
    Song();
    ~Song();
    void Reset();
    void DetachSteps();
 
    void FinalizeLoading();
    auto LoadFromSongDir(std::string sDir, Calc* calc = nullptr) -> bool;
    // This one takes the effort to reuse Steps pointers as best as it can
    auto ReloadFromSongDir(const std::string& sDir) -> bool;
    auto ReloadFromSongDir() -> bool { return ReloadFromSongDir(GetSongDir()); }
    void ReloadIfNoMusic();
 
    std::string m_sFileHash;
    auto GetFileHash() -> std::string;
 
    DateTime dateAdded = DateTime::GetNowDateTime();
    auto GetDateAdded() const -> DateTime { return dateAdded; };
 
    void TidyUpData(bool fromCache = false,
                    bool duringCache = false,
                    Calc* calc = nullptr);
 
    void ReCalculateRadarValuesAndLastSecond(bool fromCache = false,
                                             bool duringCache = false,
                                             Calc* calc = nullptr);
    void TranslateTitles();
 
    auto SaveToSSCFile(const std::string& sPath, bool bSavingCache) -> bool;
    auto SaveToETTFile(const std::string& sPath, bool bSavingCache) -> bool;
 
    void Save();
    auto SaveToCacheFile() -> bool;
    auto SaveToSMFile() -> bool;
    auto SaveToDWIFile() -> bool;
 
    [[nodiscard]] auto GetSongFilePath() const -> const std::string&;
    [[nodiscard]] auto GetCacheFilePath() const -> std::string;
 
    // Directory this song data came from:
    [[nodiscard]] auto GetSongDir() const -> const std::string&
    {
        return m_sSongDir;
    }
 
    std::string m_sSongFileName;
 
    std::string m_sGroupName;
 
    ProfileSlot m_LoadedFromProfile;
    bool m_bIsSymLink;
    bool m_bEnabled;
 
    std::string m_sMainTitle;
    std::string m_sSubTitle;
    std::string m_sArtist;
    std::string m_sMainTitleTranslit;
    std::string m_sSubTitleTranslit;
    std::string m_sArtistTranslit;
 
    /* If PREFSMAN->m_bShowNative is off, these are the same as GetTranslit*
     * below. Otherwise, they return the main titles. */
    [[nodiscard]] auto GetDisplayMainTitle() const -> const std::string&;
    [[nodiscard]] auto GetDisplaySubTitle() const -> const std::string&;
    [[nodiscard]] auto GetDisplayArtist() const -> const std::string&;
    [[nodiscard]] auto GetMainTitle() const -> const std::string&;
 
    [[nodiscard]] auto GetTranslitMainTitle() const -> const std::string&
    {
        return static_cast<unsigned int>(!m_sMainTitleTranslit.empty()) != 0U
                 ? m_sMainTitleTranslit
                 : m_sMainTitle;
    }
 
    auto GetStepsToSave(bool bSavingCache = true, const std::string& path = "")
      -> std::vector<Steps*>;
 
    [[nodiscard]] auto GetTranslitSubTitle() const -> const std::string&
    {
        return static_cast<unsigned int>(!m_sSubTitleTranslit.empty()) != 0U
                 ? m_sSubTitleTranslit
                 : m_sSubTitle;
    }
    [[nodiscard]] auto GetTranslitArtist() const -> const std::string&
    {
        return static_cast<unsigned int>(!m_sArtistTranslit.empty()) != 0U
                 ? m_sArtistTranslit
                 : m_sArtist;
    }
 
    // "title subtitle"
    std::string displayfulltitle;
    std::string translitfulltitle;
    [[nodiscard]] auto GetDisplayFullTitle() const -> const std::string&
    {
        return displayfulltitle;
    }
    [[nodiscard]] auto GetTranslitFullTitle() const -> const std::string&
    {
        return translitfulltitle;
    }
 
    float m_fVersion;
    std::string m_sGenre;
 
    std::string m_sCredit;
 
    std::string m_sOrigin; // song origin (for .ssc format)
 
    std::string m_sMusicFile;
    std::string m_PreviewFile;
    std::string m_sInstrumentTrackFile[NUM_InstrumentTrack];
 
    float m_fMusicLengthSeconds;
    float m_fMusicSampleStartSeconds;
    float m_fMusicSampleLengthSeconds;
    DisplayBPM m_DisplayBPMType;
    float m_fSpecifiedBPMMin;
    float m_fSpecifiedBPMMax; // if a range, then Min != Max
 
    std::string m_sBannerFile; // typically a 16:5 ratio graphic (e.g. 256x80)
    std::string m_sJacketFile; // typically square (e.g. 192x192, 256x256)
    std::string m_sCDFile;     // square (e.g. 128x128 [DDR 1st-3rd])
    std::string
      m_sDiscFile; // rectangular (e.g. 256x192 [Pump], 200x150 [MGD3])
    std::string m_sLyricsFile;
    std::string m_sBackgroundFile;
    std::string m_sCDTitleFile;
    std::string m_sPreviewVidFile;
 
    std::string m_sMusicPath;
    std::string m_PreviewPath;
    std::string m_sInstrumentTrackPath[NUM_InstrumentTrack];
    std::string m_sBannerPath; // typically a 16:5 ratio graphic (e.g. 256x80)
    std::string m_sJacketPath; // typically square (e.g. 192x192, 256x256)
    std::string m_sCDPath;     // square (e.g. 128x128 [DDR 1st-3rd])
    std::string
      m_sDiscPath; // rectangular (e.g. 256x192 [Pump], 200x150 [MGD3])
    std::string m_sLyricsPath;
    std::string m_sBackgroundPath;
    std::string m_sCDTitlePath;
    std::string m_sPreviewVidPath;
 
    std::vector<std::string> ImageDir;
 
    static auto GetSongAssetPath(std::string sPath,
                                 const std::string& sSongPath) -> std::string;
    [[nodiscard]] auto GetMusicPath() const -> const std::string&
    {
        return m_sMusicPath;
    }
    [[nodiscard]] auto GetInstrumentTrackPath(InstrumentTrack it) const
      -> const std::string&
 
    {
        return m_sInstrumentTrackPath[it];
    }
    [[nodiscard]] auto GetBannerPath() const -> const std::string&
    {
        return m_sBannerPath;
    }
    [[nodiscard]] auto GetJacketPath() const -> const std::string&
    {
        return m_sJacketPath;
    }
    [[nodiscard]] auto GetCDImagePath() const -> const std::string&
    {
        return m_sCDPath;
    }
    [[nodiscard]] auto GetDiscPath() const -> const std::string&
    {
        return m_sDiscPath;
    }
    [[nodiscard]] auto GetLyricsPath() const -> const std::string&
    {
        return m_sLyricsPath;
    }
    [[nodiscard]] auto GetBackgroundPath() const -> const std::string&
    {
        return m_sBackgroundPath;
    }
    [[nodiscard]] auto GetCDTitlePath() const -> const std::string&
    {
        return m_sCDTitlePath;
    }
    [[nodiscard]] auto GetPreviewVidPath() const -> const std::string&
    {
        return m_sPreviewVidPath;
    }
    [[nodiscard]] auto GetPreviewMusicPath() const -> const std::string&
    {
        return m_PreviewPath;
    }
    [[nodiscard]] auto GetCredits() const -> const std::string&
    {
        return m_sCredit;
    }
    [[nodiscard]] auto GetPreviewStartSeconds() const -> float;
    auto GetCacheFile(const std::string& sType) -> std::string;
 
    // how have i not jammed anything here yet - mina
 
    // Get the highest value for a specific skillset across all the steps
    // objects for the song at a given rate
    [[nodiscard]] auto HighestMSDOfSkillset(Skillset x,
                                            float rate,
                                            bool filtered_charts_only) const
      -> float;
    [[nodiscard]] auto IsSkillsetHighestOfChart(Steps* chart,
                                                Skillset skill,
                                                float rate) const -> bool;
    [[nodiscard]] auto MatchesFilter(
      float rate,
      std::vector<Steps*>* vMatchingStepsOut = nullptr) const -> bool;
    [[nodiscard]] auto ChartMatchesFilter(Steps* chart, float rate) const
      -> bool;
    [[nodiscard]] auto IsChartHighestDifficulty(Steps* chart,
                                                Skillset skill,
                                                float rate) const -> bool;
    auto HasChartByHash(const std::string& hash) -> bool;
 
    // For loading only:
    bool m_bHasMusic, m_bHasBanner, m_bHasBackground;
 
    [[nodiscard]] auto HasMusic() const -> bool;
    [[nodiscard]] auto HasInstrumentTrack(InstrumentTrack it) const -> bool;
    [[nodiscard]] auto HasBanner() const -> bool;
    [[nodiscard]] auto HasBackground() const -> bool;
    [[nodiscard]] auto HasJacket() const -> bool;
    [[nodiscard]] auto HasCDImage() const -> bool;
    [[nodiscard]] auto HasDisc() const -> bool;
    [[nodiscard]] auto HasCDTitle() const -> bool;
    [[nodiscard]] auto HasBGChanges() const -> bool;
    [[nodiscard]] auto HasLyrics() const -> bool;
    [[nodiscard]] auto HasPreviewVid() const -> bool;
 
    [[nodiscard]] auto Matches(const std::string& sGroup,
                               const std::string& sSong) const -> bool;
 
    TimingData m_SongTiming;
 
    [[nodiscard]] auto GetFirstBeat() const -> float;
    [[nodiscard]] auto GetFirstSecond() const -> float;
    [[nodiscard]] auto GetLastBeat() const -> float;
    [[nodiscard]] auto GetLastSecond() const -> float;
    [[nodiscard]] auto GetSpecifiedLastBeat() const -> float;
    [[nodiscard]] auto GetSpecifiedLastSecond() const -> float;
 
    void SetFirstSecond(float f);
    void SetLastSecond(float f);
    void SetSpecifiedLastSecond(float f);
 
    using VBackgroundChange = std::vector<BackgroundChange>;
 
  private:
    float firstSecond;
    float lastSecond;
    float specifiedLastSecond;
    std::shared_ptr<VBackgroundChange>
      m_BackgroundChanges[NUM_BackgroundLayer];
    std::shared_ptr<VBackgroundChange> m_ForegroundChanges;
 
    [[nodiscard]] auto GetChangesToVectorString(
      const std::vector<BackgroundChange>& changes) const
      -> std::vector<std::string>;
 
  public:
    [[nodiscard]] auto GetBackgroundChanges(BackgroundLayer bl) const
      -> const std::vector<BackgroundChange>&;
    auto GetBackgroundChanges(BackgroundLayer bl)
      -> std::vector<BackgroundChange>&;
    [[nodiscard]] auto GetForegroundChanges() const
      -> const std::vector<BackgroundChange>&;
    auto GetForegroundChanges() -> std::vector<BackgroundChange>&;
 
    [[nodiscard]] auto GetBGChanges1ToVectorString() const
      -> std::vector<std::string>;
    [[nodiscard]] auto GetBGChanges2ToVectorString() const
      -> std::vector<std::string>;
    [[nodiscard]] auto GetFGChanges1ToVectorString() const
      -> std::vector<std::string>;
 
    [[nodiscard]] auto GetInstrumentTracksToVectorString() const
      -> std::vector<std::string>;
 
    std::vector<LyricSegment> m_LyricSegments;
 
    void AddBackgroundChange(BackgroundLayer blLayer,
                             const BackgroundChange& seg);
    void AddForegroundChange(const BackgroundChange& seg);
    void AddLyricSegment(const LyricSegment& seg);
 
    void GetDisplayBpms(DisplayBpms& AddTo,
                        bool bIgnoreCurrentRate = false) const;
    [[nodiscard]] auto GetBackgroundAtBeat(BackgroundLayer iLayer,
                                           float fBeat) const
      -> const BackgroundChange&;
 
    auto CreateSteps() -> Steps*;
    void InitSteps(Steps* pSteps);
 
    auto GetOrTryAtLeastToGetSimfileAuthor() const -> const std::string;
 
    [[nodiscard]] auto HasSignificantBpmChangesOrStops() const -> bool;
    [[nodiscard]] auto GetStepsSeconds() const -> float;
    [[nodiscard]] auto IsLong() const -> bool;
    [[nodiscard]] auto IsMarathon() const -> bool;
 
    // plays music for chart preview and is available to lua -mina
    void PlaySampleMusicExtended();
 
    auto SongCompleteForStyle(const Style* st) const -> bool;
    [[nodiscard]] auto HasStepsType(StepsType st) const -> bool;
    [[nodiscard]] auto HasStepsTypeAndDifficulty(StepsType st,
                                                 Difficulty dc) const -> bool;
    [[nodiscard]] auto GetAllSteps() const -> const std::vector<Steps*>&
    {
        return m_vpSteps;
    }
    [[nodiscard]] auto GetStepsByStepsType(StepsType st) const
      -> const std::vector<Steps*>&
    {
        return m_vpStepsByType[st];
    }
    [[nodiscard]] auto GetChartsOfCurrentGameMode() const
      -> std::vector<Steps*>;
    [[nodiscard]] auto GetChartsMatchingFilter() const -> std::vector<Steps*>;
    [[nodiscard]] auto HasEdits(StepsType st) const -> bool;
 
    auto HasFavoritedChart() const -> bool { return isfavorited; }
    void SetHasFavoritedChart(bool b) { isfavorited = b; }
    auto HasGoal() const -> bool { return hasgoal; }
    void SetHasGoal(bool b) { hasgoal = b; }
    auto HasPermaMirrorChart() const -> bool { return permamirror; }
    void SetHasPermaMirrorChart(bool b) { permamirror = b; }
 
    void SetEnabled(bool b) { m_bEnabled = b; }
    [[nodiscard]] auto GetEnabled() const -> bool { return m_bEnabled; }
 
    void AddSteps(Steps* pSteps);
    void DeleteSteps(const Steps* pSteps, bool bReAutoGen = true);
 
    auto IsEditAlreadyLoaded(Steps* pSteps) const -> bool;
 
    auto IsStepsUsingDifferentTiming(Steps* pSteps) const -> bool;
    [[nodiscard]] auto AnyChartUsesSplitTiming() const -> bool;
    void UnloadAllCalcDebugOutput();
    std::vector<std::string> m_vsKeysoundFile;
 
    CachedObject<Song> m_CachedObject;
 
    // Lua
    void PushSelf(lua_State* L);
 
    std::vector<Steps*> m_vpSteps;
    std::vector<Steps*> m_UnknownStyleSteps;
 
  private:
    bool isfavorited = false;
    bool permamirror = false;
    bool hasgoal = false;
    std::vector<Steps*> m_vpStepsByType[NUM_StepsType];
};
 
#endif