src/songs/musiclibrarytypes.cpp

///
/// Method implementations for music library types.
///	@file		musiclibrarytypes.cpp - pianod
///	@author		Perette Barella
///	@date		2014-12-09
///	@copyright	Copyright 2014-2020 Devious Fish.  All rights reserved.
///

#include <config.h>

#include <string>
#include <set>

#include <parsnip.h>
#include <football.h>

#include "musiclibrary.h"
#include "musiclibraryparameters.h"
#include "utility.h"
#include "datastore.h"
#include "user.h"
#include "mediaunit.h"
#include "musickeys.h"

using namespace std;

/// Element and attribute keys for ratings.
namespace MusicLibrary {
    static const std::string noPlaylistName = "Bibliotheque";


    /** Make a list of unique strings.  Used for artists on compilation albums
        and genres on playlists. */
    class NameAggregator: public set<string> {
    public:
        /** Return the results of aggregation.
            @param joiner The string with which to connect members.
            @param limit Approximate maximum length of the returned string.
            @param tail A string to append if members are dropped. */
        string str(const string &joiner, string::size_type limit = 0xffff, const string &tail = "...") const {
            std::string result;
            bool dropped = false;
            for (auto &item : *this) {
                if (!item.empty()) {
                    if (result.empty() || (result.size() + joiner.size() + item.size() < limit)) {
                        if (!result.empty())
                            result += joiner;
                        result += item;
                    } else {
                        dropped = true;
                    }
                }
            }
            if (dropped) {
                result += tail;
            }
            return result;
        }
    };


    /*
     *                  Playlists
     */
    bool Playlist::appliesTo (const PianodSong *song) const {
        if (selector.matches (song)) return true;
        if (seeds.find (song->songId()) != seeds.end()) return true;
        if (seeds.find (song->albumId()) != seeds.end()) return true;
        if (seeds.find (song->artistId()) != seeds.end()) return true;
        return false;
    };

    bool Playlist::canSeed (MusicThingie::Type) const {
        return true;
    }

    bool Playlist::seed (MusicThingie::Type seed_type,
                         const MusicThingie *music) const {
        assert (music->source() == this->source());
        if (seed_type == MusicThingie::Type::Playlist)
            throw CommandError (E_MEDIA_VALUE);
        const std::string &seed_id = music->id (seed_type);
        if (seed_id.empty()) return false;
        return (seeds.find (seed_id) != seeds.end());
    }

    void Playlist::seed (MusicThingie::Type seed_type,
                         MusicThingie *music,
                         bool value) {
        assert (music->source() == this->source());
        if (seed_type == MusicThingie::Type::Playlist)
            throw CommandError (E_MEDIA_VALUE);
        const std::string &seed_id = music->id (seed_type);
        if (seed_id.empty())
            throw CommandError (E_INVALID);
        assert (static_cast <MusicThingie::Type> (seed_id [0]) == seed_type);
        SeedSet::const_iterator it = seeds.find (seed_id);
        if ((value && it != seeds.end()) || (!value && it == seeds.end())) {
            // Already in correct state.
            return;
        }
        if (value) {
            pair<SeedSet::iterator, bool> result = seeds.insert (seed_id);
            if (!result.second)
                throw CommandError (E_NAK);
        } else {
            seeds.erase (it);
            invalidateSeeds (music);
        }
        genres_dirty = true;
        _library->populatePlaylist (this);
        _library->markDirty (Foundation::NOMINAL);
    }

    ThingieList Playlist::getSeeds (void) const {
        return _library->seedsForPlaylist (this);
    };

    SongList Playlist::songs () {
        return _library->getPlaylistSongs (this, true);
    }

    SongList Playlist::songs (const Filter &filter) {
        SongList candidates = this->songs();
        SongList results;
        results.reserve (candidates.size());
        for (auto song : candidates) {
            if (filter.matches (song)) {
                results.push_back (song);
            }
        }
        return results;
    }


    void Playlist::invalidateSeeds(const MusicThingie *music) {
        auto artist = dynamic_cast<const Artist *>(music);
        if (artist) {
            for (auto album : artist->albums) {
                for (auto song : album->_songs) {
                    if (song->_playlist == this) song->_playlist = nullptr;
                }
            }
            return;
        }
        // To ensure we invalidate all related seeds,
        // do it from our parent artist.
        auto album = dynamic_cast<const Album *>(music);
        if (album) {
            invalidateSeeds (album->_artist);
        } else {
            auto song = dynamic_cast<const Song *>(music);
            assert (song);
            invalidateSeeds (song->_album->_artist);
        }
    }

    void Playlist::rename (const std::string &newname) {
        _name = newname;
        return;
    }

    void Playlist::erase () {
        if (!library()->removePlaylist (this)) {
            throw CommandError (E_NAK);
        }
    }


    PianodPlaylist *Song::playlist (void) const {
        return _playlist;
    };

    Parsnip::SerialData Playlist::persist () const {
        Parsnip::SerialData seed_list {Parsnip::SerialData::List};
        for (const auto &seed : seeds) {
            seed_list.push_back (seed);
        }

        return Parsnip::SerialData { Parsnip::SerialData::Dictionary,
            MusicStorage::PlaylistId, _id,
            MusicStorage::PlaylistName, _name,
            MusicStorage::PlaylistEnabled, enabled,
            MusicStorage::PlaylistSelector, selector.toString(),
            MusicStorage::PlaylistSeeds, std::move (seed_list)
        };
    };

    void Playlist::restore (const Parsnip::SerialData &data) {
        enabled = data [MusicStorage::PlaylistEnabled].asBoolean();
        try {
            selector = data [MusicStorage::PlaylistSelector].asString();
        } catch (const CommandError &err) {
            flog (LOG_WHERE (LOG_WARNING),
                  "Playlist ", playlistName(), " has an invalid filter expression: ", err.reason());
            selector = Filter::None;
        } catch (const Parsnip::SerializationException &err) {
            flog (LOG_WHERE (LOG_WARNING),
                  "Playlist ", playlistName(), ": ", err.what());
            selector = Filter::None;
        }
        for (const auto &seed : data [MusicStorage::PlaylistSeeds]) {
            seeds.insert (seed.asString());
        }
        genres_dirty = true;
    }

    void Playlist::calculateGenres () const {
        NameAggregator genres;
        for (auto song : _library->getPlaylistSongs (this)) {
            const char *gen = song->genre().c_str();
            while (isspace (*gen))
                gen++;
            while (*gen) {
                // Grab everything up to one of the genre separators
                string::size_type len = strcspn (gen, "/,+");
                if (len) {
                    genres.insert (trim (string {gen, len}));
                }
                // Skip past the genre and any separators
                gen += len;
                gen += strspn (gen, "/,+ \t");
            }
        }

        // Assemble the list into a string
        _genres = genres.str (", ", 50);
        genres_dirty = false;
    }

    /** (Re)calculate the current genres list for a playlist. */
    const std::string &Playlist::genre (void) const {
        if (genres_dirty) {
            calculateGenres();
        }
        return _genres;
    }


    /*
     *                  Transient Playlist
     */

    TransientPlaylist::TransientPlaylist (Foundation *const library, const Filter &criteria) :
    Playlist (library, "transient", "Transient") {
        selector = criteria;
    }

    SongList TransientPlaylist::songs () {
        return _library->getMatchingSongs (selector);
    }


    /*
     *                  Artists
     */

    /** Create a new artist.
        @param library The library in which the artist will reside.
        @param id A unique ID for the artist.
        @param name The name of the artist. */
    Artist::Artist (Foundation *const library,
                    const std::string &id, const std::string &name)
    : _library (library), _id (id), _name (name) {
    };
    Artist::~Artist() {
        assert (albums.empty());
    }

    /** Get all songs belonging to all albums by this artist.
        However, since compilation albums don't belong to the artist,
        this does not return the artist's songs that are on complations.
        @return All songs on albums belonging to this artist. */
    SongList Artist::songs () {
        int song_count = 0;
        for (auto album : albums) {
            song_count += album->_songs.size();
        }
        SongList songs, album_songs;
        songs.reserve (song_count);
        for (auto album : albums) {
            album_songs = album->songs();
            songs.join (album_songs);
        }
        return songs;
    };

    Parsnip::SerialData Artist::persist () const {
        Parsnip::SerialData all_albums { Parsnip::SerialData::List };

        for (auto album : albums) {
            all_albums.push_back (album->persist ());
        }
        return Parsnip::SerialData { Parsnip::SerialData::Dictionary,
            MusicStorage::ArtistId, _id,
            MusicStorage::ArtistName, _name,
            MusicStorage::ArtistAlbums, std::move (all_albums)
        };
    };
    void Artist::restore (const Parsnip::SerialData &data) {
        // Nothing to do in this base class.
    }


    /*
     *                  Albums
     */

    /** Create a new album, and register itself with its parent.
        @param parent The album's artist.
        @param id A unique ID for the album.
        @param name The name of the album. */
    Album::Album (Artist *const parent, const std::string &id, const std::string &name)
    : _artist (parent), _id (id), _name (name) {
        _artist->albums.push_back (this);
        _artist->retain();
    };

    /** Destroy an album by unregistering from its parent artist. */
    Album::~Album (void) {
        assert (_songs.empty());
        auto it = find (_artist->albums.begin(), _artist->albums.end(), this);
        assert (it != _artist->albums.end());
        if (it != _artist->albums.end())
            _artist->albums.erase (it);
        _artist->release();
    }


    /** Get the current artist, or list of artists if a compilation. */
    const string &Album::artist (void) const {
        if (compilation() && artists_dirty)
            calculateArtists();
        return (compilation() ? _artists : _artist->_name);
    };

    /** (Re)calculate the current artists list for a compilation. */
    void Album::calculateArtists (void) const {
        assert (compilation()); // Harmless but wasteful on non-compilation
        NameAggregator artists;
        for (auto song : _songs) {
            artists.insert (trim (song->artist()));
        }
        _artists = artists.str("; ");
        artists_dirty = false;
    }

    bool Album::compilation () const {
        return (_songs.empty() ? false :
                _songs.front()->_artist != nullptr);
    };


    /** Mark an album as a compilation.
        Set all song artists the current artist.
        Detach the item from its artist and stick it into a special compilation
        artist.
        @param compilation_artist The compilation artist to move the album to. */
    void Album::compilation (Artist *compilation_artist) {
        assert (compilation_artist);

        // If already a compilation, do nothing.
        if (compilation()) return;

        // Move artist name into existing songs.
        for (auto song : _songs) {
            assert (!song->_artist);
            if (song->_artist) {
                flog (LOG_WARNING, operator()(), " was ambiguously a compilation");
                if (song->_artist != compilation_artist) {
                    flog (LOG_WARNING, operator()(), " is not the compilation artist ",
                          (*compilation_artist)());
                }
            }
            song->artist (_artist);
        }

        // Remove album from existing artist
        auto it = find (_artist->albums.begin(), _artist->albums.end(), this);
        assert (it != _artist->albums.end());
        if (it != _artist->albums.end())
            _artist->albums.erase (it);
        _artist->release();

        // Add to new artist
        _artist = compilation_artist;
        _artist->albums.push_back (this);
        compilation_artist->retain();
    };

    /** Get all songs belonging to the album.
        @return The songs belonging to the album. */
    SongList Album::songs () {
        sort (_songs.begin(), _songs.end(), [] (Song *a, Song *b) {
            int result = a->trackNumber() - b->trackNumber();
            if (result == 0) {
                result = compare_title_order(a->title(), b->title());
            }
            return result < 0;
        });
        SongList list;
        list.reserve (_songs.size());
        for (auto song : _songs) {
            list.push_back (song);
        }
        return list;
    };


    Parsnip::SerialData Album::persist () const {
        Parsnip::SerialData all_songs { Parsnip::SerialData::List };
        for (auto song : _songs) {
            all_songs.push_back (song->persist());
        }
        Parsnip::SerialData album { Parsnip::SerialData::Dictionary,
            MusicStorage::AlbumId, _id,
            MusicStorage::AlbumName, _name,
            MusicStorage::AlbumSongs, std::move (all_songs)
        };

        if (compilation())
            album [MusicStorage::AlbumIsCompilation] = true;

        return album;
    };

    void Album::restore (const Parsnip::SerialData &data) {
    }


    /*
     *                  Songs
     */

    /** Add a song, and register itself with its parent album.
        @param parent The song's album.
        @param id A unique ID for the song.
        @param name The name of the song. */
    Song::Song (Album *const parent, const std::string &id, const std::string &name)
    : _album (parent), _id (id), _name (name) {
        _album->_songs.push_back (this);
        _album->retain();
        _album->artists_dirty = true;
    };
    const string &Song::artist (void) const {
        return (_artist ? _artist->_name : _album->_artist->_name);
    };

    Song::~Song (void) {
        if (_artist) {
            _artist->release();
        }
        auto it = find (_album->_songs.begin(), _album->_songs.end(), this);
        assert (it != _album->_songs.end());
        if (it != _album->_songs.end())
            _album->_songs.erase (it);
        _album->artists_dirty = true;
        _album->release();
    };

    /** Set the artist for this song.  This applies only for compilation albums.
        @param artist The artist of the song. */
    void Song::artist (Artist *artist) {
        if (_artist)
            _artist->release();
        _artist = artist;
        _artist->retain();
    };

    RESPONSE_CODE Song::rate (Rating value, User *user) {
        assert (user);
        auto ratings = UserData::Ratings::retrieve (user, UserData::Key::TrackRatings, source()->key());
        if (!ratings) {
            return E_RESOURCE;
        }
        try {
            (*ratings) [songId()] = value;
            user->updateData();
            return S_OK;
        } catch (const bad_alloc &) {
            return E_RESOURCE;
        }
    }

    Rating Song::rating (const User *user) const {
        assert (user);
        auto ratings = UserData::Ratings::retrieve (user, UserData::Key::TrackRatings, source()->key());
        if (!ratings) return Rating::UNRATED;
        return ratings->get (songId(), Rating::UNRATED);
    }

    RESPONSE_CODE Song::rateOverplayed (User *user) {
        if (!user) return E_LOGINREQUIRED;
        auto overplays = UserData::OverplayedList::retrieve (user, source()->key());
        if (!overplays) {
            return E_RESOURCE;
        }
        try {
            // 30 days in seconds
            (*overplays) [songId()] = time(nullptr) + 86400 * 30;
            user->updateData();
            return S_OK;
        } catch (const bad_alloc &) {
            return E_RESOURCE;
        }
    }

    Parsnip::SerialData Song::persist () const {
        Parsnip::SerialData song { Parsnip::SerialData::Dictionary,
            MusicStorage::SongId, _id,
            MusicStorage::SongName, _name,
            MusicStorage::SongGenre, _genre
        };

        if (_artist) {
            song [MusicStorage::ArtistId] = _artist->_id;
            song [MusicStorage::ArtistName] = _artist->_name;
        }
        if (_duration)
            song [MusicStorage::SongDuration] = _duration;
        if (_year)
            song [MusicStorage::SongYear] = _year;
        if (_trackNumber)
            song [MusicStorage::SongTrackNumber] = _trackNumber;
        if (last_played)
            song [MusicStorage::SongLastPlayed] = last_played;
        return (song);
    };

    void Song::restore(const Parsnip::SerialData &data) {
        _genre = data [MusicStorage::SongGenre].asString();
        if (data.contains (MusicStorage::SongDuration))
            _duration = data [MusicStorage::SongDuration].asInteger();
        if (data.contains (MusicStorage::SongYear))
            _year = data [MusicStorage::SongYear].asInteger();
        if (data.contains (MusicStorage::SongTrackNumber))
            _trackNumber = data [MusicStorage::SongTrackNumber].asInteger();
        if (data.contains (MusicStorage::SongLastPlayed))
            last_played = data [MusicStorage::SongLastPlayed].as<time_t> ();
    }
}