# Copyright 2021 (c) Anna Schumaker.
import datetime
import db
import lib
import unittest
from gi.repository import GObject
from gi.repository import Gio
from gi.repository import Gtk
from . import model

class TestChildModel(unittest.TestCase):
    def items_changed(self, table, pos, rm, add):
        self.changed = (pos, rm, add)

    def setUp(self):
        db.reset()

    def test_init(self):
        artist = db.artist.Table.find("Test Artist", "Test Sort")
        child = model.ChildModel(artist)

        self.assertIsInstance(child, GObject.GObject)
        self.assertIsInstance(child, Gio.ListModel)

        self.assertEqual(child.parent, artist)
        self.assertEqual(child.get_item_type(), GObject.TYPE_PYOBJECT)
        self.assertEqual(child.get_n_items(), 0)

    def test_children(self):
        artist = db.artist.Table.find("Test Artist", "Test Sort")
        child = model.ChildModel(artist)
        child.connect("items-changed", self.items_changed)

        album = artist.find_album("Test Album", datetime.date.today())
        self.assertEqual(child.get_n_items(), 1)
        self.assertEqual(child.get_item(0), album)
        self.assertEqual(self.changed, (0, 0, 1))


class TestTreeListModel(unittest.TestCase):
    def test_init(self):
        tree = model.TreeListModel(db.artist.Table)
        self.assertIsInstance(tree, Gtk.TreeListModel)
        self.assertEqual(tree.get_model(), db.artist.Table)
        self.assertFalse(tree.get_autoexpand())
        self.assertFalse(tree.get_passthrough())

    def test_create_child_func(self):
        artist = db.artist.Table.find("Test Artist", "Test Sort")
        child = model.create_child_func(artist)
        self.assertEqual(child.parent, artist)

        genre = db.genre.Table.find("Test Genre")
        self.assertIsNone(model.create_child_func(genre))


class TestFilterTableModel(unittest.TestCase):
    def tearDown(self):
        model.TableFilter.set_pattern("")

    def test_init(self):
        filter = model.FilterTableModel(db.artist.Table)
        self.assertIsInstance(filter, Gtk.FilterListModel)
        self.assertIsInstance(filter.get_model(), Gtk.TreeListModel)
        self.assertEqual(filter.get_table(), db.artist.Table)
        self.assertEqual(filter.get_filter(), model.TableFilter)

    def test_filter(self):
        artist = db.artist.Table.find("Test Artist", "Test Sort")
        album = artist.find_album("Test Album", datetime.date.today())
        self.assertIsInstance(model.TableFilter, lib.filter.Regex)

        model.TableFilter.set_pattern("Artist")
        self.assertTrue(model.TableFilter.do_check(artist))
        model.TableFilter.set_pattern("Album")
        self.assertTrue(model.TableFilter.do_check(artist))
        model.TableFilter.set_pattern("Disc")
        self.assertFalse(model.TableFilter.do_check(artist))


class TestTableSelectionModel(unittest.TestCase):
    def test_init(self):
        selection = model.TableSelection(db.artist.Table)
        self.assertIsInstance(selection, Gtk.SingleSelection)
        self.assertIsInstance(selection.get_model(), model.FilterTableModel)
        self.assertEqual(selection.get_table(), db.artist.Table)
        self.assertTrue(selection.get_can_unselect())
        self.assertFalse(selection.get_autoselect())

    def test_selected_playlist(self):
        db.reset()
        selection = model.TableSelection(db.artist.Table)
        self.assertIsNone(selection.get_selected_playlist())

        track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
        selection.set_selected(0)
        self.assertEqual(selection.get_selected_playlist(), track.artist)

    def test_get_playlist(self):
        selection = model.TableSelection(db.artist.Table)
        track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
        self.assertEqual(selection.get_playlist(0), track.artist)
        self.assertIsNone(selection.get_playlist(1))


class TestFilterUserModel(unittest.TestCase):
    def test_init(self):
        filter = model.FilterUserModel()
        self.assertIsInstance(filter, Gtk.FilterListModel)
        self.assertIsInstance(filter.get_filter(), model.UserFilter)
        self.assertEqual(filter.get_model(), db.user.Table)

    def test_filter(self):
        filter = model.UserFilter()
        self.assertFalse(filter.do_match(db.user.Table.find("Collection")))
        self.assertTrue(filter.do_match(db.user.Table.find("Favorites")))
        self.assertFalse(filter.do_match(db.user.Table.find("New Tracks")))
        self.assertFalse(filter.do_match(db.user.Table.find("Previous")))
        self.assertTrue(filter.do_match(db.user.Table.find("Queued Tracks")))
        self.assertTrue(filter.do_match(db.user.Table.find("Test Playlist")))


class TestUserSelectionModel(unittest.TestCase):
    def test_init(self):
        selection = model.UserSelection()
        self.assertIsInstance(selection, Gtk.SingleSelection)
        self.assertIsInstance(selection.get_model(), model.FilterUserModel)
        self.assertEqual(selection.get_selected_item(), db.user.Table.find("Favorites"))