# Copyright 2021 (c) Anna Schumaker.
#
# Table: playlists
# +------   ---+-----------+------+------+
# | playlistid | plstateid | name | sort |
# +--------   -+-----------+------+------+
#
# Index: playlist_index
# +--------------------+
# | name -> playlistid |
# +--------------------+
from gi.repository import GObject
from .sql import execute
from . import objects
from . import state
from . import track

Default = [ "Collection", "Favorites", "New Tracks",
            "Previous", "Queued Tracks" ]


class Playlist(objects.Tag):
    def do_get_column(self, column):
        return execute(f"SELECT {column} FROM playlists "
                        "WHERE playlistid=?", [ self.rowid ])

    @GObject.Property
    def playlist_state(self):
        return state.Table.get(self.get_column("plstateid"))


class PlaylistTable(objects.Table):
    def __init__(self):
        objects.Table.__init__(self, "playlists", Playlist)

    def do_create(self):
        execute("CREATE TABLE IF NOT EXISTS playlists "
                   "(playlistid INTEGER PRIMARY KEY, "
                   " plstateid INTEGER NOT NULL, "
                   " name TEXT UNIQUE, "
                   " sort TEXT, "
                   " FOREIGN KEY (plstateid) REFERENCES playlist_states(plstateid))")
        execute("CREATE INDEX IF NOT EXISTS playlist_index "
                "ON playlists(name)")

    def do_insert(self, name, loop=False):
        plstate = state.Table.insert(random=False, loop=loop)
        return execute("INSERT INTO playlists (plstateid, name, sort) "
                       "VALUES (?, ?, ?)", (plstate.rowid, name, name.casefold()))

    def do_delete(self, playlist):
        Map.delete_playlist(playlist)
        TempMap.delete_playlist(playlist)
        return execute("DELETE FROM playlists WHERE playlistid=?", [ int(playlist) ])

    def do_get(self, rowid):
        return execute("SELECT playlistid FROM playlists "
                       "WHERE playlistid=?", [ rowid ])

    def do_lookup(self, name):
        return execute("SELECT playlistid FROM playlists "
                       "WHERE name=?", [ name ])

    def create_default_playlists(self):
        for name in Default:
            if (plist := self.lookup(name)) != None:
                continue
            self.do_insert(name, name == "Collection")


class PlaylistMap(objects.Map):
    def __init__(self, temp=False):
        name = "playlist_map" if temp==False else "temp_playlist_map"
        self.temporary = temp

        objects.Map.__init__(self, name, Playlist, track.Track)
        self.lookup_tracks = self.lookup_rhs
        self.lookup_playlists = self.lookup_lhs

    def do_create(self):
        temp = "" if self.temporary == False else "TEMPORARY"
        execute(f"CREATE {temp} TABLE IF NOT EXISTS {self.map_name} "
                    "(playlistid INTEGER, "
                    " trackid INTEGER, "
                    " FOREIGN KEY(playlistid) REFERENCES playlists(playlistid), "
                    " FOREIGN KEY(trackid) REFERENCES tracks(trackid), "
                    " UNIQUE(playlistid, trackid))")

    def do_insert(self, playlist, track):
        execute(f"INSERT INTO {self.map_name} (playlistid, trackid) "
                 "VALUES (?, ?)", [ int(playlist), int(track) ])

    def do_delete(self, playlist, track):
        return execute(f"DELETE FROM {self.map_name} "
                        "WHERE playlistid=? AND trackid=?",
                        [ int(playlist), int(track) ])

    def do_lookup_rhs(self, playlist):
        return execute(f"SELECT trackid FROM {self.map_name} "
                        "WHERE playlistid=?", [ int(playlist) ])

    def do_lookup_lhs(self, track):
        return execute(f"SELECT playlistid FROM {self.map_name} "
                        "WHERE trackid=?", [ int(track) ])

    def delete_track(self, track):
        for playlist in self.lookup_playlists(track):
            self.delete(playlist, track)

    def delete_playlist(self, playlist):
        for track in self.lookup_tracks(playlist):
            self.delete(playlist, track)


Table = PlaylistTable()
Map = PlaylistMap(temp=False)
TempMap = PlaylistMap(temp=True)