"""The once-only skin defaults under the first-run guide (wcs/skin/defaults.first_setup, wcs/onboarding/launch.prepare_skin).

Found in a Windows Kodi with Milionář 1.0 and a TMDb key (scripts/install_harness/whisky_kodi.py): the guide covered Home,
Home's <onload> defaults waited, Home did not load again after the guide and stayed without rows until Kodi restarted.
"""
import importlib.util
import pathlib
import sys
import types
import unittest
from unittest.mock import Mock, patch

ROOT = pathlib.Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))


def _load(name, path, modules):
    with patch.dict(sys.modules, modules):
        spec = importlib.util.spec_from_file_location(name, ROOT / path)
        module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(module)
    return module


class FirstSetup(unittest.TestCase):
    def setUp(self):
        self.flags, self.strings = set(), {}
        self.xbmc = types.ModuleType('xbmc')
        self.xbmc.LOGINFO, self.xbmc.LOGWARNING = 1, 2
        self.xbmc.log = Mock()
        self.xbmc.getCondVisibility = lambda c: c[len('Skin.HasSetting('):-1] in self.flags
        self.xbmc.getInfoLabel = lambda label: self.strings.get(label[len('Skin.String('):-1], '')
        self.xbmc.executebuiltin = Mock(side_effect=self._builtin)
        self.navigation = types.SimpleNamespace(FLAG='MilionarNavigationV1', migrate=Mock(), repair_titles=Mock())
        self.slots = types.SimpleNamespace(GENRES_FLAG='MilionarGenresV2', SERVICES_FLAG='MilionarServicesV1',
                                           RADIO_FLAG='MilionarRadioV1', add_genres_row=Mock(), add_services_row=Mock(),
                                           add_radio_rows=Mock(), apply_defaults=Mock(), _set=Mock())
        skin = types.ModuleType('wcs.skin')
        skin.navigation, skin.slots = self.navigation, self.slots
        self.modules = {'xbmc': self.xbmc, 'xbmcaddon': types.ModuleType('xbmcaddon'),
                        'xbmcvfs': types.ModuleType('xbmcvfs'), 'wcs.skin': skin,
                        'wcs.skin.navigation': self.navigation, 'wcs.skin.slots': self.slots}
        self.defaults = _load('defaults_under_test', 'wcs/skin/defaults.py', self.modules)
        self.defaults.load = lambda: {'strings': {}, 'flags': {}}
        started = patch.dict(sys.modules, self.modules)
        started.start()
        self.addCleanup(started.stop)

    def _builtin(self, command, wait=False):
        if command.startswith('Skin.SetBool('):
            self.flags.add(command[len('Skin.SetBool('):-1])

    def test_old_addon_without_the_skin_gets_every_default(self):
        self.assertTrue(self.defaults.first_setup())
        self.slots.apply_defaults.assert_any_call()                       # apply(): all sections
        self.navigation.migrate.assert_called_once()
        self.slots.add_genres_row.assert_called_once()
        self.slots.add_radio_rows.assert_called_once()
        self.assertIn(self.defaults.FLAG, self.flags)

    def test_skin_with_its_defaults_is_left_alone(self):
        self.flags |= {self.defaults.FLAG, 'MilionarNavigationV1', 'MilionarNavigationTitlesV1', 'MilionarGenresV2',
                       'MilionarServicesV1', 'MilionarRadioV1'}
        self.strings['mil.foryou.1.type'] = 'fy_continue'
        self.assertFalse(self.defaults.first_setup())
        self.slots.apply_defaults.assert_not_called()
        self.navigation.migrate.assert_not_called()

    def test_only_the_missing_flag_is_written(self):
        self.flags |= {self.defaults.FLAG, 'MilionarNavigationV1', 'MilionarNavigationTitlesV1', 'MilionarGenresV2',
                       'MilionarServicesV1'}
        self.strings['mil.foryou.1.type'] = 'fy_continue'
        self.assertTrue(self.defaults.first_setup())
        self.slots.add_radio_rows.assert_called_once()
        self.slots.apply_defaults.assert_not_called()


class PrepareSkin(unittest.TestCase):
    """The switch happened before (transition done): the defaults the cover held back, then one skin load."""

    def setUp(self):
        self.xbmc = types.ModuleType('xbmc')
        self.xbmc.LOGINFO, self.xbmc.LOGWARNING = 1, 2
        self.xbmc.log = Mock()
        self.xbmc.getSkinDir = lambda: 'skin.milionar'
        self.xbmc.executebuiltin = Mock()
        self.addon = Mock()
        addon = types.ModuleType('xbmcaddon')
        addon.Addon = lambda _: self.addon
        gui = types.ModuleType('xbmcgui')
        self.covered = True
        self.state = types.SimpleNamespace(covered=lambda: self.covered)
        self.transition = types.SimpleNamespace(COMPLETED='skin_unified_v2', run=Mock(return_value=True))
        self.defaults = types.SimpleNamespace(first_setup=Mock(return_value=True))
        skin = types.ModuleType('wcs.skin')
        skin.installer = types.SimpleNamespace(SKIN_ID='skin.milionar')
        skin.transition, skin.defaults = self.transition, self.defaults
        onboarding = types.ModuleType('wcs.onboarding')
        onboarding.state = self.state
        modules = {'xbmc': self.xbmc, 'xbmcaddon': addon, 'xbmcgui': gui, 'wcs.skin': skin,
                   'wcs.skin.installer': skin.installer, 'wcs.skin.transition': self.transition,
                   'wcs.skin.defaults': self.defaults, 'wcs.onboarding': onboarding,
                   'wcs.onboarding.state': self.state}
        self.launch = _load('launch_under_test', 'wcs/onboarding/launch.py', modules)
        started = patch.dict(sys.modules, modules)
        started.start()
        self.addCleanup(started.stop)

    def test_missing_defaults_load_the_skin_once_more(self):
        self.assertTrue(self.launch.prepare_skin())
        self.defaults.first_setup.assert_called_once()
        self.xbmc.executebuiltin.assert_called_once_with('ReloadSkin()', True)

    def test_nothing_missing_no_extra_load(self):
        self.defaults.first_setup.return_value = False
        self.assertTrue(self.launch.prepare_skin())
        self.xbmc.executebuiltin.assert_not_called()

    def test_without_the_cover_the_skin_keeps_its_own_onload(self):
        self.covered = False
        self.assertTrue(self.launch.prepare_skin())
        self.defaults.first_setup.assert_not_called()


if __name__ == '__main__':
    unittest.main()
