# Copyright 2022 (c) Anna Schumaker.
"""Tests our playlist Sidebar card."""
import emmental.sidebar
import tests.util
import unittest.mock
from gi.repository import Gtk


class TestSidebar(tests.util.TestCase):
    """Tests the Sidebar card."""

    def setUp(self):
        """Set up common variables."""
        super().setUp()
        self.sidebar = emmental.sidebar.Card(sql=self.sql)

    def test_init(self):
        """Test that the Sidebar has been set up correctly."""
        self.assertIsInstance(self.sidebar, Gtk.Box)

        self.assertEqual(self.sidebar.sql, self.sql)
        self.assertEqual(self.sidebar.get_orientation(),
                         Gtk.Orientation.VERTICAL)
        self.assertFalse(self.sidebar.get_sensitive())

        self.assertTrue(self.sidebar.has_css_class("background"))
        self.assertTrue(self.sidebar.has_css_class("linked"))
        self.assertTrue(self.sidebar.has_css_class("card"))

    def test_filter(self):
        """Test the Sidebar filter entry."""
        self.assertIsInstance(self.sidebar._filter, emmental.entry.Filter)

        self.assertEqual(self.sidebar.get_first_child(), self.sidebar._filter)
        self.assertEqual(self.sidebar._filter.get_placeholder_text(),
                         "type to filter playlists")

        with unittest.mock.patch.object(self.sql, "filter") as mock_filter:
            self.sidebar._filter.set_text("test text")
            self.sidebar._filter.emit("search-changed")
            mock_filter.assert_called_with("*test text*")

    def test_sensitivity(self):
        """Test setting the sidebar sensitivity when all tables have loaded."""
        tables = [t for t in self.sql.playlist_tables()]
        self.sidebar.select_playlist = unittest.mock.Mock()

        for table in tables:
            self.assertFalse(self.sidebar.get_sensitive())
            self.sidebar.select_playlist.assert_not_called()
            self.sql.emit("table-loaded", table)

        self.assertTrue(self.sidebar.get_sensitive())
        self.sidebar.select_playlist.assert_called()

        self.sidebar.select_playlist.reset_mock()
        self.sql.emit("table-loaded", tables[0])
        self.sidebar.select_playlist.assert_not_called()

    def test_show_all_artists(self):
        """Test the show-all-artists property."""
        self.assertFalse(self.sidebar.show_all_artists)
        self.sidebar.show_all_artists = True
        self.assertTrue(self.sidebar._artists.show_all)
        self.sidebar._artists.show_all = False
        self.assertFalse(self.sidebar.show_all_artists)

    def test_selected_playlist(self):
        """Test the selected-playlist property."""
        self.assertIsNone(self.sidebar.selected_playlist)

        playlist1 = self.sql.playlists.create("Playlist 1")
        self.sidebar._group.selected_playlist = playlist1
        self.assertEqual(self.sidebar.selected_playlist, playlist1)

    def test_group(self):
        """Test that sidebar sections are part of the same Group."""
        self.assertIsInstance(self.sidebar._group,
                              emmental.sidebar.section.Group)

        self.assertListEqual(self.sidebar._group._sections,
                             [self.sidebar._playlists,
                              self.sidebar._artists,
                              self.sidebar._genres,
                              self.sidebar._decades])

    def test_sections(self):
        """Tests sidebar section models."""
        self.assertIsInstance(self.sidebar._playlists,
                              emmental.sidebar.playlist.Section)
        self.assertIsInstance(self.sidebar._artists,
                              emmental.sidebar.artist.Section)
        self.assertIsInstance(self.sidebar._genres,
                              emmental.sidebar.genre.Section)
        self.assertIsInstance(self.sidebar._decades,
                              emmental.sidebar.decade.Section)

        self.assertEqual(self.sidebar._filter.get_next_sibling(),
                         self.sidebar._playlists)
        self.assertEqual(self.sidebar._playlists.get_next_sibling(),
                         self.sidebar._artists)
        self.assertEqual(self.sidebar._artists.get_next_sibling(),
                         self.sidebar._genres)
        self.assertEqual(self.sidebar._genres.get_next_sibling(),
                         self.sidebar._decades)

        self.assertEqual(self.sidebar._playlists.table, self.sql.playlists)
        self.assertEqual(self.sidebar._artists.table, self.sql.artists)
        self.assertEqual(self.sidebar._artists.album_table, self.sql.albums)
        self.assertEqual(self.sidebar._genres.table, self.sql.genres)
        self.assertEqual(self.sidebar._decades.table, self.sql.decades)
        self.assertEqual(self.sidebar._decades.year_table, self.sql.years)

    def test_select_playlist(self):
        """Test setting the active playlist."""
        playlist = self.sql.playlists.create("Test Playlist")
        self.sidebar.select_playlist(playlist)
        self.assertTrue(self.sidebar._playlists.active)
        self.assertEqual(self.sidebar.selected_playlist, playlist)

        artist = self.sql.artists.create("Test Artist")
        album = self.sql.albums.create("Test Album", "Test Artist", "2023")
        medium = self.sql.media.create(album, "Test Medium", number=1)

        self.sidebar._artists.select_playlist = unittest.mock.Mock()
        for plist in [artist, album, medium]:
            self.sidebar._artists.select_playlist.reset_mock()
            self.sidebar._artists.active = False

            self.sidebar.select_playlist(plist)
            self.assertTrue(self.sidebar._artists.active)
            self.sidebar._artists.select_playlist.assert_called_with(plist)

        genre = self.sql.genres.create("Test Genre")
        self.sidebar.select_playlist(genre)
        self.assertTrue(self.sidebar._genres.active)
        self.assertEqual(self.sidebar.selected_playlist, genre)

        decade = self.sql.decades.create(1990)
        year = self.sql.years.create(1990)

        self.sidebar._decades.select_playlist = unittest.mock.Mock()
        for plist in [decade, year]:
            self.sidebar._decades.select_playlist.reset_mock()
            self.sidebar._decades.active = False

            self.sidebar.select_playlist(plist)
            self.assertTrue(self.sidebar._decades.active)
            self.sidebar._decades.select_playlist.assert_called_with(plist)