# Copyright 2021 (c) Anna Schumaker.
from lib import fake
from lib import tag
from lib import tagstore
from . import user
import unittest

class TestUserTags(unittest.TestCase):
    def test_collection_tag(self):
        c = user.CollectionTag()
        self.assertIsInstance(c, tag.Tag)
        self.assertTrue(c.loop)
        self.assertFalse(c.can_loop())

    def test_new_tracks_tag(self):
        n = user.NewTracksTag()
        self.assertIsInstance(n, tag.Tag)
        self.assertTrue(n.can_loop())
        self.assertTrue(n.can_random())

        n.tracks = [ fake.Track(1), fake.Track(2), fake.Track(3) ]
        state = n.__getstate__()
        self.assertEqual(state["name"], "New Tracks")
        self.assertEqual(state["sort"], "new tracks")
        self.assertEqual(state["current"], -1)
        self.assertEqual(state["tracks"], [ ])
        self.assertFalse(state["loop"])
        self.assertFalse(state["random"])

    def test_previous_tag(self):
        p = user.PreviousTag()
        self.assertIsInstance(p, tag.Tag)
        self.assertFalse(p.can_loop())
        self.assertFalse(p.can_random())

        p.add_track(fake.Track(1))
        self.assertEqual(p.tracks, [ fake.Track(1) ])
        self.assertIsNone(p.next())

        p.add_track(fake.Track(2))
        self.assertEqual(p.tracks, [ fake.Track(2), fake.Track(1) ])
        self.assertEqual(p.next(), fake.Track(1))

        p.add_track(fake.Track(3))
        self.assertEqual(p.tracks, [ fake.Track(3), fake.Track(2), fake.Track(1) ])
        self.assertEqual(p.next(), fake.Track(2))
        self.assertEqual(p.next(), fake.Track(1))

        state = p.__getstate__()
        self.assertEqual(state["name"], "Previous")
        self.assertEqual(state["sort"], "previous")
        self.assertEqual(state["current"], 2)
        self.assertEqual(state["tracks"], [ ])
        self.assertFalse(state["loop"])
        self.assertFalse(state["random"])

    def test_up_next_tag(self):
        u = user.UpNextTag()
        self.assertIsInstance(u, tag.Tag)
        self.assertFalse(u.loop)
        self.assertFalse(u.can_loop())
        self.assertIsNone(u.next())

        u.tracks = [ fake.Track(1, u), fake.Track(2, u), fake.Track(3, u) ]
        self.assertEqual(u.next(), fake.Track(1, u))
        self.assertEqual(u.tracks, [ fake.Track(2, u), fake.Track(3, u) ])

        self.assertEqual(u.next(), fake.Track(2, u))
        self.assertEqual(u.tracks, [ fake.Track(3, u) ])

        u.random = True
        self.assertEqual(u.next(), fake.Track(3, u))
        self.assertEqual(u.tracks, [ ])
        self.assertFalse(u.random)


class TestUserTagStore(unittest.TestCase):
    def test_user_init(self):
        store = user.UserTagStore()
        self.assertIsInstance(store, tagstore.TagStore)

        self.assertIsInstance(store["Collection"], user.CollectionTag)
        self.assertIsInstance(store["New Tracks"], user.NewTracksTag)
        self.assertIsInstance(store["Previous"], user.PreviousTag)
        self.assertIsInstance(store["Favorites"], tag.Tag)
        self.assertIsInstance(store["Up Next"], user.UpNextTag)

    def test_user_reset(self):
        store = user.UserTagStore()
        store.add("Playlist")
        self.assertEqual(len(store), 6)

        store.reset()
        self.assertEqual(len(store), 5)
        self.assertIsInstance(store["Collection"], user.CollectionTag)
        self.assertIsInstance(store["New Tracks"], user.NewTracksTag)
        self.assertIsInstance(store["Previous"], user.PreviousTag)
        self.assertIsInstance(store["Favorites"], tag.Tag)
        self.assertIsInstance(store["Up Next"], user.UpNextTag)