# Copyright 2020 (c) Anna Schumaker.
from lib import metadata
from lib import publisher
from . import tags
from gi.repository import GObject
import datetime
import db
import scanner

class Track(GObject.Object):
    def __init__(self, trackid, filepath, library):
        GObject.Object.__init__(self)
        self.trackid = trackid
        self.path = filepath.relative_to(library.name)
        self.library = library
        self.lastplayed = None
        self.playcount = 0

        with metadata.Metadata(filepath) as meta:
            self.title = meta.title()
            self.length = meta.length()
            self.discnumber = meta.discnumber()
            self.tracknumber = meta.tracknumber()

            self.artist = tags.Artist.add(meta.artist(), self, sort=meta.artistsort())
            self.album = tags.Album.add(self.artist, meta.album(), self)
            self.genres = [ tags.Genre.add(g, self) for g in meta.genres() ]
            self.decade = tags.Decade.add(f"{meta.decade()}s", self)
            self.year = tags.Year.add(self.decade, str(meta.year()), self)

        self.playlists = [ tags.User.add("Collection", self),
                           tags.User.add("New Tracks", self) ]

    def __getitem__(self, item):
        tag = self.__dict__.get(item, None)
        if item == "length":
            (m, s) = divmod(tag, 60)
            return f"{m}:{s:02}"
        elif item == "discnumber":
            return f"{tag:02}"
        elif item == "tracknumber":
            return f"{self.discnumber}-{tag:02}"
        elif item == "lastplayed":
            return "Never" if tag == None else str(tag)
        elif item == "genres":
            return ", ".join([ str(g) for g in self.genres ])
        return None if tag == None else str(tag)

    def __getstate__(self):
        state = self.__dict__.copy()
        state["artist"] = str(self.artist)
        state["album"]  = str(self.album)
        state["genres"] = [ str(g) for g in self.genres ]
        state["decade"] = str(self.decade)
        state["year"] = str(self.year)
        state["playlists" ] = [ str(p) for p in self.playlists \
                             if str(p) not in ("New Tracks", "Previous") ]
        return state

    def __setstate__(self, state):
        GObject.Object.__init__(self)
        self.__dict__.update(state)

    def __set_tags__(self):
        self.artist = tags.Artist.init_track(self.artist, self)
        self.album  = tags.Album.init_track(self.artist, self.album, self)
        self.genres = [ tags.Genre.init_track(g, self) for g in self.genres ]
        self.decade = tags.Decade.init_track(self.decade, self)
        self.year   = tags.Year.init_track(self.decade, self.year, self)
        self.playlists = [ tags.User.init_track(p, self) for p in self.playlists ]
        scanner.import_track(db.library.Table.find(self.library.name),
                             self.filepath(), self.playcount, self.lastplayed,
                             [ p.name for p in self.playlists ])

    def about_to_remove(self):
        tags.Artist.remove(self.artist, self)
        tags.Album.remove(self.album, self)
        for genre in self.genres:
            tags.Genre.remove(genre, self)
        tags.Decade.remove(self.decade, self)
        tags.Year.remove(self.year, self)
        for tag in self.playlists:
            tag.remove_track(self)

    def add_to_playlist(self, name):
        self.playlists.append(tags.User.add(name, self))

    def filepath(self):
        return self.library.name / self.path

    def played(self):
        self.playcount += 1
        self.lastplayed = datetime.datetime.now()

    def remove_from_playlist(self, name):
        tag = tags.User[name]
        tag.remove_track(self)
        self.playlists.remove(tag)