# Copyright 2022 (c) Anna Schumaker
"""Tests our decade Gio.ListModel."""
import pathlib
import unittest.mock
import emmental.db
import tests.util
from gi.repository import Gtk


class TestDecadeObject(tests.util.TestCase):
    """Tests our decade object."""

    def setUp(self):
        """Set up common variables."""
        tests.util.TestCase.setUp(self)
        self.table = self.sql.decades
        self.decade = emmental.db.decades.Decade(table=self.table,
                                                 propertyid=12345,
                                                 decade=2020, name="The 2020s")

    def test_init(self):
        """Test that the Decade is set up properly."""
        self.assertIsInstance(self.decade, emmental.db.playlist.Playlist)
        self.assertEqual(self.decade.table, self.table)
        self.assertEqual(self.decade.propertyid, 12345)
        self.assertEqual(self.decade.decade, 2020)
        self.assertEqual(self.decade.primary_key, 2020)
        self.assertEqual(self.decade.name, "The 2020s")
        self.assertIsNone(self.decade.parent)

    def test_add_remove_year(self):
        """Test adding and removing a year from the decade."""
        year = self.sql.years.create(1988)

        self.assertFalse(year in self.decade.child_set)
        self.assertFalse(self.decade.has_year(year))

        self.decade.add_year(year)
        self.assertTrue(year in self.decade.child_set)
        self.assertTrue(self.decade.has_year(year))

        self.decade.remove_year(year)
        self.assertFalse(year in self.decade.child_set)
        self.assertFalse(self.decade.has_year(year))

    def test_get_years(self):
        """Test getting the list of years for this decade."""
        with unittest.mock.patch.object(self.table, "get_years",
                                        return_value=[1, 2, 3]) as mock:
            self.assertListEqual(self.decade.get_years(), [1, 2, 3])
            mock.assert_called_with(self.decade)

    def test_years_model(self):
        """Test getting a Gio.ListModel representing a Decade's years."""
        self.assertIsInstance(self.decade.child_set,
                              emmental.db.table.TableSubset)
        self.assertIsInstance(self.decade.children, Gtk.FilterListModel)
        self.assertEqual(self.decade.children.get_filter(),
                         self.sql.years.get_filter())
        self.assertEqual(self.decade.child_set.table, self.sql.years)


class TestDecadeTable(tests.util.TestCase):
    """Tests our decade table."""

    def setUp(self):
        """Set up common variables."""
        super().setUp()
        self.table = self.sql.decades
        self.sql.years.load()

        self.album = self.sql.albums.create("Test Album", "Test Artist", "123")
        self.medium = self.sql.media.create(self.album, "", number=1)
        self.library = self.sql.libraries.create(pathlib.Path("/a/b"))
        self.year = self.sql.years.create(2023)
        self.track = self.sql.tracks.create(self.library,
                                            pathlib.Path("/a/b/c/1.ogg"),
                                            self.medium, self.year)

    def test_init(self):
        """Test that the decade table is configured correctly."""
        self.assertIsInstance(self.table, emmental.db.playlist.Table)
        self.assertEqual(len(self.table), 0)
        self.assertTrue(self.table.autodelete)
        self.assertFalse(self.table.system_tracks)

    def test_add_track(self):
        """Test adding a Track to a Decade playlist."""
        decade = self.table.create(2020)
        self.assertTrue(self.table.add_track(decade, self.track))
        decade2 = self.table.create(1990)
        self.assertFalse(self.table.add_track(decade2, self.track))

    def test_construct(self):
        """Test constructing a decade playlist."""
        decade = self.table.construct(propertyid=1980, decade=1980,
                                      name="The 1980s")
        self.assertIsInstance(decade, emmental.db.decades.Decade)
        self.assertEqual(decade.table, self.table)
        self.assertEqual(decade.propertyid, 1980)
        self.assertEqual(decade.decade, 1980)
        self.assertEqual(decade.name, "The 1980s")
        self.assertFalse(decade.active)
        self.assertFalse(decade.tracks_movable)

    def test_create(self):
        """Test creating a decade playlist."""
        decade = self.table.create(1988)
        self.assertIsInstance(decade, emmental.db.decades.Decade)
        self.assertEqual(decade.decade, 1980)
        self.assertEqual(decade.name, "The 1980s")
        self.assertEqual(decade.sort_order,
                         "release, albumartist, album, mediumno, number")

        cur = self.sql("SELECT COUNT(decade) FROM decades")
        self.assertEqual(cur.fetchone()["COUNT(decade)"], 1)

        row = self.sql("""SELECT COUNT(*) FROM playlist_properties
                          WHERE propertyid=?""", decade.propertyid).fetchone()
        self.assertEqual(row["COUNT(*)"], 1)

        self.assertIsNone(self.table.create(1985))

    def test_delete(self):
        """Test deleting a decade playlist."""
        self.year.delete()
        decade = self.table.create(1980)
        self.sql.years.create(1988)
        self.assertTrue(decade.delete())

        cur = self.sql("SELECT COUNT(decade) FROM decades")
        self.assertEqual(cur.fetchone()["COUNT(decade)"], 0)
        self.assertEqual(len(self.table), 0)
        self.assertIsNone(self.table.get_item(0))

        row = self.sql("""SELECT COUNT(*) FROM playlist_properties
                          WHERE propertyid=?""", decade.propertyid).fetchone()
        self.assertEqual(row["COUNT(*)"], 0)

        row = self.sql("""SELECT COUNT(*) FROM years""").fetchone()
        self.assertEqual(row["COUNT(*)"], 0)

        self.assertFalse(decade.delete())

    def test_filter(self):
        """Test filtering a decade playlist."""
        self.table.create(1980)
        self.table.create(1990)

        self.sql.years.create(1985)
        self.sql.years.create(1988)
        self.sql.years.create(1992)

        self.table.filter("*80*", now=True)
        self.assertSetEqual(self.table.get_filter().keys, {1980})
        self.table.filter("the*s", now=True)
        self.assertSetEqual(self.table.get_filter().keys, {1980, 1990})

        self.table.filter("1988", now=True)
        self.assertSetEqual(self.table.get_filter().keys, {1980})

    def test_get_sort_key(self):
        """Test getting the sort key for a decade playlist."""
        decade = self.table.create(1980)
        self.assertEqual(self.table.get_sort_key(decade), 1980)

    def test_get_trackids(self):
        """Test loading decade tracks from the database."""
        decade = self.table.create(2020)
        track2 = self.sql.tracks.create(self.library,
                                        pathlib.Path("/a/b/c/2.ogg"),
                                        self.medium, self.year)
        self.assertSetEqual(self.table.get_trackids(decade),
                            {self.track.trackid, track2.trackid})

    def test_load(self):
        """Load the decade table from the database."""
        decade = self.table.create(1980)
        self.table.create(1990)
        year = self.sql.years.create(1988)
        decade.add_year(year)

        decades2 = emmental.db.decades.Table(self.sql)
        self.assertEqual(len(decades2), 0)

        decades2.load(now=True)
        self.assertEqual(len(decades2), 2)

        self.assertEqual(decades2.get_item(0).decade, 1980)
        self.assertEqual(decades2.get_item(0).name, "The 1980s")
        self.assertSetEqual(decades2.get_item(0).child_set.keyset.keys, {1988})

        self.assertEqual(decades2.get_item(1).decade, 1990)
        self.assertEqual(decades2.get_item(1).name, "The 1990s")
        self.assertSetEqual(decades2.get_item(1).child_set.keyset.keys, set())

    def test_lookup(self):
        """Test looking up decade playlists."""
        decade = self.table.create(1980)
        self.assertEqual(self.table.lookup(1988), decade)
        self.assertIsNone(self.table.lookup(1990))

    def test_remove_track(self):
        """Test removing a Track from the Decade."""
        decade = self.table.create(2023)
        self.assertTrue(self.table.remove_track(decade, unittest.mock.Mock()))

    def test_update(self):
        """Test updating decade attributes."""
        decade = self.table.create(1980)
        decade.active = True
        decade.loop = "Track"
        decade.shuffle = True
        decade.sort_order = "trackid"

        row = self.sql("""SELECT active, loop, shuffle,
                                 sort_order, current_trackid
                          FROM decades_view WHERE decade=?""",
                       decade.decade).fetchone()
        self.assertTrue(row["active"])
        self.assertEqual(row["loop"], "Track")
        self.assertTrue(row["shuffle"])
        self.assertEqual(row["sort_order"], "trackid")
        self.assertIsNone(row["current_trackid"])

    def test_get_years(self):
        """Test getting the list of years for a decade."""
        decade = self.table.create(1980)
        y1985 = self.sql.years.create(1985)
        y1988 = self.sql.years.create(1988)

        self.assertSetEqual(self.table.get_yearids(decade), {1985, 1988})
        self.assertListEqual(self.table.get_years(decade), [y1985, y1988])