# Copyright 2024 (c) Anna Schumaker.
"""Tests our custom ListenBrainz GObject."""
import emmental.listenbrainz
import io
import unittest
from gi.repository import GObject
from gi.repository import GLib


@unittest.mock.patch("sys.stdout", new_callable=io.StringIO)
@unittest.mock.patch("gi.repository.GLib.source_remove")
@unittest.mock.patch("gi.repository.GLib.idle_add", return_value=42)
class TestListenBrainz(unittest.TestCase):
    """ListenBrainz GObject test case."""

    def setUp(self):
        """Set up common variables."""
        self.listenbrainz = emmental.listenbrainz.ListenBrainz()

    @unittest.mock.patch("gi.repository.GLib.source_remove")
    def tearDown(self, mock_source_remove: unittest.mock.Mock):
        """Clean up."""
        self.listenbrainz.stop()

    def test_init(self, mock_idle_add: unittest.mock.Mock,
                  mock_source_remove: unittest.mock.Mock,
                  mock_stdout: io.StringIO):
        """Test that the ListenBrainz GObject was set up properly."""
        self.assertIsInstance(self.listenbrainz, GObject.GObject)
        self.assertIsInstance(self.listenbrainz._queue,
                              emmental.listenbrainz.task.Queue)
        self.assertIsInstance(self.listenbrainz._thread,
                              emmental.listenbrainz.thread.Thread)
        self.assertIsNone(self.listenbrainz._idle_id)

    def test_stop(self, mock_idle_add: unittest.mock.Mock,
                  mock_source_remove: unittest.mock.Mock,
                  mock_stdout: io.StringIO):
        """Test stopping the thread during shutdown."""
        self.listenbrainz._idle_id = 12345

        self.listenbrainz.stop()
        self.assertFalse(self.listenbrainz._thread.is_alive())
        self.assertIsNone(self.listenbrainz._idle_id)
        mock_source_remove.assert_called_with(12345)

    def test_set_user_token(self, mock_idle_add: unittest.mock.Mock,
                            mock_source_remove: unittest.mock.Mock,
                            mock_stdout: io.StringIO):
        """Test setting the user-token property."""
        self.assertEqual(self.listenbrainz.user_token, "")
        self.assertTrue(self.listenbrainz.valid_token)

        idle_work = self.listenbrainz._ListenBrainz__idle_work
        with unittest.mock.patch.object(self.listenbrainz._thread,
                                        "set_user_token") as mock_set_token:
            self.listenbrainz.user_token = "abc"
            self.assertEqual(self.listenbrainz._queue._set_token,
                             ("set-token", "abc"))
            self.assertEqual(self.listenbrainz._idle_id, 42)
            mock_idle_add.assert_called_with(idle_work)

            self.assertEqual(idle_work(), GLib.SOURCE_CONTINUE)
            mock_set_token.assert_called_with("abc")

            mock_idle_add.reset_mock()
            self.listenbrainz.user_token = "abcde"
            self.assertEqual(self.listenbrainz._queue._set_token,
                             ("set-token", "abcde"))
            self.assertEqual(self.listenbrainz._idle_id, 42)
            mock_idle_add.assert_not_called()

            self.listenbrainz._thread.set_result(op="set-token", token="abc",
                                                 valid=True)
            self.assertEqual(idle_work(), GLib.SOURCE_CONTINUE)
            mock_set_token.assert_called_with("abcde")

            self.listenbrainz._thread.ready.clear()
            self.assertEqual(idle_work(), GLib.SOURCE_CONTINUE)

            for valid in [False, True]:
                with self.subTest(valid=valid):
                    self.listenbrainz._thread.set_result(op="set-token",
                                                         token="abcde",
                                                         valid=valid)
                    self.assertEqual(idle_work(), GLib.SOURCE_REMOVE)
                    self.assertEqual(self.listenbrainz.valid_token, valid)
                    self.assertIsNone(self.listenbrainz._idle_id)