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

class TagStore:
    def __init__(self):
        self.store = dict()
        self.lock = threading.Lock()
        self.Added = publisher.Publisher()
        self.Removed = publisher.Publisher()

    def __add_tag__(self, name, sort, track):
        t = self.__get_tag__(name, sort)
        if track:
            t.add_track(track)
        return t

    def __alloc_tag__(self, name, sort):
        return tag.Tag(name, sort)

    def __getitem__(self, name):
        with self.lock:
            return self.store.get(name)

    def __getstate__(self):
        with self.lock:
            return { "store" : self.store }

    def __get_tag__(self, name, sort):
        with self.lock:
            if (t := self.store.get(name)) != None:
                return t
            t = self.__alloc_tag__(name, sort)
            self.store[name] = t
        self.Added.publish(t)
        return t

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

    def __pop_tag__(self, t):
        self.store.pop(t.name)

    def __setstate__(self, state):
        self.store = state["store"]
        self.lock = threading.Lock()
        self.Added = publisher.Publisher()
        self.Removed = publisher.Publisher()

    def add(self, name, track=None, sort=None):
        return self.__add_tag__(name.strip(), sort, track)

    def init_track(self, name, track):
        with self.lock:
            if (t := self.store.get(name)) != None:
                t.init_track(track)
                return t

    def remove(self, t, track=None):
        if track:
            t.remove_track(track)
        if (track == None or len(t) == 0) and t in self.store.values():
            with self.lock:
                self.__pop_tag__(t)
            self.Removed.publish(t)

    def reset(self):
        with self.lock:
            self.store.clear()
            self.Added.reset()
            self.Removed.reset()

    def tags(self):
        with self.lock:
            for (name, tag) in self.store.items():
                yield tag


class TagSuperStore(TagStore):
    def __alloc_tag__(self, key, sort):
        return tag.SuperTag(key[0], key[1], sort)

    def __pop_tag__(self, t):
        self.store.pop((t.parent, t.name))

    def add(self, parent, name, track, sort=None):
        return super().__add_tag__((parent, name.strip()), sort, track)

    def init_track(self, parent, name, track):
        return super().init_track((parent, name), track)

    def tags(self, parent=None):
        with self.lock:
            for (name, tag) in self.store.items():
                if parent == None or tag.parent == parent:
                    yield tag