# Copyright 2021 (c) Anna Schumaker.
import unittest
from gi.repository import Gtk
from . import model
from . import sort

class TestUpDownBox(unittest.TestCase):
    def move_up(self, button): self.up = True
    def move_down(self, button): self.down = True

    def test_init(self):
        updown = sort.UpDownBox()
        self.assertIsInstance(updown, Gtk.Box)
        self.assertTrue(updown.has_css_class("linked"))

        child = updown.get_first_child()
        self.assertIsInstance(child, Gtk.Button)
        self.assertEqual(child.get_icon_name(), "go-up-symbolic")
        self.assertFalse(child.get_sensitive())

        child = child.get_next_sibling()
        self.assertIsInstance(child, Gtk.Button)
        self.assertEqual(child.get_icon_name(), "go-down-symbolic")
        self.assertFalse(child.get_sensitive())

    def test_sensitive(self):
        updown = sort.UpDownBox()
        updown.set_active(True, first=False, last=False)
        self.assertTrue(updown.get_first_child().get_sensitive())
        self.assertTrue(updown.get_last_child().get_sensitive())

        updown.set_active(True, first=True, last=False)
        self.assertFalse(updown.get_first_child().get_sensitive())
        self.assertTrue(updown.get_last_child().get_sensitive())

        updown.set_active(True, first=False, last=True)
        self.assertTrue(updown.get_first_child().get_sensitive())
        self.assertFalse(updown.get_last_child().get_sensitive())

        updown.set_active(False, first=True, last=True)
        self.assertFalse(updown.get_first_child().get_sensitive())
        self.assertFalse(updown.get_last_child().get_sensitive())

    def test_clicks(self):
        updown = sort.UpDownBox()
        updown.connect("move-up", self.move_up)
        updown.connect("move-down", self.move_down)

        updown.get_first_child().emit("clicked")
        self.assertTrue(self.up)
        updown.get_last_child().emit("clicked")
        self.assertTrue(self.down)


class TestDirectionButton(unittest.TestCase):
    def test_init(self):
        button = sort.DirectionButton()
        self.assertIsInstance(button, Gtk.Button)
        self.assertEqual(button.get_icon_name(), "view-sort-ascending")
        self.assertFalse(button.get_sensitive())

    def test_set_direction(self):
        button = sort.DirectionButton()
        button.set_direction("DESC", active=True)
        self.assertEqual(button.get_icon_name(), "view-sort-descending")
        self.assertTrue(button.get_sensitive())

        button.set_direction("ASC", active=False)
        self.assertEqual(button.get_icon_name(), "view-sort-ascending")
        self.assertFalse(button.get_sensitive())


class TestFieldLabel(unittest.TestCase):
    def test_init(self):
        label = sort.FieldLabel()
        self.assertIsInstance(label, Gtk.Label)
        self.assertFalse(label.get_sensitive())
        self.assertTrue(label.get_hexpand())

    def test_set_field(self):
        label = sort.FieldLabel()
        label.set_field("tracks.number", active=True)
        self.assertEqual(label.get_text(), "Track Number")
        self.assertEqual(label.get_field(), "tracks.number")
        self.assertTrue(label.get_sensitive())

        label.set_field("tracks.title", active=False),
        self.assertEqual(label.get_text(), "Track Title")
        self.assertEqual(label.get_field(), "tracks.title")
        self.assertFalse(label.get_sensitive())

        label.set_field("tracks.length", active=True),
        self.assertEqual(label.get_text(), "Track Length")
        self.assertEqual(label.get_field(), "tracks.length")
        self.assertTrue(label.get_sensitive())

        label.set_field("artists.sort", active=False),
        self.assertEqual(label.get_text(), "Artist Name")
        self.assertEqual(label.get_field(), "artists.sort")
        self.assertFalse(label.get_sensitive())

        label.set_field("albums.sort", active=True),
        self.assertEqual(label.get_text(), "Album Name")
        self.assertEqual(label.get_field(), "albums.sort")
        self.assertTrue(label.get_sensitive())

        label.set_field("discs.subtitle", active=False),
        self.assertEqual(label.get_text(), "Disc Subtitle")
        self.assertEqual(label.get_field(), "discs.subtitle")
        self.assertFalse(label.get_sensitive())

        label.set_field("albums.release", active=True),
        self.assertEqual(label.get_text(), "Release Date")
        self.assertEqual(label.get_field(), "albums.release")
        self.assertTrue(label.get_sensitive())

        label.set_field("tracks.playcount", active=False),
        self.assertEqual(label.get_text(), "Play Count")
        self.assertEqual(label.get_field(), "tracks.playcount")
        self.assertFalse(label.get_sensitive())

        label.set_field("tracks.lastplayed", active=True)
        self.assertEqual(label.get_text(), "Last Played")
        self.assertEqual(label.get_field(), "tracks.lastplayed")
        self.assertTrue(label.get_sensitive())

        label.set_field("playlist_map.rowid", active=False)
        self.assertEqual(label.get_text(), "Order Added")
        self.assertEqual(label.get_field(), "playlist_map.rowid")
        self.assertFalse(label.get_sensitive())


class TestSortRow(unittest.TestCase):
    def on_switched(self, row, enabled):
        self.enabled = enabled

    def on_reversed(self, row):
        self.reversed = True

    def on_move_up(self, row):
        self.move_up = True

    def on_move_down(self, row):
        self.move_down = True

    def test_init(self):
        row = sort.SortRow()
        self.assertIsInstance(row, Gtk.Box)
        self.assertIsInstance(row.switch, Gtk.Switch)
        self.assertIsInstance(row.label, sort.FieldLabel)
        self.assertIsInstance(row.direction, sort.DirectionButton)
        self.assertIsInstance(row.updown, sort.UpDownBox)

        self.assertEqual(row.get_spacing(), 5)
        self.assertEqual(row.switch.get_valign(), Gtk.Align.CENTER)

        self.assertEqual(row.get_first_child(), row.switch)
        self.assertEqual(row.switch.get_next_sibling(), row.label)
        self.assertEqual(row.label.get_next_sibling(), row.direction)
        self.assertEqual(row.direction.get_next_sibling(), row.updown)

    def test_set_item(self):
        row = sort.SortRow()
        row.set_item("tracks.number ASC", 0, 3)
        self.assertTrue(row.switch.get_active())
        self.assertTrue(row.switch.get_sensitive())
        self.assertEqual(row.label.get_field(), "tracks.number")
        self.assertTrue(row.label.get_sensitive())
        self.assertEqual(row.direction.get_icon_name(), "view-sort-ascending")
        self.assertTrue(row.direction.get_sensitive())
        self.assertFalse(row.updown.get_first_child().get_sensitive())
        self.assertTrue(row.updown.get_last_child().get_sensitive())

        row.set_item("playlist_map.rowid ASC", 1, 2)
        self.assertTrue(row.switch.get_active())
        self.assertFalse(row.switch.get_sensitive())

    def test_signals(self):
        row = sort.SortRow()
        row.connect("switched", self.on_switched)
        row.connect("reversed", self.on_reversed)
        row.connect("move-up", self.on_move_up)
        row.connect("move-down", self.on_move_down)

        row.switch.set_active(True)
        self.assertTrue(self.enabled)
        row.switch.set_active(False)
        self.assertFalse(self.enabled)

        row.direction.emit("clicked")
        self.assertTrue(self.reversed)

        row.updown.emit("move-up")
        self.assertTrue(self.move_up)

        row.updown.emit("move-down")
        self.assertTrue(self.move_down)


class TestFactory(unittest.TestCase):
    def test_init(self):
        factory = sort.Factory(model.FlatSortModel())
        self.assertIsInstance(factory, Gtk.SignalListItemFactory)