src/songs/musiclibraryimpl.h

///
/// Template method implementations for music library.
///	@file		musiclibraryimpl.h - pianod
///	@author		Perette Barella
///	@date		2014-12-09
///	@copyright	Copyright 2014-2020 Devious Fish.  All rights reserved.
///

#pragma once

#include "fileio.h"
#include "parsnip.h"
#include "fundamentals.h"
#include "utility.h"
#include "musickeys.h"

namespace MusicLibrary {

    /*
     *              Supporting functions
     */
    inline std::string persistentId (MusicThingie::Type item_type,
                                     const std::string &key) {
        const char type_code [2] = { static_cast <char> (item_type), '\0' };
        return type_code + std::to_string (create_key_from_string (key));
    }


    /**
     *              Customized hash tables.
     *
     * These add persist/restore capabilities, and provide for items
     * that are cross-linked with parent objects.
     */
    template <class TThing, class TParent>
    ThingieContainer<TThing, TParent>::~ThingieContainer() {
#ifndef NDEBUG
        for (auto &item : *this) {
            assert (item.second->getUseCount() == 1);
        }
#endif
        clear();
    }

    /** Remove items according to the predicate.
        @param pred Predicate, which returns true to indicate removal. */
    template <class TThing, class TParent>
    void ThingieContainer<TThing, TParent>::purge (bool pred(const TThing *)) {
        auto it = this->begin();
        while (it != this->end()) {
            auto element = it++;
            if (pred (element->second)) {
                element->second->release();
                this->erase (element);
            }
        }
    }


    /** Remove all items from the hash table. */
    template <class TThing, class TParent>
    void ThingieContainer<TThing, TParent>::clear() {
        while (this->begin() != this->end()) {
            this->begin()->second->release();
            this->erase (this->begin());
        }
    }

    /** Get a thing by its id. */
    template <class TThing, class TParent>
    TThing *ThingieContainer<TThing, TParent>::getById (const std::string &key) const {
        const auto iterator = this->find (key);
        return (iterator == this->end() ? nullptr : iterator->second);
    }

    /** Get a thing by its id, getting the ID from JSON data. */
    template <class TThing, class TParent>
    TThing *ThingieContainer<TThing, TParent>::getById (const Parsnip::SerialData &data,
                                                        const char *field) {
        return getById (data [field].asString());
    }


    /** Search the things looking for a name and parent match. */
    template <class TThing, class TParent>
    TThing *ThingieContainer<TThing, TParent>::getByName(const std::string &name,
                                                         TParent *parent) const {
        for (auto item : *this) {
            if (item.second->parent() == parent && *(item.second) == name) {
                return item.second;
            }
        }
        return nullptr;
    }


    /** Construct unique, random ID for a new item.
        @param item_type The type code for the item.
        @return The unique ID string. */
    template <class TThing, class TParent>
    std::string ThingieContainer<TThing, TParent>::getNewId (MusicThingie::Type item_type) const {
        const char type [2] = { static_cast <char> (item_type), '\0' };
        while (true) {
            long candidate = random();
            std::string newid = type + std::to_string (candidate);
            if (!getById (newid))
                return newid;
        }
    }


    /** Construct a new item instance and add it to the hash by its ID.
        @param name The new item's name.
        @param id The item's ID, if known, or the empty string.
        @param parent The parent object to which the new item will be linked. */
    template <class TThing, class TParent>
    TThing *ThingieContainer<TThing, TParent>::addItem (const std::string &name,
                                                        std::string id, TParent *parent) {
        std::string newid (id.empty() ? getNewId (TThing::typetype ()) : id);
        TThing *thing = new TThing (parent, newid, name);
        assert (this->find (newid) == this->end());
        (*this) [newid] = thing;
        thing->retain();
        return thing;
    }

    /** Retrieve an item by ID or by name.
        - If ID is given, that is used.
        - Otherwise, a "persistent ID" based on hashing the name is tried;
          if a match is found, use that.
        - Otherwise, try searching by name and parent.  If found, use that.
        - Otherwise, create a new item with the name and a new ID assigned.
        @param name The name to search for.
        @param id The ID to search for.
        @param parent The parent item. */
    template <class TThing, class TParent>
    TThing *ThingieContainer<TThing, TParent>::addOrGetItem (const std::string &name,
                                                             std::string id, TParent *parent) {
        assert (parent);
        TThing *thing;
        if (id.empty()) {
            // Hash the name for a candidate ID
            id = persistentId (TThing::typetype (), name);
            thing = getById (id);
            if (thing &&
                thing->parent() == parent &&
                *thing == name) {
                return thing;
            }
            // If there was no match, leave ID set to the candidate ID.
            if (thing)
                id = "";
            thing = getByName (name, parent);
        } else {
            thing = getById (id);
        }
        if (thing)
            return thing;
        return addItem (name, id, parent);
    }

    /** Reconstitute an item from a persisted file.
        @param node The JSON node with data to be restored.
        @param parent The parent to which the new record will be attached.
        @return A newly constructed item, attached to its parent. */
    template <class TThing, class TParent>
    TThing *ThingieContainer<TThing, TParent>::addOrGetItem (const Parsnip::SerialData &data,
                                                             TParent *parent,
                                                             const std::string &namefield,
                                                             const std::string &idfield) {
        const std::string &name = data [namefield].asString();
        const std::string &id = data [idfield].asString();
        TThing *item = addOrGetItem (name, id, parent);
        assert (item);
        item->restore (data);
        return item;
    }


    /*
     *              Library Template
     */

    template <class TSong, class TAlbum, class TArtist>
    void Library<TSong, TAlbum, TArtist>::purge (void) {
        albums.purge ([] (const TAlbum *album)->bool {
            return (album->getUseCount() == 1
                    && album->empty());
        });
        artists.purge ([] (const TArtist *artist)->bool {
            return (artist->getUseCount() == 1
                    && artist->empty());
        });
    }

    template <class TSong, class TAlbum, class TArtist>
    bool Library<TSong, TAlbum, TArtist>::removePlaylist (Playlist *play) {
        auto it = playlists.find (play->playlistId());
        assert (it != playlists.end());
        playlists.erase (it);
        unpopulatePlaylist (play);
        play->release();
        return true;
    };

    template <class TSong, class TAlbum, class TArtist>
    ThingieList Library<TSong, TAlbum, TArtist>::seedsForPlaylist (const Playlist *playlist) {
        ThingieList results;
        for (auto &item : playlist->seeds) {
            assert (!item.empty());
            // Type code is the first character of the ID.
            const MusicThingie::Type type = (MusicThingie::Type) item.at (0);
            MusicThingie *thing = nullptr;
            switch (type) {
                case MusicThingie::Type::Song:
                    thing = songs.getById (item);
                    break;
                case MusicThingie::Type::Album:
                    thing = albums.getById (item);
                    break;
                case MusicThingie::Type::Artist:
                    thing = artists.getById (item);
                    break;
                default:
                    assert (0);
                    break;
            }
            if (thing) {
                results.push_back (thing);
            }
        }
        return results;
    }


    /// Get a list of all songs in the library.
    template <class TSong, class TAlbum, class TArtist>
    SongList Library<TSong, TAlbum, TArtist>::getAllSongs (void) {
        SongList list;
        list.reserve (songs.size());
        for (auto item : songs) {
            list.push_back (item.second);
        }
        return list;
    }

    /// Get a list of all songs matching a filter.
    template <class TSong, class TAlbum, class TArtist>
    SongList Library<TSong, TAlbum, TArtist>::getMatchingSongs (const Filter &criteria) {
        SongList list;
        list.reserve (songs.size());
        for (auto &item : songs) {
            if (criteria.matches (item.second)) {
                list.push_back (item.second);
            }
        }
        return list;
    }

    /** Retrieve suggestions.  Whereas getMatchingSongs only
        returns songs (several songs on an artist match), this
        returns only the artist or album and not more discrete
        data when an encompassing concept matches. */
    template <class TSong, class TAlbum, class TArtist>
    ThingieList Library<TSong, TAlbum, TArtist>::getSuggestions (const Filter &criteria,
                                                                 SearchRange what) {
        bool exhaustive = deepSearch (what);
        ThingieList list;
        for (auto &artist : artists) {
            bool matches_artist = criteria.matches (artist.second);
            if (matches_artist)
                list.push_back (artist.second);
            if (!matches_artist || exhaustive) {
                for (auto album : artist.second->getAlbums()) {
                    bool matches_album = criteria.matches (album);
                    if (matches_album)
                        list.push_back (album);
                    if (!matches_album || exhaustive) {
                        for (auto song : album->getSongs()) {
                            if (criteria.matches (song)) {
                                list.push_back (song);
                            }
                        }
                    }
                }
            }
        }
        return list;
    }


    /// Get a list of all songs belonging to enabled playlists.
    template <class TSong, class TAlbum, class TArtist>
    SongList Library<TSong, TAlbum, TArtist>::getMixSongs (void) {
        SongList list;
        list.reserve (songs.size());
        for (auto item : songs) {
            if (item.second->_playlist && item.second->_playlist->enabled) {
                list.push_back (item.second);
            }
        }
        return list;
    }


    /** Get a list of all songs assigned to a playlist.
        @param reassess If false, only assigned songs are returned.
        If true, songs in other playlists are also considered. */
    template <class TSong, class TAlbum, class TArtist>
    SongList Library<TSong, TAlbum, TArtist>::getPlaylistSongs (const Playlist *play, bool reassess) {
        SongList list;
        list.reserve (songs.size());
        for (auto item : songs) {
            if ((item.second->_playlist == play) ||
                (reassess && item.second->_playlist && play->appliesTo (item.second))) {
                list.push_back (item.second);
            }
        }
        return list;
    }


    /** Find a playlist for a song, preferring enabled playlists.
        First, aim for enabled playlists;
        if not found then recurse and aim for disabled playlists. */
    template <class TSong, class TAlbum, class TArtist>
    Playlist *Library<TSong, TAlbum, TArtist>::findPlaylistForSong (TSong *song, bool enabled) {
        for (auto playlist : playlists) {
            if (playlist.second->enabled == enabled) {
                if (playlist.second->appliesTo (song)) {
                    return playlist.second;
                }
            }
        }
        if (enabled == false) return nullptr;
        return findPlaylistForSong (song, false);
    }


    /** Review songs and assign them to a new candidate if they match. This is
        applicable when a playlist has been created or just been added to the mix.
        @param aggressive If true, songs with enabled playlists are  considered for reassignment.
        If false, only songs without a playlist or with a disabled playlist are considered. */
    template <class TSong, class TAlbum, class TArtist>
    void Library<TSong, TAlbum, TArtist>::populatePlaylist (Playlist *play, bool aggressive) {
        for (auto item : songs) {
            // Only grab songs that aren't assigned or whose playlist isn't enabled, unless we're aggressive
            if (aggressive || !item.second->_playlist || !item.second->_playlist->enabled) {
                // Don't waste time if we already own it
                if (item.second->_playlist != play) {
                    if (play->appliesTo (item.second)) {
                        item.second->_playlist = play;
                    }
                }
            }
        }
    }

    /** Reassign all a playlists' songs to some other playlist.
        Applicable when song has been removed from the mix, or
        playlist is about to be deleted.
        @warning May reassign current playlists, if no better ones are found
        and the current playlist is still in the playlist set. */
    template <class TSong, class TAlbum, class TArtist>
    void Library<TSong, TAlbum, TArtist>::unpopulatePlaylist (Playlist *play) {
        for (auto &item : songs) {
            // Reassign only if it belongs to this playlist
            if (item.second->_playlist == play) {
                item.second->_playlist = findPlaylistForSong (item.second);
            }
        }
    }
    /** Retrieve anything stored in the library by its ID.
        @param type The type of the thing.
        @param id The ID of the thing to retrieve.
        @return The thing, or a nullptr if not found. */
    template <class TSong, class TAlbum, class TArtist>
    MusicThingie *Library<TSong, TAlbum, TArtist>::getById (MusicThingie::Type type,
                           const std::string &id) {
        MusicThingie *thing = nullptr;
        switch (type) {
            case MusicThingie::Type::Playlist:
            {
                MusicLibrary::Playlist *play = playlists.getById (id);
                if (!play) return nullptr;
                populatePlaylist (play, true);
                thing = play;
                break;
            }
            case MusicThingie::Type::Artist:
                thing = artists.getById (id);
                break;
            case MusicThingie::Type::Album:
                thing = albums.getById (id);
                break;
            case MusicThingie::Type::Song:
                thing = songs.getById (id);
                break;
            default:
                // Asked for a suggestion, seed, etc.
                // Not used by this source, may nevertheless be asked for one.
                break;
        }
        return thing;
    }


    /** Retrieve all songs for a playlist, which may be a meta playlist */
    template <class TSong, class TAlbum, class TArtist>
    SongList Library<TSong, TAlbum, TArtist>::getSongsForPlaylist (PianodPlaylist *playlist) {
        switch (playlist->playlistType()) {
            case PianodPlaylist::SINGLE:
            case PianodPlaylist::TRANSIENT:
                return playlist->songs();
            case PianodPlaylist::MIX:
                return getMixSongs();
            case PianodPlaylist::EVERYTHING:
                return getAllSongs();
        }
        assert (0);
        return SongList();
    }


    template <class TSong, class TAlbum, class TArtist>
    PianodPlaylist *Library<TSong, TAlbum, TArtist>::createPlaylist (const std::string &name,
                                                                   MusicThingie::Type type,
                                                                   MusicThingie *from) {
        assert (from);
        assert (from->source() == source);
        assert (!playlists.getByName (name, this));
        if (playlists.getByName (name, this))
            throw CommandError (E_DUPLICATE);
        Playlist *play = playlists.addOrGetItem (name, this);
        play->selector = Filter::None;
        populatePlaylist (play);
        markDirty (IMPORTANT);
        try {
            play->seed (type, from, true);
        } catch (...) {
            removePlaylist (play);
            throw;
        }
        return play;
    }


    template <class TSong, class TAlbum, class TArtist>
    PianodPlaylist *Library<TSong, TAlbum, TArtist>::createPlaylist (const std::string &name,
                                                                     const Filter &filter) {
        assert (filter.canPersist());
        assert (!playlists.getByName (name, this));
        Playlist *play = playlists.addOrGetItem (name, this);
        play->selector = filter;
        populatePlaylist (play);
        markDirty (IMPORTANT);
        return play;
    }

    template <class TSong, class TAlbum, class TArtist>
    PianodPlaylist *Library<TSong, TAlbum, TArtist>::formTransientPlaylist (const Filter &criteria) {
        return new TransientPlaylist (this, criteria);
    }


    /** Persist library data into a file */
    template <class TSong, class TAlbum, class TArtist>
    bool Library<TSong, TAlbum, TArtist>::writeIndexToFile (const std::string &filename) const {
        try {
            Parsnip::SerialData all_artists {Parsnip::SerialData::List};
            for (const auto &artist : artists) {
                all_artists.push_back (artist.second->persist());
            }

            Parsnip::SerialData all_playlists {Parsnip::SerialData::List};
            for (const auto &playlist : playlists) {
                assert (playlist.second->selector.canPersist());
                all_playlists.push_back (playlist.second->persist ());
            }

            Parsnip::SerialData media = {Parsnip::SerialData::Dictionary,
                MusicStorage::MediaArtists, std::move (all_artists)
            };
            persist (media);

            Parsnip::SerialData doc {Parsnip::SerialData::Dictionary,
                MusicStorage::LibraryMedia, std::move (media),
                MusicStorage::LibraryPlaylists, std::move (all_playlists)
            };
            return carefullyWriteFile (filename, doc);
        } catch (const std::exception &e) {
            flog (LOG_WHERE (LOG_ERROR), "Could not serialize user data: ", e.what());
            return false;
        }
    }

    template <class TSong, class TAlbum, class TArtist>
    bool Library<TSong, TAlbum, TArtist>::restoreIndexFromFile (const std::string &filename) {
        const Parsnip::SerialData index = retrieveJsonFile(filename);

        // Restore the regular tree
        MusicAutoReleasePool pool;
        for (const auto &artist : index [MusicStorage::LibraryMedia][MusicStorage::MediaArtists]) {
            auto newartist = artists.addOrGetItem (artist, this, MusicStorage::ArtistName, MusicStorage::ArtistId);
            if (!newartist)
                continue;
            for (const auto &album : artist [MusicStorage::ArtistAlbums]) {
                auto newalbum = albums.addOrGetItem (album, newartist, MusicStorage::AlbumName, MusicStorage::AlbumId);
                if (!newalbum)
                    continue;
                for (const auto &track : album [MusicStorage::AlbumSongs]) {
                    songs.addOrGetItem(track, newalbum, MusicStorage::SongName, MusicStorage::SongId);
                }
            }
        }
        // Restore compilations
        for (const auto &artist : index [MusicStorage::LibraryMedia][MusicStorage::MediaArtists]) {
            for (const auto &album : artist [MusicStorage::ArtistAlbums]) {
                if (isCompilationAlbum (album)) {
                    for (const auto &track : album [MusicStorage::AlbumSongs]) {
                        auto thesong = songs.getById (track, MusicStorage::SongId);
                        assert (thesong);
                        // Check if compilation song has an artist; if so, set it up.
                        if (track.contains (MusicStorage::ArtistId)) {
                            auto trackartist = artists.getById (track, MusicStorage::ArtistId);
                            if (!trackartist)
                                flog (LOG_WHERE (LOG_WARNING), "Could not find song artist for ",
                                    (*thesong)());
                            else
                                thesong->artist (trackartist);
                        }
                    }
                }
            }
        }
        // Restore the playlists
        for (const auto &playlist : index [MusicStorage::LibraryPlaylists]) {
            playlists.addOrGetItem (playlist, this, MusicStorage::PlaylistName, MusicStorage::PlaylistId);
        }
        return true;
    }

}