# Copyright 2021 (c) Anna Schumaker.
from lib import publisher
from . import track
import threading

class TrackAllocator:
    def __init__(self):
        self.tracks = dict()
        self.nextid = 0
        self.lock = threading.Lock()
        self.Added = publisher.Publisher()
        self.Removed = publisher.Publisher()
        self.Updated = publisher.Publisher()

    def __alloc_track__(self, lib, filepath):
        with self.lock:
            trak = track.Track(self.nextid, filepath, lib)
            self.tracks[self.nextid] = trak
            self.nextid += 1
        self.Added.publish(trak)
        return trak

    def __getitem__(self, id):
        with self.lock:
            return self.tracks.get(id, None)

    def __getstate__(self):
        with self.lock:
            return { "tracks" : self.tracks,
                     "nextid" : self.nextid }

    def __len__(self):
        with self.lock:
            return len(self.tracks)

    def __setstate__(self, state):
        self.__dict__.update(state)
        self.lock = threading.Lock()
        self.Added = publisher.Publisher()
        self.Removed = publisher.Publisher()
        self.Updated = publisher.Publisher()

    def allocate(self, lib, filepath):
        try:
            return self.__alloc_track__(lib, filepath)
        except Exception as e:
            pass

    def autoremove(self, lib):
        with self.lock:
            to_rm = [ trak for trak in self.tracks.values() \
                    if trak.library == lib and not trak.filepath().exists() ]
            for trak in to_rm:
                trak.about_to_remove()
                del self.tracks[trak.trackid]
                self.Removed.publish(trak)
            return to_rm

    def list_tracks(self, lib):
        with self.lock:
            for (id, track) in self.tracks.items():
                if track.library ==lib:
                    yield track

    def load_tags(self):
        for (id, track) in self.tracks.items():
            track.__set_tags__()

    def played(self, track):
        with self.lock:
            track.played()
            self.Updated.publish(track)

    def remove(self, track):
        with self.lock:
            track.about_to_remove()
            del self.tracks[track.trackid]
        self.Removed.publish(track)

    def reset(self):
        with self.lock:
            self.nextid = 0
            self.tracks.clear()
            self.Added.reset()
            self.Removed.reset()