# Copyright 2022 (c) Anna Schumaker.
"""Tests our library path section."""
import pathlib
import emmental.sidebar.library
import tests.util
import unittest.mock
from gi.repository import GLib
from gi.repository import Gio
from gi.repository import Gtk
from gi.repository import Adw


class TestLibraries(tests.util.TestCase):
    """Tests our Library Paths section."""

    def setUp(self):
        """Set up common variables."""
        super().setUp()
        self.libraries = emmental.sidebar.library.Section(self.sql.libraries)

    def test_init(self):
        """Test that the libraries section is set up correctly."""
        self.assertIsInstance(self.libraries, emmental.sidebar.section.Section)
        self.assertEqual(self.libraries._factory.row_type,
                         emmental.sidebar.library.LibraryRow)

        self.assertEqual(self.libraries.table, self.sql.libraries)
        self.assertEqual(self.libraries.icon_name, "library-music-symbolic")
        self.assertEqual(self.libraries.title, "Library Paths")

    def test_extra_widget(self):
        """Test the library section extra widget."""
        self.assertIsInstance(self.libraries.extra_widget, Gtk.Button)
        self.assertEqual(self.libraries.extra_widget.get_icon_name(),
                         "folder-new")
        self.assertEqual(self.libraries.extra_widget.get_tooltip_text(),
                         "add new library path")
        self.assertFalse(self.libraries.extra_widget.get_has_frame())

        mock_set_initial_file = unittest.mock.Mock()
        self.libraries._dialog.set_initial_file = mock_set_initial_file
        music = GLib.get_user_special_dir(GLib.UserDirectory.DIRECTORY_MUSIC)

        with unittest.mock.patch.object(self.libraries._dialog,
                                        "select_folder") as mock_func:
            self.libraries.extra_widget.emit("clicked")
            self.assertEqual(mock_set_initial_file.call_args[0][0].get_path(),
                             str(music))
            mock_func.assert_called_with(None, None,
                                         self.libraries._Section__async_ready)

    def test_subtitle(self):
        """Test that the subtitle property is set properly."""
        self.assertEqual(self.libraries.subtitle, "0 library paths")
        self.sql.libraries.create("/a/b/c")
        self.assertEqual(self.libraries.subtitle, "1 library path")
        self.sql.libraries.create("/a/b/d")
        self.assertEqual(self.libraries.subtitle, "2 library paths")

    def test_library_row(self):
        """Test the library playlist row."""
        library = self.sql.libraries.create(pathlib.Path("/a/b/c"))
        treeitem = Gtk.TreeListRow()
        treeitem.get_item = unittest.mock.Mock(return_value=library)
        listitem = Gtk.ListItem()
        listitem.get_item = unittest.mock.Mock(return_value=treeitem)

        row = emmental.sidebar.library.LibraryRow(listitem)
        self.assertIsInstance(row.child, emmental.sidebar.row.LibraryRow)
        self.assertFalse(row.indented)

        row.bind()
        self.assertTrue(row.child.enabled)
        self.assertTrue(row.child.scanning)
        self.assertFalse(row.child.online)

        row.child.enabled = False
        library.online = True
        library.deleting = True
        library.queue.running = False
        library.queue.progress = 0.42

        self.assertFalse(library.enabled)
        self.assertFalse(row.child.get_sensitive())
        self.assertFalse(row.child.scanning)
        self.assertTrue(row.child.online)
        self.assertEqual(row.child.progress, 0.42)
        row.unbind()

    def test_toast(self):
        """Test sending a toast notification for library online status."""
        self.assertIsNone(self.libraries._toast)

        toast = unittest.mock.Mock()
        window = unittest.mock.Mock()
        window.post_toast = unittest.mock.Mock(return_value=toast)
        self.libraries.get_ancestor = unittest.mock.Mock(return_value=window)
        self.sql.libraries.loaded = True

        library = self.sql.libraries.create("/a/b/c")
        library.online = False
        window.post_toast.assert_called_with("/a/b/c is offline")
        toast.set_priority.assert_called_with(Adw.ToastPriority.HIGH)
        toast.dismiss.assert_not_called()
        self.assertEqual(self.libraries._toast, toast)

        library.online = True
        window.post_toast.assert_called_with("/a/b/c is online")
        toast.dismiss.assert_called()

    def test_directory_filter(self):
        """Test that the directory filters list is set up properly."""
        self.assertIsInstance(emmental.sidebar.library.DIRECTORY_FILTERS,
                              Gio.ListStore)

        filter = emmental.sidebar.library.DIRECTORY_FILTERS[0]
        self.assertIsInstance(filter, Gtk.FileFilter)
        self.assertEqual(filter.get_name(), "Directories")

        (name, mime_types) = filter.to_gvariant()
        self.assertEqual(name, "Directories")
        self.assertListEqual(mime_types, [(1, "inode/directory")])
        self.assertEqual(len(mime_types), 1)

    def test_dialog(self):
        """Test that the FileDialog works as expected."""
        self.assertIsInstance(self.libraries._dialog, Gtk.FileDialog)
        self.assertEqual(self.libraries._dialog.get_title(),
                         "Pick a Directory")
        self.assertEqual(self.libraries._dialog.get_filters(),
                         emmental.sidebar.library.DIRECTORY_FILTERS)

        with unittest.mock.patch.object(self.libraries._dialog,
                                        "select_folder_finish") as mock_finish:
            task = Gio.Task()
            path = pathlib.Path("/a/b/c")
            mock_finish.return_value = Gio.File.new_for_path(str(path))

            self.libraries._Section__async_ready(self.libraries._dialog, task)
            mock_finish.assert_called_with(task)
            self.assertIsNotNone(self.sql.libraries.lookup(path))