# Copyright 2022 (c) Anna Schumaker.
"""Test our button helper classes."""
import unittest
import unittest.mock
import emmental.buttons
from gi.repository import Gtk


class TestButton(unittest.TestCase):
    """Test a Button."""

    def setUp(self):
        """Set up common variables."""
        self.button = emmental.buttons.Button()

    def test_init(self):
        """Test that the button is configured correctly."""
        self.assertIsInstance(self.button, Gtk.Button)
        self.assertIsInstance(self.button._image, Gtk.Image)
        self.assertEqual(self.button.get_child(), self.button._image)
        self.assertFalse(self.button.get_focusable())

    def test_icon_name(self):
        """Test the icon-name property."""
        self.assertEqual(self.button.icon_name, "")
        self.button.icon_name = "icon-name"
        self.assertEqual(self.button._image.get_icon_name(), "icon-name")

        button2 = emmental.buttons.Button(icon_name="icon-name")
        self.assertEqual(button2.icon_name, "icon-name")
        self.assertEqual(button2._image.get_icon_name(), "icon-name")

    def test_icon_opacity(self):
        """Test the icon-opacity property."""
        self.assertEqual(self.button.icon_opacity, 1.0)
        self.button.icon_opacity = 0.5
        self.assertAlmostEqual(self.button._image.get_opacity(),
                               0.5, delta=0.005)

        button2 = emmental.buttons.Button(icon_opacity=0.25)
        self.assertAlmostEqual(button2.icon_opacity, 0.25, delta=0.005)
        self.assertAlmostEqual(button2._image.get_opacity(), 0.25, delta=0.005)

    def test_large_icon(self):
        """Test the large-icon property."""
        self.assertFalse(self.button.large_icon)
        self.assertEqual(self.button._image.get_icon_size(),
                         Gtk.IconSize.NORMAL)

        self.button.large_icon = True
        self.assertEqual(self.button._image.get_icon_size(),
                         Gtk.IconSize.LARGE)

        button2 = emmental.buttons.Button(large_icon=True)
        self.assertTrue(button2.large_icon)
        self.assertEqual(button2._image.get_icon_size(), Gtk.IconSize.LARGE)


class TestPopoverButton(unittest.TestCase):
    """Test a Popover Button."""

    def setUp(self):
        """Set up common variables."""
        self.button = emmental.buttons.PopoverButton()

    def test_button(self):
        """Test that the popover button is configured correctly."""
        self.assertIsInstance(self.button, Gtk.MenuButton)
        self.assertIsInstance(self.button.get_popover(), Gtk.Popover)

    def test_popover_child(self):
        """Test setting a child widget to the popover button."""
        self.assertIsNone(self.button.popover_child)
        self.button.popover_child = Gtk.Label()
        self.assertEqual(self.button.get_popover().get_child(),
                         self.button.popover_child)

        button2 = emmental.buttons.PopoverButton(popover_child=Gtk.Label())
        self.assertIsInstance(button2.popover_child, Gtk.Label)
        self.assertEqual(button2.get_popover().get_child(),
                         button2.popover_child)

    def test_popdown(self):
        """Test the popdown() function."""
        self.button.popdown()


class TestSplitButton(unittest.TestCase):
    """Test a Split Button."""

    def setUp(self):
        """Set up common variables."""
        self.secondary = Gtk.Button()
        self.button = emmental.buttons.SplitButton(secondary=self.secondary)

    def test_button(self):
        """Test that the split button is configured correctly."""
        self.assertIsInstance(self.button, Gtk.Box)
        self.assertIsInstance(self.button._primary, emmental.buttons.Button)
        self.assertIsInstance(self.button._separator, Gtk.Separator)
        self.assertEqual(self.button._secondary, self.secondary)

        self.assertTrue(self.button._primary.get_hexpand())

        self.assertEqual(self.button._separator.get_orientation(),
                         Gtk.Orientation.VERTICAL)
        self.assertEqual(self.button._separator.get_margin_top(), 12)
        self.assertEqual(self.button._separator.get_margin_bottom(), 12)

        self.assertEqual(self.button.get_first_child(), self.button._primary)
        self.assertEqual(self.button._primary.get_next_sibling(),
                         self.button._separator)
        self.assertEqual(self.button._separator.get_next_sibling(),
                         self.secondary)

        self.assertTrue(self.button.has_css_class("emmental-splitbutton"))

    def test_icon_name(self):
        """Test the icon name property."""
        self.assertEqual(self.button.icon_name, "")
        self.button.icon_name = "icon-name"
        self.assertEqual(self.button._primary.icon_name, "icon-name")

        button2 = emmental.buttons.SplitButton(icon_name="icon-name",
                                               secondary=Gtk.Button())
        self.assertEqual(button2.icon_name, "icon-name")
        self.assertEqual(button2._primary.icon_name, "icon-name")

    def test_large_icon(self):
        """Test the large icon property."""
        self.assertFalse(self.button.large_icon)
        self.button.large_icon = True
        self.assertTrue(self.button._primary.large_icon)

        button2 = emmental.buttons.SplitButton(large_icon=True,
                                               secondary=Gtk.Button())
        self.assertTrue(button2.large_icon)
        self.assertTrue(button2._primary.large_icon)

    def test_secondary(self):
        """Test the secondary property."""
        self.assertEqual(self.button.secondary, self.secondary)
        with self.assertRaises(TypeError):
            self.button.secondary = Gtk.Button()
        self.assertEqual(self.button.secondary, self.secondary)

    def test_clicked(self):
        """Test the clicked signal."""
        on_click = unittest.mock.Mock()
        self.button.connect("clicked", on_click)
        self.button._primary.emit("clicked")
        on_click.assert_called_with(self.button)

    def test_activate(self):
        """Test the activate function."""
        activate = unittest.mock.Mock()
        primary = unittest.mock.Mock()

        self.button.connect("activate-primary", primary)
        self.button._primary.connect("activate", activate)

        self.button.activate()
        activate.assert_called()
        primary.assert_called()


class TestImageToggle(unittest.TestCase):
    """Test an ImageToggle button."""

    def setUp(self):
        """Set up common variables."""
        self.button = emmental.buttons.ImageToggle("active", "inactive")

    def test_init(self):
        """Test that the ImageToggle button is configured correctly."""
        self.assertIsInstance(self.button, emmental.buttons.Button)
        self.assertEqual(self.button.active_icon_name, "active")
        self.assertEqual(self.button.inactive_icon_name, "inactive")
        self.assertEqual(self.button.icon_name, "inactive")
        self.assertFalse(self.button.active)

    def test_active(self):
        """Test the active property."""
        self.button.active = True
        self.assertTrue(self.button.active)
        self.assertEqual(self.button.icon_name, "active")

        self.button.active = False
        self.assertFalse(self.button.active)
        self.assertEqual(self.button.icon_name, "inactive")

        button2 = emmental.buttons.ImageToggle("active", "inactive",
                                               active=True)
        self.assertTrue(button2.active)

    def test_tooltip_text(self):
        """Test the active and inactive tooltip text."""
        self.assertEqual(self.button.active_tooltip_text, None)
        self.assertEqual(self.button.inactive_tooltip_text, None)

        button2 = emmental.buttons.ImageToggle("active", "inactive",
                                               "active tooltip text",
                                               "inactive tooltip text")
        self.assertEqual(button2.active_tooltip_text, "active tooltip text")
        self.assertEqual(button2.inactive_tooltip_text,
                         "inactive tooltip text")
        self.assertEqual(button2.get_tooltip_text(), "inactive tooltip text")

        button2.active = True
        self.assertEqual(button2.get_tooltip_text(), "active tooltip text")
        button2.active = False
        self.assertEqual(button2.get_tooltip_text(), "inactive tooltip text")

    def test_changing_tooltip_text(self):
        """Test changing the tooltip text for the current state."""
        self.assertEqual(self.button.props.tooltip_text, None)
        self.button.inactive_tooltip_text = "inactive tooltip"
        self.assertEqual(self.button.props.tooltip_text, "inactive tooltip")

        self.button.active = True
        self.assertEqual(self.button.props.tooltip_text, None)
        self.button.active_tooltip_text = "active tooltip"
        self.assertEqual(self.button.props.tooltip_text, "active tooltip")

    def test_toggle(self):
        """Test the toggle signal."""
        toggled = unittest.mock.Mock()
        self.button.connect("toggled", toggled)

        self.button.active = False
        toggled.assert_not_called()

        self.button.active = True
        toggled.assert_called()

        toggled.reset_mock()
        self.button.emit("clicked")
        self.assertFalse(self.button.active)
        toggled.assert_called()