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

expected = [ (1, 1, "Collection",    "collection",    0, 1),
             (2, 2, "Favorites",     "favorites",     0, 0),
             (3, 3, "New Tracks",    "new tracks",    0, 0),
             (4, 4, "Previous",      "previous",      0, 0),
             (5, 5, "Queued Tracks", "queued tracks", 0, 0) ]


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

    def test_playlist_table_init(self):
        self.assertIsInstance(db.user.Table, db.user.PlaylistTable)
        self.assertEqual(db.user.Default, [ "Collection", "Favorites", "New Tracks",
                                                "Previous", "Queued Tracks" ])

        cur = db.sql.execute("SELECT playlistid, "
                                    "playlists.plstateid, "
                                    "name, "
                                    "playlists.sort, "
                                    "random,loop "
                             "FROM playlists "
                             "JOIN playlist_states "
                             "ON playlists.plstateid = playlist_states.plstateid")
        rows = cur.fetchall()
        self.assertEqual(tuple(rows[0]), expected[0])
        self.assertEqual(tuple(rows[1]), expected[1])
        self.assertEqual(tuple(rows[2]), expected[2])
        self.assertEqual(tuple(rows[3]), expected[3])
        self.assertEqual(tuple(rows[4]), expected[4])

    def test_playlist_table_insert(self):
        playlist = db.user.Table.insert("Test Playlist")
        self.assertIsInstance(playlist, db.user.Playlist)
        self.assertIsInstance(playlist, db.objects.Tag)

        self.assertEqual(playlist.name, "Test Playlist")
        self.assertEqual(playlist.sort, "test playlist")
        self.assertIsInstance(playlist.playlist_state, db.state.PlaylistState)

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

    def test_playlist_table_delete(self):
        playlist = db.user.Table.find("Test Playlist")
        track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")

        db.user.Map.insert(playlist, track)
        db.user.TempMap.insert(playlist, track)
        db.user.Table.delete(playlist)

        self.assertIsNone(db.user.Table.lookup("Test Playlist"))
        self.assertEqual(db.user.Map.lookup_playlists(track), [ ])
        self.assertEqual(db.user.TempMap.lookup_playlists(track), [ ])

    def test_playlist_table_get(self):
        playlist = db.user.Playlist(1)
        self.assertEqual(db.user.Table.get(1), playlist)
        self.assertIsNone(db.user.Table.get(6))

    def test_playlist_table_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_playlist_create_default_playlists(self):
        db.user.Table.create_default_playlists()


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

    def test_playlist_map_init(self):
        self.assertIsInstance(db.user.Map, db.user.PlaylistMap)
        self.assertIsInstance(db.user.TempMap, db.user.PlaylistMap)

        self.assertEqual(db.user.Map.map_lhs, db.user.Playlist)
        self.assertEqual(db.user.Map.map_rhs, db.track.Track)

        self.assertFalse(db.user.Map.temporary)
        self.assertTrue( db.user.TempMap.temporary)

        db.sql.execute("SELECT playlistid,trackid FROM playlist_map")
        db.sql.execute("SELECT playlistid,trackid FROM temp_playlist_map")

    def test_playlist_map_insert(self):
        track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
        collection = db.user.Table.find("Collection")

        db.user.Map.insert(collection, track)
        with self.assertRaises(sqlite3.IntegrityError):
            db.user.Map.insert(collection, track)

    def test_playlist_map_delete(self):
        track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
        playlist = db.user.Table.find("Test Playlist")

        db.user.Map.insert(playlist, track)
        db.user.Map.delete(playlist, track)
        self.assertEqual(db.user.Map.lookup_tracks(playlist), [ ])

    def test_playlist_map_lookup_tracks(self):
        track1 = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
        track2 = db.make_fake_track(2, 2.345, "Test Title 2", "/a/c.def")
        playlist = db.user.Table.find("Collection")

        db.user.Map.insert(playlist, track1)
        db.user.Map.insert(playlist, track2)

        lookup_res = db.user.Map.lookup_tracks(playlist)
        self.assertEqual(lookup_res, [ track1, track2 ])

    def test_playlist_map_lookup_playlists(self):
        track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
        collection = db.user.Table.find("Collection")
        favorites  = db.user.Table.find("Favorites")

        db.user.Map.insert(collection, track)
        db.user.Map.insert(favorites, track)

        lookup_res = db.user.Map.lookup_playlists(track)
        self.assertEqual(lookup_res, [ collection, favorites ])

    def test_playlist_map_delete_track(self):
        track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
        collection = db.user.Table.find("Collection")
        favorites  = db.user.Table.find("Favorites")

        db.user.Map.insert(collection, track)
        db.user.Map.insert(favorites, track)

        db.user.Map.delete_track(track)
        self.assertEqual(db.user.Map.lookup_playlists(track), [ ])

    def test_playlist_map_delete_playlist(self):
        track1 = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
        track2 = db.make_fake_track(2, 2.345, "Test Title 2", "/a/c.def")
        playlist = db.user.Table.find("Collection")

        db.user.Map.insert(playlist, track1)
        db.user.Map.insert(playlist, track2)

        db.user.Map.delete_playlist(playlist)
        self.assertEqual(db.user.Map.lookup_tracks(playlist), [ ])