# Copyright 2022 (c) Anna Schumaker.
"""Tests our Track ColumnView."""
import pathlib
import unittest.mock
import emmental.tracklist.trackview
import tests.util
from gi.repository import Gtk


class TestTrackView(tests.util.TestCase):
    """Tests the TrackView widget."""

    def setUp(self):
        """Set up common variables."""
        super().setUp()
        self.db_plist = self.sql.playlists.create("Test Playlist")
        self.playlist = emmental.playlist.playlist.Playlist(self.sql,
                                                            self.db_plist)
        self.trackview = emmental.tracklist.trackview.TrackView(self.sql)

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

    def test_init(self):
        """Test that the TrackView is initialized properly."""
        self.assertIsInstance(self.trackview, Gtk.ScrolledWindow)
        self.assertEqual(self.trackview.get_child(),
                         self.trackview._columnview)

    def test_list_models(self):
        """Test our filter and selection list models."""
        self.assertIsInstance(self.trackview._filtermodel, Gtk.FilterListModel)
        self.assertIsInstance(self.trackview._selection, Gtk.MultiSelection)

        self.assertEqual(self.trackview._filtermodel.get_filter(),
                         self.sql.tracks.get_filter())
        self.assertTrue(self.trackview._filtermodel.get_incremental())

        self.assertEqual(self.trackview._selection.get_model(),
                         self.trackview._filtermodel)
        self.assertEqual(self.trackview.selection_model,
                         self.trackview._selection)

    def test_columnview(self):
        """Test the columnview."""
        self.assertIsInstance(self.trackview._columnview, Gtk.ColumnView)
        self.assertEqual(self.trackview._columnview.get_model(),
                         self.trackview._selection)
        self.assertEqual(self.trackview._columnview.get_columns(),
                         self.trackview.columns)

        self.assertTrue(self.trackview._columnview.get_hexpand())
        self.assertTrue(self.trackview._columnview.get_vexpand())
        self.assertTrue(self.trackview._columnview.get_show_row_separators())
        self.assertTrue(self.trackview._columnview.get_enable_rubberband())
        self.assertTrue(self.trackview._columnview.has_css_class(
                        "emmental-track-list"))

    def test_track_activated(self):
        """Test activating a row in the columnview."""
        requested = unittest.mock.Mock()
        self.playlist.connect("track-requested", requested)
        self.trackview.playlist = self.playlist
        self.trackview._selection.set_model(self.playlist)
        self.db_plist.add_track(self.track)

        with unittest.mock.patch.object(self.trackview._selection,
                                        "unselect_all") as mock_unselect:
            self.trackview._columnview.emit("activate", 0)
            requested.assert_called_with(self.playlist, self.track)
            mock_unselect.assert_called()

    def test_playlist(self):
        """Test the playlist property."""
        self.assertIsNone(self.trackview.playlist)
        self.trackview.playlist = self.playlist
        self.assertEqual(self.trackview._filtermodel.get_model(),
                         self.playlist)

    def test_n_tracks(self):
        """Test the n-tracks property."""
        self.assertEqual(self.trackview.n_tracks, 0)
        self.trackview._selection.set_model(self.playlist)
        self.db_plist.add_track(self.track)
        self.assertEqual(self.trackview.n_tracks, 1)

    def test_runtime(self):
        """Test the runtime property."""
        self.assertEqual(self.trackview.runtime, 0)
        self.trackview._selection.set_model(self.playlist)
        self.db_plist.add_track(self.track)
        self.assertEqual(self.trackview.runtime, 10.0)


class TestTrackViewColumns(tests.util.TestCase):
    """Test the TrackView Columns."""

    def setUp(self):
        """Set up common variables."""
        super().setUp()
        self.trackview = emmental.tracklist.trackview.TrackView(self.sql)
        self.columns = self.trackview.columns
        self.listitem = Gtk.ListItem()

    def test_artwork_column(self, i: int = 0):
        """Test the favorite column."""
        self.assertEqual(self.columns[i].get_title(), "Art")
        self.assertEqual(self.columns[i].get_fixed_width(), -1)
        self.assertFalse(self.columns[i].get_resizable())
        self.assertTrue(self.columns[i].get_visible())

        factory = self.columns[i].get_factory()
        self.assertIsInstance(factory, emmental.factory.Factory)
        self.assertEqual(factory.row_type, emmental.tracklist.row.AlbumCover)

        factory.emit("setup", self.listitem)
        self.assertEqual(self.listitem.listrow.property, "cover")

    def test_favorite_column(self, i: int = 1):
        """Test the favorite column."""
        self.assertEqual(self.columns[i].get_title(), "Fav")
        self.assertEqual(self.columns[i].get_fixed_width(), -1)
        self.assertFalse(self.columns[i].get_resizable())
        self.assertTrue(self.columns[i].get_visible())

        factory = self.columns[i].get_factory()
        self.assertIsInstance(factory, emmental.factory.Factory)
        self.assertEqual(factory.row_type,
                         emmental.tracklist.row.FavoriteButton)

        factory.emit("setup", self.listitem)
        self.assertEqual(self.listitem.listrow.property, "favorite")

    def test_trackno_column(self, i: int = 2):
        """Test the track number column."""
        self.assertEqual(self.columns[i].get_title(), "Track")
        self.assertEqual(self.columns[i].get_fixed_width(), 55)
        self.assertTrue(self.columns[i].get_resizable())
        self.assertTrue(self.columns[i].get_visible())

        factory = self.columns[i].get_factory()
        self.assertIsInstance(factory, emmental.factory.Factory)
        self.assertEqual(factory.row_type,
                         emmental.tracklist.row.TracknoString)

        factory.emit("setup", self.listitem)
        self.assertEqual(self.listitem.listrow.property, "number")
        self.assertEqual(self.listitem.listrow.child.get_xalign(), 1.0)
        self.assertTrue(self.listitem.listrow.child.has_css_class("numeric"))

    def test_title_column(self, i: int = 3):
        """Test the title column."""
        self.assertEqual(self.columns[i].get_title(), "Title")
        self.assertEqual(self.columns[i].get_fixed_width(), 300)
        self.assertTrue(self.columns[i].get_resizable())
        self.assertTrue(self.columns[i].get_visible())

        factory = self.columns[i].get_factory()
        self.assertIsInstance(factory, emmental.factory.Factory)
        self.assertEqual(factory.row_type, emmental.tracklist.row.TrackString)

        factory.emit("setup", self.listitem)
        self.assertEqual(self.listitem.listrow.property, "title")
        self.assertEqual(self.listitem.listrow.child.get_xalign(), 0.0)
        self.assertFalse(self.listitem.listrow.child.has_css_class("numeric"))

    def test_length_column(self, i: int = 4):
        """Test the length column."""
        self.assertEqual(self.columns[i].get_title(), "Length")
        self.assertEqual(self.columns[i].get_fixed_width(), -1)
        self.assertTrue(self.columns[i].get_resizable())
        self.assertTrue(self.columns[i].get_visible())

        factory = self.columns[i].get_factory()
        self.assertIsInstance(factory, emmental.factory.Factory)
        self.assertEqual(factory.row_type, emmental.tracklist.row.LengthString)

        factory.emit("setup", self.listitem)
        self.assertEqual(self.listitem.listrow.property, "length")
        self.assertEqual(self.listitem.listrow.child.get_xalign(), 1.0)
        self.assertTrue(self.listitem.listrow.child.has_css_class("numeric"))

    def test_artist_column(self, i: int = 5):
        """Test the artist column."""
        self.assertEqual(self.columns[i].get_title(), "Artist")
        self.assertEqual(self.columns[i].get_fixed_width(), 250)
        self.assertTrue(self.columns[i].get_resizable())
        self.assertTrue(self.columns[i].get_visible())

        factory = self.columns[i].get_factory()
        self.assertIsInstance(factory, emmental.factory.Factory)
        self.assertEqual(factory.row_type, emmental.tracklist.row.TrackString)

        factory.emit("setup", self.listitem)
        self.assertEqual(self.listitem.listrow.property, "artist")
        self.assertEqual(self.listitem.listrow.child.get_xalign(), 0.0)
        self.assertFalse(self.listitem.listrow.child.has_css_class("numeric"))

    def test_album_column(self, i: int = 6):
        """Test the artist column."""
        self.assertEqual(self.columns[i].get_title(), "Album")
        self.assertEqual(self.columns[i].get_fixed_width(), 350)
        self.assertTrue(self.columns[i].get_resizable())
        self.assertTrue(self.columns[i].get_visible())

        factory = self.columns[i].get_factory()
        self.assertIsInstance(factory, emmental.factory.Factory)
        self.assertEqual(factory.row_type, emmental.tracklist.row.MediumString)

        factory.emit("setup", self.listitem)
        self.assertEqual(self.listitem.listrow.property, "name")
        self.assertEqual(self.listitem.listrow.child.get_xalign(), 0.0)
        self.assertFalse(self.listitem.listrow.child.has_css_class("numeric"))

    def test_album_artist_column(self, i: int = 7):
        """Test the album artist column."""
        self.assertEqual(self.columns[i].get_title(), "Album Artist")
        self.assertEqual(self.columns[i].get_fixed_width(), 250)
        self.assertTrue(self.columns[i].get_resizable())
        self.assertFalse(self.columns[i].get_visible())

        factory = self.columns[i].get_factory()
        self.assertIsInstance(factory, emmental.factory.Factory)
        self.assertEqual(factory.row_type, emmental.tracklist.row.AlbumString)

        factory.emit("setup", self.listitem)
        self.assertEqual(self.listitem.listrow.property, "artist")
        self.assertEqual(self.listitem.listrow.child.get_xalign(), 0.0)
        self.assertFalse(self.listitem.listrow.child.has_css_class("numeric"))

    def test_release_column(self, i: int = 8):
        """Test the release date column."""
        self.assertEqual(self.columns[i].get_title(), "Release")
        self.assertEqual(self.columns[i].get_fixed_width(), 115)
        self.assertTrue(self.columns[i].get_resizable())
        self.assertTrue(self.columns[i].get_visible())

        factory = self.columns[i].get_factory()
        self.assertIsInstance(factory, emmental.factory.Factory)
        self.assertEqual(factory.row_type, emmental.tracklist.row.AlbumString)

        factory.emit("setup", self.listitem)
        self.assertEqual(self.listitem.listrow.property, "release")
        self.assertEqual(self.listitem.listrow.child.get_xalign(), 0.0)
        self.assertTrue(self.listitem.listrow.child.has_css_class("numeric"))

    def test_playcount_column(self, i: int = 9):
        """Test the play count column."""
        self.assertEqual(self.columns[i].get_title(), "Play Count")
        self.assertEqual(self.columns[i].get_fixed_width(), 135)
        self.assertTrue(self.columns[i].get_resizable())
        self.assertTrue(self.columns[i].get_visible())

        factory = self.columns[i].get_factory()
        self.assertIsInstance(factory, emmental.factory.Factory)
        self.assertEqual(factory.row_type,
                         emmental.tracklist.row.PlayCountString)

        factory.emit("setup", self.listitem)
        self.assertEqual(self.listitem.listrow.property, "playcount")
        self.assertEqual(self.listitem.listrow.child.get_xalign(), 0.0)
        self.assertTrue(self.listitem.listrow.child.has_css_class("numeric"))

    def test_last_started_column(self, i: int = 10):
        """Test the last started column."""
        self.assertEqual(self.columns[i].get_title(), "Last Started")
        self.assertEqual(self.columns[i].get_fixed_width(), 250)
        self.assertTrue(self.columns[i].get_resizable())
        self.assertFalse(self.columns[i].get_visible())

        factory = self.columns[i].get_factory()
        self.assertIsInstance(factory, emmental.factory.Factory)
        self.assertEqual(factory.row_type,
                         emmental.tracklist.row.TimestampString)

        factory.emit("setup", self.listitem)
        self.assertEqual(self.listitem.listrow.property, "laststarted")
        self.assertEqual(self.listitem.listrow.child.get_xalign(), 0.0)
        self.assertTrue(self.listitem.listrow.child.has_css_class("numeric"))

    def test_last_played_column(self, i: int = 11):
        """Test the last played column."""
        self.assertEqual(self.columns[i].get_title(), "Last Played")
        self.assertEqual(self.columns[i].get_fixed_width(), 250)
        self.assertTrue(self.columns[i].get_resizable())
        self.assertTrue(self.columns[i].get_visible())

        factory = self.columns[i].get_factory()
        self.assertIsInstance(factory, emmental.factory.Factory)
        self.assertEqual(factory.row_type,
                         emmental.tracklist.row.TimestampString)

        factory.emit("setup", self.listitem)
        self.assertEqual(self.listitem.listrow.property, "lastplayed")
        self.assertEqual(self.listitem.listrow.child.get_xalign(), 0.0)
        self.assertTrue(self.listitem.listrow.child.has_css_class("numeric"))

    def test_filepath_column(self, i: int = 12):
        """Test the last played column."""
        self.assertEqual(self.columns[i].get_title(), "Filepath")
        self.assertEqual(self.columns[i].get_fixed_width(), -1)
        self.assertTrue(self.columns[i].get_resizable())
        self.assertFalse(self.columns[i].get_visible())

        factory = self.columns[i].get_factory()
        self.assertIsInstance(factory, emmental.factory.Factory)
        self.assertEqual(factory.row_type, emmental.tracklist.row.PathString)

        factory.emit("setup", self.listitem)
        self.assertEqual(self.listitem.listrow.property, "path")
        self.assertEqual(self.listitem.listrow.child.get_xalign(), 0.0)
        self.assertFalse(self.listitem.listrow.child.has_css_class("numeric"))