# Copyright 2021 (c) Anna Schumaker.
import db
import sqlite3
import unittest
from gi.repository import GObject
from . import sql

class TestCollection(unittest.TestCase):
    def track_added(self, plist, added):
        self.added = added

    def track_removed(self, plist, removed, adjusted_current):
        self.removed = (removed, adjusted_current)

    def refreshed(self, plist):
        self.refreshed = True

    def setUp(self): db.reset()

    def test_init(self):
        collection = db.user.Table.find("Collection")
        self.assertIsInstance(collection, db.playlist.Playlist)
        self.assertIsInstance(collection, db.user.Collection)
        self.assertEqual(collection.name, "Collection")
        self.assertEqual(collection.icon_name, "media-playback-start")
        self.assertTrue(collection.plist_state.loop)

    def test_tracks(self):
        collection = db.user.Table.find("Collection")
        collection.connect("track-added", self.track_added)
        self.assertEqual(collection.get_n_tracks(), 0)
        self.assertEqual(collection.get_tracks(), [ ])

        track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
        self.assertEqual(collection.get_n_tracks(), 1)
        self.assertEqual(collection.get_track(0), track)
        self.assertEqual(collection.get_tracks(), [ track ])
        self.assertEqual(collection.get_track_index(track), 0)
        self.assertEqual(self.added, track)

        collection.connect("track-removed", self.track_removed)
        db.track.Table.delete(track)
        self.assertEqual(collection.get_tracks(), [ ])
        self.assertEqual(self.removed, (track, False))

    def test_library_enabled(self):
        collection = db.user.Table.find("Collection")
        track1 = db.make_fake_track(1, 1, "Test Track 1", "/a/b/c/1.ogg")
        track2 = db.make_fake_track(2, 2, "Test Track 2", "/a/b/c/2.ogg")
        self.assertEqual(collection.get_n_tracks(), 2)
        self.assertEqual(collection.get_tracks(), [ track1, track2 ])
        collection.connect("refreshed", self.refreshed)

        track1.library.enabled = False
        self.assertEqual(collection.get_n_tracks(), 0)
        self.assertEqual(collection.get_tracks(), [ ])
        self.assertTrue(self.refreshed)

        self.refreshed = None
        track1.library.enabled = True
        self.assertEqual(collection.get_n_tracks(), 2)
        self.assertEqual(collection.get_tracks(), [ track1, track2 ])
        self.assertTrue(self.refreshed)


class TestFavorites(unittest.TestCase):
    def track_added(self, plist, added):
        self.added = added

    def track_removed(self, plist, removed, adjusted_current):
        self.removed = (removed, False)

    def setUp(self): db.reset()

    def test_init(self):
        favorites = db.user.Table.find("Favorites")
        self.assertIsInstance(favorites, db.playlist.MappedPlaylist)
        self.assertIsInstance(favorites, db.user.UserPlaylist)
        self.assertEqual(favorites.name, "Favorites")
        self.assertEqual(favorites.icon_name, "emmental-favorites")
        self.assertEqual(favorites.map_table, "playlist_map")
        self.assertFalse(favorites.plist_state.loop)
        self.assertTrue(favorites.can_add_remove_tracks())

    def test_add_remove_track(self):
        favorites = db.user.Table.find("Favorites")
        track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
        favorites.connect("track-added", self.track_added)
        self.assertEqual(favorites.get_n_tracks(), 0)
        self.assertEqual(favorites.get_tracks(), [ ])

        self.assertTrue(favorites.add_track(track))
        self.assertFalse(favorites.add_track(track))
        self.assertEqual(favorites.get_n_tracks(), 1)
        self.assertEqual(favorites.get_track(0), track)
        self.assertEqual(favorites.get_tracks(), [ track ])
        self.assertEqual(favorites.get_track_index(track), 0)
        self.assertEqual(self.added, track)

        favorites.connect("track-removed", self.track_removed)
        self.assertTrue(favorites.remove_track(track))
        self.assertFalse(favorites.remove_track(track))
        self.assertEqual(favorites.get_n_tracks(), 0)
        self.assertEqual(favorites.get_tracks(), [ ])
        self.assertEqual(self.removed, (track, False))


class TestNewTracks(unittest.TestCase):
    def track_added(self, plist, added):
        self.added = added

    def track_removed(self, plist, removed, adjusted_current):
        self.removed = (removed, adjusted_current)

    def setUp(self): db.reset()

    def test_init(self):
        new = db.user.Table.find("New Tracks")
        self.assertIsInstance(new, db.playlist.MappedPlaylist)
        self.assertIsInstance(new, db.user.UserPlaylist)
        self.assertEqual(new.name, "New Tracks")
        self.assertEqual(new.icon_name, "starred")
        self.assertEqual(new.map_table, "temp_playlist_map")
        self.assertFalse(new.plist_state.loop)
        self.assertFalse(new.can_add_remove_tracks())

    def test_add_remove_track(self):
        new = db.user.Table.find("New Tracks")
        new.connect("track-added", self.track_added)
        self.assertEqual(new.get_n_tracks(), 0)
        self.assertEqual(new.get_tracks(), [ ])

        track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
        self.assertEqual(new.get_n_tracks(), 1)
        self.assertEqual(new.get_track(0), track)
        self.assertEqual(new.get_tracks(), [ track ])
        self.assertEqual(new.get_track_index(track), 0)
        self.added = track

        new.connect("track-removed", self.track_removed)
        self.assertTrue(new.remove_track(track))
        self.assertFalse(new.remove_track(track))
        self.assertEqual(new.get_n_tracks(), 0)
        self.assertEqual(new.get_tracks(), [ ])
        self.assertEqual(self.removed, (track, False))


class TestPrevious(unittest.TestCase):
    def track_added(self, plist, added):
        self.added = added

    def track_removed(self, plist, removed, adjusted_current):
        self.removed = (removed, adjusted_current)

    def setUp(self): db.reset()

    def test_init(self):
        previous = db.user.Table.find("Previous")
        self.assertIsInstance(previous, db.user.UserPlaylist)
        self.assertIsInstance(previous, db.user.Previous)
        self.assertEqual(previous.name, "Previous")
        self.assertEqual(previous.icon_name, "media-skip-backward")
        self.assertEqual(previous.map_table, "temp_playlist_map")
        self.assertEqual(previous.plist_state.sort, [ "temp_playlist_map.rowid DESC" ])
        self.assertFalse(previous.plist_state.loop)
        self.assertFalse(previous.can_add_remove_tracks())

    def test_add_remove_track(self):
        previous = db.user.Table.find("Previous")
        track1 = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
        track2 = db.make_fake_track(2, 2, "Test Track 2", "/a/b/c/2.ogg")
        previous.connect("track-added", self.track_added)
        self.assertEqual(previous.get_n_tracks(), 0)
        self.assertEqual(previous.get_tracks(), [ ])

        self.assertTrue(previous.add_track(track1))
        self.assertEqual(previous.get_n_tracks(), 1)
        self.assertEqual(previous.get_track(0), track1)
        self.assertEqual(previous.get_tracks(), [ track1 ])
        self.assertEqual(previous.get_track_index(track1), 0)
        self.assertEqual(self.added, track1)

        self.assertTrue(previous.add_track(track2))
        self.assertEqual(previous.get_n_tracks(), 2)
        self.assertEqual(previous.get_track(0), track2)
        self.assertEqual(previous.get_track(1), track1)
        self.assertEqual(previous.get_tracks(), [ track2, track1 ])
        self.assertEqual(previous.get_track_index(track2), 0)
        self.assertEqual(previous.get_track_index(track1), 1)
        self.assertEqual(self.added, track2)

        previous.connect("track-removed", self.track_removed)
        self.assertTrue(previous.add_track(track1))
        self.assertEqual(previous.get_n_tracks(), 2)
        self.assertEqual(previous.get_track(0), track1)
        self.assertEqual(previous.get_track(1), track2)
        self.assertEqual(previous.get_tracks(), [ track1, track2 ])
        self.assertEqual(previous.get_track_index(track1), 0)
        self.assertEqual(previous.get_track_index(track2), 1)
        self.assertEqual(self.removed, (track1, False))
        self.assertEqual(self.added, track1)

        self.assertTrue(previous.remove_track(track1))
        self.assertFalse(previous.remove_track(track1))
        self.assertEqual(previous.get_n_tracks(), 1)
        self.assertEqual(previous.get_tracks(), [ track2 ])
        self.assertEqual(previous.get_track_index(track2), 0)
        self.assertEqual(self.removed, (track1, True))

    def test_previous_track(self):
        previous = db.user.Table.find("Previous")
        self.assertEqual(previous.get_property("current"), -1)

        previous.add_track(db.make_fake_track(1, 1, "Track 1", "/a/b/c/1.ogg"))
        self.assertEqual(previous.get_property("current"), 0)
        previous.add_track(db.make_fake_track(2, 2, "Track 2", "/a/b/c/2.ogg"))
        self.assertEqual(previous.get_property("current"), 0)
        previous.add_track(db.make_fake_track(3, 3, "Track 3", "/a/b/c/3.ogg"))
        self.assertEqual(previous.get_property("current"), 0)

        self.assertEqual(previous.previous_track(), previous.get_track(1))
        self.assertEqual(previous.previous_track(), previous.get_track(2))
        self.assertIsNone(previous.previous_track())
        self.assertIsNone(previous.previous_track())

    def test_next_track(self):
        previous = db.user.Table.find("Previous")
        previous.add_track(db.make_fake_track(1, 1, "Track 1", "/a/b/c/1.ogg"))
        previous.add_track(db.make_fake_track(2, 2, "Track 2", "/a/b/c/2.ogg"))
        previous.add_track(db.make_fake_track(3, 3, "Track 3", "/a/b/c/3.ogg"))
        previous.current = 2

        self.assertEqual(previous.next_track(), previous.get_track(1))
        self.assertEqual(previous.current, 1)
        self.assertEqual(previous.next_track(), previous.get_track(0))
        self.assertEqual(previous.current, 0)
        self.assertIsNone(previous.next_track())
        self.assertEqual(previous.current, -1)
        self.assertIsNone(previous.next_track())
        self.assertEqual(previous.current, -1)


class TestQueuedTracks(unittest.TestCase):
    def track_added(self, plist, added):
        self.added = added

    def track_removed(self, plist, removed, adjusted_current):
        self.removed = (removed, adjusted_current)

    def setUp(self): db.reset()

    def test_init(self):
        queued = db.user.Table.find("Queued Tracks")
        self.assertIsInstance(queued, db.user.UserPlaylist)
        self.assertIsInstance(queued, db.user.QueuedTracks)
        self.assertEqual(queued.name, "Queued Tracks")
        self.assertEqual(queued.icon_name, "media-skip-forward")
        self.assertEqual(queued.map_table, "playlist_map")
        self.assertEqual(queued.plist_state.sort, [ "playlist_map.rowid ASC" ])
        self.assertFalse(queued.plist_state.loop)
        self.assertTrue(queued.can_add_remove_tracks())

    def test_add_remove_track(self):
        queued = db.user.Table.find("Queued Tracks")
        track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
        queued.connect("track-added", self.track_added)
        self.assertEqual(queued.get_n_tracks(), 0)
        self.assertEqual(queued.get_tracks(), [ ])

        self.assertTrue(queued.add_track(track))
        self.assertFalse(queued.add_track(track))
        self.assertEqual(queued.get_n_tracks(), 1)
        self.assertEqual(queued.get_track(0), track)
        self.assertEqual(queued.get_tracks(), [ track ])
        self.assertEqual(queued.get_track_index(track), 0)
        self.assertEqual(self.added, track)

        queued.connect("track-removed", self.track_removed)
        self.assertTrue(queued.remove_track(track))
        self.assertFalse(queued.remove_track(track))
        self.assertEqual(queued.get_n_tracks(), 0)
        self.assertEqual(queued.get_tracks(), [ ])
        self.assertEqual(self.removed, (track, False))

    def test_next_track(self):
        queued = db.user.Table.find("Queued Tracks")
        queued.add_track(db.make_fake_track(1, 1, "Test 1", "/a/b/c/1.ogg"))
        queued.add_track(db.make_fake_track(2, 2, "Test 2", "/a/b/c/2.ogg"))
        queued.add_track(db.make_fake_track(3, 3, "Test 3", "/a/b/c/3.ogg"))

        self.assertEqual(queued.next_track(), db.track.Table.lookup("/a/b/c/1.ogg"))
        self.assertEqual(queued.get_n_tracks(), 2)
        self.assertEqual(queued.next_track(), db.track.Table.lookup("/a/b/c/2.ogg"))
        self.assertEqual(queued.get_n_tracks(), 1)
        self.assertEqual(queued.next_track(), db.track.Table.lookup("/a/b/c/3.ogg"))
        self.assertEqual(queued.get_n_tracks(), 0)
        self.assertIsNone(queued.next_track())


class TestUserPlaylist(unittest.TestCase):
    def track_added(self, plist, added):
        self.added = added

    def track_removed(self, plist, removed, adjusted_current):
        self.removed = (removed, adjusted_current)

    def setUp(self): db.reset()

    def test_init(self):
        plist = db.user.Table.find("Test Playlist")
        self.assertIsInstance(plist, db.playlist.MappedPlaylist)
        self.assertIsInstance(plist, db.user.UserPlaylist)
        self.assertEqual(plist.name, "Test Playlist")
        self.assertEqual(plist.icon_name, "audio-x-generic")
        self.assertEqual(plist.map_table, "playlist_map")
        self.assertFalse(plist.plist_state.loop)
        self.assertTrue(plist.can_add_remove_tracks())

    def test_delete(self):
        track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
        plist = db.user.Table.find("Test Playlist")
        plist.add_track(track)
        plist.delete()
        self.assertEqual(plist.get_n_tracks(), 0)
        self.assertIsNone(db.user.Table.lookup("Test Playlist"))

    def test_add_remove_track(self):
        plist = db.user.Table.find("Test Playlist")
        track = db.make_fake_track(1, 1, "Test Track", "/a/b/c/1.ogg")
        plist.connect("track-added", self.track_added)
        self.assertEqual(plist.get_n_tracks(), 0)
        self.assertEqual(plist.get_tracks(), [ ])

        self.assertTrue(plist.add_track(track))
        self.assertFalse(plist.add_track(track))
        self.assertEqual(plist.get_n_tracks(), 1)
        self.assertEqual(plist.get_track(0), track)
        self.assertEqual(plist.get_tracks(), [ track ])
        self.assertEqual(plist.get_track_index(track), 0)
        self.assertEqual(self.added, track)

        plist.connect("track-removed", self.track_removed)
        self.assertTrue(plist.remove_track(track))
        self.assertFalse(plist.remove_track(track))
        self.assertEqual(plist.get_n_tracks(), 0)
        self.assertEqual(plist.get_tracks(), [ ])
        self.assertEqual(self.removed, (track, False))


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

    def test_init(self):
        table = db.user.UserTable()
        self.assertIsInstance(table, db.playlist.Model)
        self.assertEqual(table.table, "playlists")
        self.assertEqual(table.order, "sort")

        self.assertIsInstance(db.user.Table, db.user.UserTable)
        db.sql.execute("SELECT playlistid,plstateid,name,sort FROM playlists")

    def test_insert(self):
        table = db.user.UserTable()
        playlist = table.find("Test Playlist")

        self.assertIsInstance(playlist, db.user.UserPlaylist)
        self.assertEqual(playlist._name, "Test Playlist")
        self.assertEqual(playlist._rowkey, "playlistid")

        with self.assertRaises(sqlite3.IntegrityError):
            db.user.Table.insert("Test Playlist")

    def test_lookup(self):
        playlist = db.user.Table.insert("Test Playlist")
        self.assertEqual(db.user.Table.lookup("Test Playlist"), playlist)
        self.assertIsNone(db.user.Table.lookup("none"))

    def test_default_playlists(self):
        table = db.user.UserTable()
        self.assertEqual(table.get_n_items(), 5)
        self.assertEqual(table.get_item(0).name, "Collection")
        self.assertEqual(table.get_item(1).name, "Favorites")
        self.assertEqual(table.get_item(2).name, "New Tracks")
        self.assertEqual(table.get_item(3).name, "Previous")
        self.assertEqual(table.get_item(4).name, "Queued Tracks")