# Copyright 2021 (c) Anna Schumaker.
import audio
import db
import lib
import unittest
from gi.repository import Gtk
from . import column

class FakeListItem:
    def __init__(self): self.child = None
    def get_item(self): return None
    def get_child(self): return self.child
    def set_child(self, child): self.child = child


class TestLabelFactory(unittest.TestCase):
    def setUp(self): db.reset()

    def test_init(self):
        factory = column.LabelFactory(0.5)
        self.assertIsInstance(factory, Gtk.SignalListItemFactory)
        self.assertEqual(factory.xalign, 0.5)

    def test_label(self):
        audio.Player.track = None
        track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
        label = column.TrackLabel()

        self.assertIsInstance(label, Gtk.Label)
        self.assertIsNone(label.get_attributes())

        label.set_attributes(column.BoldAttr)
        label.set_item(track, "Test Track")
        self.assertEqual(label.get_text(), "Test Track")
        self.assertIsNone(label.get_attributes())

        audio.Player.change_track(track)
        self.assertIsNotNone(label.get_attributes())

        label.unset_item(track)
        self.assertEqual(label.get_text(), "")

    def test_setup_teardown(self):
        fake = FakeListItem()
        factory = column.LabelFactory(0.5)

        factory.on_setup(factory, fake)
        self.assertIsInstance(fake.child, column.TrackLabel)
        self.assertEqual(fake.child.get_xalign(), 0.5)

        factory.on_teardown(factory, fake)
        self.assertIsNone(fake.child)

    def test_bind_unbind(self):
        track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
        fake = FakeListItem()
        factory = column.LabelFactory(0.5)
        factory.on_setup(factory, fake)

        with self.assertRaises(NotImplementedError):
            factory.on_bind(factory, fake)

        fake.child.set_item(track, "abcde")
        factory.on_unbind(factory, fake)
        self.assertEqual(fake.child.get_text(), "")


class TestColumnFactories(unittest.TestCase):
    def setUp(self):
        db.reset()
        self.track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")

    def test_trackno(self):
        factory = column.TracknoFactory()
        self.assertIsInstance(factory, column.LabelFactory)
        self.assertEqual(factory.get_track_text(self.track), "1-01")
        self.assertEqual(factory.xalign, 1)

    def test_title(self):
        factory = column.TitleFactory()
        self.assertIsInstance(factory, column.LabelFactory)
        self.assertEqual(factory.get_track_text(self.track), "Test Track")

    def test_length(self):
        factory = column.LengthFactory()
        self.assertIsInstance(factory, column.LabelFactory)
        self.assertEqual(factory.get_track_text(self.track), "0:01")
        self.assertEqual(factory.xalign, 1)

    def test_artist(self):
        factory = column.ArtistFactory()
        self.assertIsInstance(factory, column.LabelFactory)
        self.assertEqual(factory.get_track_text(self.track), "Test Artist")

    def test_album(self):
        factory = column.AlbumFactory()
        self.assertIsInstance(factory, column.LabelFactory)
        self.assertEqual(factory.get_track_text(self.track), "Test Album")

    def test_subtitle(self):
        factory = column.SubtitleFactory()
        self.assertIsInstance(factory, column.LabelFactory)
        self.assertEqual(factory.get_track_text(self.track), "Disc 1")
        self.assertTrue(factory.get_track_dim(self.track))
        self.track.disc._subtitle = "Test Subtitle"
        self.assertEqual(factory.get_track_text(self.track), "Test Subtitle")
        self.assertFalse(factory.get_track_dim(self.track))

    def test_year(self):
        factory = column.YearFactory()
        self.assertIsInstance(factory, column.LabelFactory)
        self.assertEqual(factory.get_track_text(self.track), "2021")
        self.assertEqual(factory.xalign, 1)

    def test_playcount(self):
        factory = column.PlayCountFactory()
        self.assertIsInstance(factory, column.LabelFactory)
        self.assertEqual(factory.get_track_text(self.track), "0")
        self.assertEqual(factory.xalign, 1)

    def test_lastplayed(self):
        factory = column.LastPlayedFactory()
        self.assertIsInstance(factory, column.LabelFactory)
        self.assertEqual(factory.get_track_text(self.track), "Never")
        self.track.played()
        self.assertNotEqual(factory.get_track_text(self.track), "Never")


class TestColumn(unittest.TestCase):
    def test_init(self):
        factory = column.LabelFactory(0.5)
        col = column.Column("Test", factory)

        self.assertIsInstance(col, Gtk.ColumnViewColumn)
        self.assertEqual(col.get_title(), "Test")
        self.assertEqual(col.get_factory(), factory)
        self.assertFalse(col.get_expand())
        self.assertTrue(col.get_resizable())

        col = column.Column("Test2", factory, expand=True)
        self.assertTrue(col.get_expand())

    def test_width(self):
        factory = column.LabelFactory(0.5)
        col = column.Column("Test", factory, width=-1)

        self.assertEqual(lib.settings.get_int("column.Test"), -1)
        col.set_fixed_width(200)
        self.assertEqual(lib.settings.get_int("column.Test"), 200)

        col2 = column.Column("Test", factory, width=-1)
        self.assertEqual(col2.get_fixed_width(), 200)


class TestColumns(unittest.TestCase):
    def test_trackno(self):
        col = column.TracknoColumn()
        self.assertIsInstance(col, column.Column)
        self.assertIsInstance(col.get_factory(), column.TracknoFactory)
        self.assertEqual(col.get_title(), "#")

    def test_title(self):
        col = column.TitleColumn()
        self.assertIsInstance(col, column.Column)
        self.assertIsInstance(col.get_factory(), column.TitleFactory)
        self.assertEqual(col.get_title(), "Title")
        self.assertEqual(col.get_fixed_width(), 250)
        self.assertTrue(col.get_expand())

    def test_length(self):
        col = column.LengthColumn()
        self.assertIsInstance(col, column.Column)
        self.assertIsInstance(col.get_factory(), column.LengthFactory)
        self.assertEqual(col.get_title(), "Length")

    def test_artist(self):
        col = column.ArtistColumn()
        self.assertIsInstance(col, column.Column)
        self.assertIsInstance(col.get_factory(), column.ArtistFactory)
        self.assertEqual(col.get_title(), "Artist")
        self.assertEqual(col.get_fixed_width(), 150)
        self.assertTrue(col.get_expand())

    def test_album(self):
        col = column.AlbumColumn()
        self.assertIsInstance(col, column.Column)
        self.assertIsInstance(col.get_factory(), column.AlbumFactory)
        self.assertEqual(col.get_title(), "Album")
        self.assertEqual(col.get_fixed_width(), 150)
        self.assertTrue(col.get_expand())

    def test_subtitle(self):
        col = column.SubtitleColumn()
        self.assertIsInstance(col, column.Column)
        self.assertIsInstance(col.get_factory(), column.SubtitleFactory)
        self.assertEqual(col.get_title(), "Subtitle")
        self.assertEqual(col.get_fixed_width(), 150)
        self.assertTrue(col.get_expand())

    def test_year(self):
        col = column.YearColumn()
        self.assertIsInstance(col, column.Column)
        self.assertIsInstance(col.get_factory(), column.YearFactory)
        self.assertEqual(col.get_title(), "Year")

    def test_playcount(self):
        col = column.PlayCountColumn()
        self.assertIsInstance(col, column.Column)
        self.assertIsInstance(col.get_factory(), column.PlayCountFactory)
        self.assertEqual(col.get_title(), "Count")

    def test_lastplayed(self):
        col = column.LastPlayedColumn()
        self.assertIsInstance(col, column.Column)
        self.assertIsInstance(col.get_factory(), column.LastPlayedFactory)
        self.assertEqual(col.get_title(), "Last Played")