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

class TestTagStore(unittest.TestCase):
    def setUp(self):
        self.added = None
        self.removed = None

    def on_store_added(self, tag):
        self.added = tag

    def on_store_removed(self, tag):
        self.removed = tag

    def test_tag_store(self):
        store = tagstore.TagStore()
        self.assertEqual(store.store, { })
        self.assertIsInstance(store.lock, type(threading.Lock()))
        self.assertIsInstance(store.Added, publisher.Publisher)
        self.assertIsInstance(store.Removed, publisher.Publisher)

    def test_tag_store_add_remove(self):
        store = tagstore.TagStore()
        store.Added.register(self.on_store_added)
        store.Removed.register(self.on_store_removed)

        tag = store.add("test", fake.Track(1))
        self.assertEqual(self.added, tag)
        self.assertEqual(tag.tracks, [ fake.Track(1) ])

        self.added = None
        self.assertEqual(store.add("test  ", fake.Track(2)), tag)
        self.assertEqual(tag.tracks, [ fake.Track(1), fake.Track(2) ])
        self.assertIsNone(self.added)

        store.remove(tag, fake.Track(1))
        self.assertEqual(tag.tracks, [ fake.Track(2) ])
        self.assertIn("test", store.store.keys())
        self.assertIsNone(self.removed)

        store.remove(tag, fake.Track(2))
        self.assertEqual(tag.tracks, [ ])
        self.assertNotIn("test", store.store.keys())
        self.assertEqual(self.removed, tag)

    def test_tag_store_add_remove_none(self):
        store = tagstore.TagStore()
        tag = store.add("test")
        self.assertEqual(tag.tracks, [ ])

        tag.add_track(fake.Track(1))
        tag.add_track(fake.Track(2))

        store.remove(tag)
        self.assertNotIn("test", store.store.keys())

    def test_tag_store_add_remove_sort(self):
        store = tagstore.TagStore()
        tag = store.add("test", sort="sort")
        self.assertEqual(tag.sort, "sort")

    def test_tag_store_items(self):
        store = tagstore.TagStore()
        self.assertEqual(len(store), 0)

        tag1 = store.add("test1", fake.Track(1))
        tag2 = store.add("test2", fake.Track(2))
        tag3 = store.add("test3", fake.Track(3))

        self.assertEqual(len(store), 3)
        self.assertEqual( store["test1"], tag1)
        self.assertEqual( store["test2"], tag2)
        self.assertEqual( store["test3"], tag3)
        self.assertIsNone(store["test4"])

        result = [ tag for tag in store.tags() ]
        self.assertEqual(len(result), 3)
        self.assertIn(tag1, result)
        self.assertIn(tag2, result)
        self.assertIn(tag3, result)

    def test_tag_store_reset(self):
        store = tagstore.TagStore()
        tag = store.add("test", fake.Track(1))
        store.Added.register(self.on_store_added)
        store.Removed.register(self.on_store_removed)

        store.reset()
        self.assertNotIn(tag.name, store.store.keys())
        self.assertEqual(store.Added.subscribers, set())
        self.assertEqual(store.Removed.subscribers, set())

    def test_tag_store_state(self):
        store = tagstore.TagStore()
        track = fake.Track(1)
        tag = store.add("test", track)

        state = store.__getstate__()
        self.assertEqual(set(state.keys()), set([ "store" ]))

        store.__dict__.clear()
        store.__setstate__(state)
        self.assertEqual(store.store, { "test" : tag })
        self.assertIsInstance(store.lock, type(threading.Lock()))
        self.assertIsInstance(store.Added, publisher.Publisher)
        self.assertIsInstance(store.Removed, publisher.Publisher)

        self.assertEqual(store.init_track("test", track), tag)
        self.assertEqual(tag.tracks, [ track ])


class TestTagSuperStore(unittest.TestCase):
    def test_tag_superstore(self):
        store = tagstore.TagStore()
        superstore = tagstore.TagSuperStore()
        self.assertIsInstance(superstore, tagstore.TagStore)

        parent = store.add("parent", fake.Track(1))
        supertag = superstore.add(parent, "test  ", fake.Track(1))
        self.assertIsInstance(supertag, tag.SuperTag)
        self.assertEqual(supertag.name, "test")
        self.assertEqual(supertag.tracks, [ fake.Track(1) ])
        self.assertEqual(supertag.parent, parent)

        superstore.remove(supertag, fake.Track(1))
        self.assertEqual(supertag.tracks, [ ])
        self.assertNotIn("test", superstore.store.keys())

    def test_tag_superstore_items(self):
        store = tagstore.TagStore()
        superstore = tagstore.TagSuperStore()

        parent1 = store.add("parent1", fake.Track(1))
        parent2 = store.add("parent2", fake.Track(2))
        tag1 = superstore.add(parent1, "test1", fake.Track(1))
        tag2 = superstore.add(parent1, "test2", fake.Track(2))
        tag3 = superstore.add(parent2, "test3", fake.Track(3))

        self.assertEqual(len(superstore), 3)
        self.assertEqual( superstore[parent1, "test1"], tag1)
        self.assertEqual( superstore[parent1, "test2"], tag2)
        self.assertEqual( superstore[parent2, "test3"], tag3)
        self.assertIsNone(superstore[parent2, "test2"])

        result = [ tag for tag in superstore.tags(parent1) ]
        self.assertEqual(result, [ tag1, tag2 ])
        result = [ tag for tag in superstore.tags(parent2) ]
        self.assertEqual(result, [ tag3 ])
        result = [ tag for tag in superstore.tags() ]
        self.assertEqual(result, [ tag1, tag2, tag3 ])

    def test_tag_superstore_init_track(self):
        store = tagstore.TagStore()
        superstore = tagstore.TagSuperStore()

        track = fake.Track(1)
        parent = store.add("test")
        tag = superstore.add(parent, "test", track)
        tag.tracks = [ 1 ]

        self.assertEqual(superstore.init_track(parent, "test", track), tag)
        self.assertEqual(tag.tracks, [ track ])