# Copyright 2021 (c) Anna Schumaker.
#
# Table: tracks
# +---------+-----------+------------+---------+--------+--------+
# | trackid | libraryid | artistid   | albumid | discid | yearid |
# +---------+-----------+------------+---------+--------+--------+
# | number  | playcount | lastplayed | length  | title  | path   |
# +---------+-----------+------------+---------+--------+--------|
#
# Index: track_index
# +-----------------+
# | path -> trackid |
# +-----------------+
import datetime
import pathlib
from gi.repository import GObject
from . import artist
from . import album
from . import commit
from . import decade
from . import disc
from . import execute
from . import library
from . import objects
from . import year

class Track(objects.Row):
    def do_get_column(self, column):
        return execute(f"SELECT {column} FROM tracks "
                        "WHERE trackid=?", [ self.rowid ])

    @GObject.Property
    def library(self):
        return library.Library(self.get_column("libraryid"))

    @GObject.Property
    def artist(self):
        return artist.Artist(self.get_column("artistid"))

    @GObject.Property
    def album(self):
        return album.Album(self.get_column("albumid"))

    @GObject.Property
    def disc(self):
        return disc.Disc(self.get_column("discid"))

    @GObject.Property
    def decade(self):
        return decade.Decade(self.get_column("decadeid"))

    @GObject.Property
    def year(self):
        return year.Year(self.get_column("yearid"))

    @GObject.Property
    def number(self):
        return self.get_column("number")

    @GObject.Property
    def playcount(self):
        return self.get_column("playcount")

    @GObject.Property
    def lastplayed(self):
        return self.get_column("lastplayed")

    @GObject.Property
    def length(self):
        return self.get_column("length")

    @GObject.Property
    def title(self):
        return self.get_column("title")

    @GObject.Property
    def path(self):
        return self.get_column("path")

    def played(self):
        execute("UPDATE tracks "
                "SET playcount=playcount+1, lastplayed=? "
                "WHERE trackid=?", [ datetime.date.today(), self.rowid ])
        commit()


class TrackTable(objects.Table):
    def __init__(self):
        objects.Table.__init__(self, "tracks", Track)

    def do_create(self):
        execute("CREATE TABLE IF NOT EXISTS tracks "
                    "(trackid INTEGER PRIMARY KEY, "
                    " libraryid INTEGER, "
                    " artistid INTEGER, "
                    " albumid INTEGER, "
                    " discid INTEGER, "
                    " decadeid INTEGER, "
                    " yearid INTEGER, "
                    " number INTEGER, "
                    " playcount INTEGER DEFAULT 0,"
                    " lastplayed DATE DEFAULT NULL, "
                    " length REAL, "
                    " title TEXT, "
                    " path TEXT UNIQUE, "
                    " FOREIGN KEY(libraryid) REFERENCES libraries(libraryid), "
                    " FOREIGN KEY(artistid) REFERENCES artists(artistid), "
                    " FOREIGN KEY(albumid) REFERENCES albums(albumid), "
                    " FOREIGN KEY(discid) REFERENCES discs(discid), "
                    " FOREIGN KEY(yearid) REFERENCES years(yearid))")
        execute("CREATE INDEX IF NOT EXISTS track_index ON tracks(path)")

    def do_insert(self, library, artist, album, disc, year, number, length, title, path):
        return execute("INSERT INTO tracks (libraryid, artistid, albumid, discid, "
                                   "decadeid, yearid, number, length, title, path) "
                       "VALUES (?,?,?,?,?,?,?,?,?,?)",
                       [ int(library), int(artist), int(album), int(disc),
                         int(year.decade), int(year), number, length, title, str(path) ])

    def do_delete(self, track):
        from . import genre
        from . import playlist
        genre.Map.delete_track(track)
        playlist.Map.delete_track(track)
        playlist.TempMap.delete_track(track)
        return execute("DELETE FROM tracks WHERE trackid=?", [ int(track) ])

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

    def do_lookup(self, path):
        return execute("SELECT trackid FROM tracks "
                       "WHERE path=?", [ str(path) ])

    def find(self, *args):
        raise NotImplementedError


Table = TrackTable()