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

class Tag:
    def __init__(self, name, sort=None):
        self.name = name
        self.sort = sort.lower() if sort else str(name).lower()
        self.current = -1
        self.runtime = 0
        self.loop = False
        self.random = False
        self.tracks = [ ]
        self.widgets = None
        self.lock = threading.Lock()
        self.TrackAdded = publisher.Publisher()
        self.TrackRemoved = publisher.Publisher()

    def __getitem__(self, n):
        with self.lock:
            if n < len(self.tracks):
                return self.tracks[n]
        return None

    def __getstate__(self):
        with self.lock:
            return { "name"    : self.name,
                     "sort"    : self.sort,
                     "current" : self.current,
                     "loop"    : self.loop,
                     "random"  : self.random,
                     "tracks"  : [ t.trackid for t in self.tracks ] }

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

    def __lt__(self, rhs):
        if not isinstance(rhs, SuperTag):
            return self.sort < rhs.sort
        if self == rhs.parent:
            return True
        return self.sort < rhs.parent.sort

    def __next_track__(self):
        if self.loop == True and self.current >= len(self.tracks):
            return 0
        return self.current + 1

    def __random_track__(self):
        i = 1
        length = len(self.tracks)
        if len(self.tracks) >= 3:
            i = random.randint(1, length - 1)
        return (self.current + i) % (1 if length == 0 else length)

    def __setstate__(self, state):
        self.name    = state["name"]
        self.sort    = state["sort"]
        self.current = state["current"]
        self.loop    = state["loop"]
        self.random  = state["random"]
        self.tracks  = state["tracks"]
        self.runtime = 0
        self.widgets = None
        self.lock    = threading.Lock()
        self.TrackAdded   = publisher.Publisher()
        self.TrackRemoved = publisher.Publisher()

    def __str__(self):
        return self.name

    def add_track(self, track):
        with self.lock:
            if track in self.tracks:
                return
            pos = len(self.tracks)
            self.tracks.append(track)
            self.runtime += track.length
        self.TrackAdded.publish(self, track, pos)

    def can_loop(self): return True
    def can_random(self): return True

    def get_header(self):
        return self.sort[0].upper() if len(self.sort) > 0 else ""

    def init_track(self, track):
        with self.lock:
            try:
                i = self.tracks.index(track.trackid)
                self.tracks[i] = track
                self.runtime += track.length
            except Exception as e:
                pass

    def next(self):
        with self.lock:
            if self.random == True:
                self.current = self.__random_track__()
            else:
                self.current = self.__next_track__()

            if self.current < len(self.tracks):
                return self.tracks[self.current]
            return None

    def remove_track(self, track):
        with self.lock:
            pos = self.tracks.index(track)
            self.tracks.remove(track)
            self.runtime -= track.length
        self.TrackRemoved.publish(self, track, pos)

    def stacked(self):
        with self.lock:
            if self.current >= len(self.tracks):
                self.current = -1

    def track_selected(self, track):
        with self.lock:
            self.current = self.tracks.index(track)
        track.add_to_playlist("Previous")


class SuperTag(Tag):
    def __init__(self, parent, name, sort=None):
        Tag.__init__(self, name, sort)
        self.parent = parent

    def __getstate__(self):
        state = Tag.__getstate__(self)
        state["parent"] = self.parent
        return state

    def __lt__(self, rhs):
        if not isinstance(rhs, SuperTag):
            return self.parent.sort < rhs.sort
        if self.parent != rhs.parent:
            return self.parent < rhs.parent
        return self.sort < rhs.sort

    def __setstate__(self, state):
        Tag.__setstate__(self, state)
        self.parent = state["parent"]