# Copyright 2022 (c) Anna Schumaker
"""Tests extra buttons for the TrackList."""
import unittest
import unittest.mock
import emmental.tracklist.buttons
from gi.repository import Gio
from gi.repository import Gtk


class TestVisibleColumns(unittest.TestCase):
    """Test the Visible Columns button."""

    def setUp(self):
        """Set up common variables."""
        self.columns = Gio.ListStore()
        self.button = emmental.tracklist.buttons.VisibleColumns(self.columns)

    def test_init(self):
        """Test that the Visible Columns button is set up properly."""
        self.assertIsInstance(self.button, emmental.buttons.PopoverButton)
        self.assertFalse(self.button.get_has_frame())
        self.assertEqual(self.button.get_icon_name(), "columns-symbolic")
        self.assertEqual(self.button.columns, self.columns)

    def test_popover_child(self):
        """Test that the popover_child was set up properly."""
        self.assertIsInstance(self.button.popover_child, Gtk.ColumnView)
        self.assertIsInstance(self.button._selection, Gtk.NoSelection)
        self.assertTrue(self.button.popover_child.get_show_row_separators())
        self.assertTrue(self.button.popover_child.has_css_class("data-table"))

        self.assertEqual(self.button.popover_child.get_model(),
                         self.button._selection)
        self.assertEqual(self.button._selection.get_model(),
                         self.button.columns)

    def test_columns(self):
        """Test the popover_child columns."""
        columns = self.button.popover_child.get_columns()
        self.assertEqual(len(columns), 2)

        self.assertIsInstance(columns[0].get_factory(),
                              emmental.factory.InscriptionFactory)
        self.assertEqual(columns[0].get_title(), "Column")
        self.assertEqual(columns[0].get_fixed_width(), 125)

        self.assertIsInstance(columns[1].get_factory(),
                              emmental.factory.Factory)
        self.assertEqual(columns[1].get_factory().row_type,
                         emmental.tracklist.buttons.VisibleSwitch)
        self.assertEqual(columns[1].get_title(), "Visible")
        self.assertEqual(columns[1].get_fixed_width(), -1)

    def test_visible_switch(self):
        """Test the visible switch widget."""
        item = Gtk.Label()
        listitem = Gtk.ListItem()
        listitem.get_item = unittest.mock.Mock(return_value=item)
        switch = emmental.tracklist.buttons.VisibleSwitch(listitem)

        self.assertIsInstance(switch, emmental.factory.ListRow)
        self.assertIsInstance(switch.child, Gtk.Switch)

        switch.bind()
        self.assertEqual(len(switch.bindings), 1)
        self.assertTrue(switch.child.get_active())

        item.set_visible(False)
        self.assertFalse(switch.child.get_active())
        switch.child.set_active(True)
        item.set_visible(True)


class TestLoopButton(unittest.TestCase):
    """Test the LoopButton."""

    def setUp(self):
        """Set up common variables."""
        self.loop = emmental.tracklist.buttons.LoopButton()

    def test_init(self):
        """Test that the loop button is set up properly."""
        self.assertIsInstance(self.loop, emmental.buttons.ImageToggle)
        self.assertEqual(self.loop.active_icon_name,
                         "media-playlist-repeat-song")
        self.assertEqual(self.loop.inactive_icon_name, "media-playlist-repeat")
        self.assertFalse(self.loop.large_icon)
        self.assertFalse(self.loop.get_has_frame())

    def test_state(self):
        """Test changing the state property."""
        self.assertTrue(self.loop.can_disable)

        self.assertEqual(self.loop.state, "None")
        self.assertAlmostEqual(self.loop.icon_opacity, 0.5, delta=0.005)
        self.assertFalse(self.loop.active)

        self.loop.state = "Playlist"
        self.assertEqual(self.loop.state, "Playlist")
        self.assertEqual(self.loop.icon_opacity, 1.0)
        self.assertFalse(self.loop.active)

        self.loop.state = "Track"
        self.assertEqual(self.loop.state, "Track")
        self.assertEqual(self.loop.icon_opacity, 1.0)
        self.assertTrue(self.loop.active)

        self.loop.can_disable = False
        self.loop.state = "None"
        self.assertEqual(self.loop.state, "Track")
        self.assertTrue(self.loop.active)

        self.loop.can_disable = True
        self.loop.state = "None"
        self.assertAlmostEqual(self.loop.icon_opacity, 0.5, delta=0.005)
        self.assertFalse(self.loop.active)

    def test_click(self):
        """Test cycling through states when clicked."""
        self.assertEqual(self.loop.state, "None")
        self.loop.emit("clicked")
        self.assertEqual(self.loop.state, "Playlist")
        self.loop.emit("clicked")
        self.assertEqual(self.loop.state, "Track")
        self.loop.emit("clicked")
        self.assertEqual(self.loop.state, "None")

        self.loop.state = "Playlist"
        self.loop.can_disable = False
        self.loop.emit("clicked")
        self.assertEqual(self.loop.state, "Track")
        self.loop.emit("clicked")
        self.assertEqual(self.loop.state, "Playlist")


class TestShuffleButtons(unittest.TestCase):
    """Test the Shuffle button."""

    def setUp(self):
        """Set up common variables."""
        self.shuffle = emmental.tracklist.buttons.ShuffleButton()

    def test_init(self):
        """Test that the shuffle button is configured correctly."""
        self.assertIsInstance(self.shuffle, emmental.buttons.ImageToggle)
        self.assertEqual(self.shuffle.active_icon_name,
                         "media-playlist-shuffle")
        self.assertEqual(self.shuffle.inactive_icon_name,
                         "media-playlist-consecutive")
        self.assertAlmostEqual(self.shuffle.icon_opacity, 0.5, delta=0.005)
        self.assertFalse(self.shuffle.large_icon)
        self.assertFalse(self.shuffle.get_has_frame())

    def test_opacity(self):
        """Test adjusting the opacity based on active state."""
        self.shuffle.active = True
        self.assertEqual(self.shuffle.icon_opacity, 1.0)
        self.shuffle.active = False
        self.assertEqual(self.shuffle.icon_opacity, 0.5)


class TestSortFieldWidget(unittest.TestCase):
    """Test the Sort Field widget."""

    def setUp(self):
        """Set up common variables."""
        self.sort = emmental.tracklist.buttons.SortFieldWidget()
        self.model = emmental.tracklist.sorter.SortOrderModel()
        self.model[0].enable()
        self.model[0].reverse()

    def test_init(self):
        """Test that the Sort Field Widget is configured correctly."""
        self.assertIsInstance(self.sort, Gtk.Box)
        self.assertIsInstance(self.sort._box, Gtk.Box)
        self.assertIsInstance(self.sort._name, Gtk.Label)

        self.assertTrue(self.sort._name.get_hexpand())

        self.assertEqual(self.sort.get_spacing(), 6)
        self.assertEqual(self.sort._enabled.get_next_sibling(),
                         self.sort._name)
        self.assertEqual(self.sort._reverse.get_next_sibling(),
                         self.sort._box)
        self.assertTrue(self.sort._box.has_css_class("linked"))

    def test_set_sort_field(self):
        """Test setting a sort field to the Sort Field Widget."""
        self.assertIsNone(self.sort.sort_field)

        self.sort.set_sort_field(self.model[0])
        self.assertEqual(self.sort.sort_field, self.model[0])
        self.assertEqual(self.sort._name.get_text(), self.model[0].name)
        self.assertTrue(self.sort._enabled.get_active())
        self.assertTrue(self.sort._reverse.active)

        self.sort.set_sort_field(None)
        self.assertIsNone(self.sort.sort_field)
        self.assertEqual(self.sort._name.get_text(), "")
        self.assertFalse(self.sort._enabled.get_active())
        self.assertFalse(self.sort._reverse.active)

    def test_enabled(self):
        """Test enabling and disabling a sort field."""
        self.assertIsInstance(self.sort._enabled, Gtk.Switch)
        self.assertEqual(self.sort._enabled.get_valign(), Gtk.Align.CENTER)
        self.assertEqual(self.sort.get_first_child(), self.sort._enabled)

        self.sort._enabled.set_active(True)

        self.sort.set_sort_field(self.model[1])
        self.assertFalse(self.sort._name.get_sensitive())
        self.assertFalse(self.sort._box.get_sensitive())
        self.assertFalse(self.sort._reverse.get_sensitive())

        self.sort._enabled.set_active(True)
        self.assertTrue(self.model[1].enabled)
        self.assertTrue(self.sort._name.get_sensitive())
        self.assertTrue(self.sort._box.get_sensitive())
        self.assertTrue(self.sort._reverse.get_sensitive())

        self.sort._enabled.set_active(False)
        self.assertFalse(self.model[1].enabled)
        self.assertFalse(self.sort._name.get_sensitive())
        self.assertFalse(self.sort._box.get_sensitive())
        self.assertFalse(self.sort._reverse.get_sensitive())

    def test_move_down(self):
        """Test the moving a sort field down."""
        self.assertIsInstance(self.sort._move_down, Gtk.Button)
        self.assertEqual(self.sort._move_down.get_icon_name(),
                         "go-down-symbolic")
        self.assertEqual(self.sort._move_up.get_next_sibling(),
                         self.sort._move_down)

        self.sort._move_down.emit("clicked")

        (field := self.model[0]).enable()
        self.model[1].enable()
        self.sort.set_sort_field(field)

        self.sort._move_down.emit("clicked")
        self.assertEqual(self.model.index(field), 1)

    def test_move_up(self):
        """Test the moving a sort field."""
        self.assertIsInstance(self.sort._move_up, Gtk.Button)
        self.assertEqual(self.sort._move_up.get_icon_name(), "go-up-symbolic")

        self.assertEqual(self.sort._box.get_first_child(),
                         self.sort._move_up)

        self.sort._move_up.emit("clicked")

        self.model[0].enable()
        (field := self.model[1]).enable()
        self.sort.set_sort_field(field)

        self.sort._move_up.emit("clicked")
        self.assertEqual(self.model.index(field), 0)

    def test_reverse(self):
        """Test reversing a sort field."""
        self.assertIsInstance(self.sort._reverse, emmental.buttons.ImageToggle)
        self.assertEqual(self.sort._name.get_next_sibling(),
                         self.sort._reverse)

        self.assertEqual(self.sort._reverse.active_icon_name, "arrow1-up")
        self.assertEqual(self.sort._reverse.inactive_icon_name, "arrow1-down")
        self.assertFalse(self.sort._reverse.large_icon)

        self.sort._reverse.emit("clicked")

        self.sort.set_sort_field(self.model[0])
        self.sort._reverse.emit("clicked")
        self.assertFalse(self.model[0].reversed)
        self.sort._reverse.emit("clicked")
        self.assertTrue(self.model[0].reversed)


class TestSortButton(unittest.TestCase):
    """Test the Sort button."""

    def setUp(self):
        """Set up common variables."""
        self.sort = emmental.tracklist.buttons.SortButton()

    def test_init(self):
        """Test that the Sort button is configured correctly."""
        self.assertIsInstance(self.sort, emmental.buttons.PopoverButton)

        self.assertEqual(self.sort.get_icon_name(),
                         "view-list-ordered-symbolic")
        self.assertFalse(self.sort.get_has_frame())

    def test_popover_child(self):
        """Test that the popover_child is configured correctly."""
        self.assertIsInstance(self.sort.popover_child, Gtk.ListView)
        self.assertIsInstance(self.sort.model,
                              emmental.tracklist.sorter.SortOrderModel)
        self.assertIsInstance(self.sort._selection, Gtk.NoSelection)
        self.assertIsInstance(self.sort._factory, emmental.factory.Factory)

        self.assertTrue(self.sort.popover_child.get_show_separators())

        self.assertEqual(self.sort.popover_child.get_model(),
                         self.sort._selection)
        self.assertEqual(self.sort._selection.get_model(), self.sort.model)
        self.assertEqual(self.sort.popover_child.get_factory(),
                         self.sort._factory)
        self.assertEqual(self.sort._factory.row_type,
                         emmental.tracklist.buttons.SortRow)

    def test_sort_row(self):
        """Test the Sort Row object."""
        (field := self.sort.model[0]).enable()
        listitem = Gtk.ListItem()
        listitem.get_item = lambda: field
        self.sort.model[1].enable()

        row = emmental.tracklist.buttons.SortRow(listitem)
        self.assertIsInstance(row, emmental.factory.ListRow)
        self.assertIsInstance(row.child,
                              emmental.tracklist.buttons.SortFieldWidget)

        row.bind()
        self.assertEqual(row.child.sort_field, field)
        row.unbind()
        self.assertIsNone(row.child.sort_field)

    def test_sort_order(self):
        """Test the sort-order property."""
        self.assertEqual(self.sort.sort_order, "")
        self.sort.model[0].enable()
        self.assertEqual(self.sort.sort_order, self.sort.model.sort_order)

        self.sort.set_sort_order("artist")
        self.assertEqual(self.sort.model.sort_order, "artist")