"""Single-skin composition and the one-time forced transition, without Kodi or network."""
from collections import Counter
import importlib.util
from io import BytesIO
import json
from pathlib import Path
import re
import sys
import threading
import types
import unittest
from unittest.mock import Mock,patch
import xml.etree.ElementTree as ET
from PIL import Image

ROOT=Path(__file__).resolve().parents[2]
sys.path.insert(0,str(ROOT))
from wcs.skin import modular,compose


class Modules(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.plans={(menu,style):modular.plan(str(ROOT/'resources'),menu,style)
                   for menu in ('sidebar','horizontal') for style in ('normal','glass')}

    def xml(self,choice,path):return ET.fromstring(compose.read(self.plans[choice][path]))

    def test_exactly_one_bundled_skin_manifest(self):
        self.assertEqual([p.parent.name for p in (ROOT/'resources').glob('skin.*/addon.xml')],['skin.milionar'])
        for choice in self.plans:
            self.assertEqual(self.xml(choice,'addon.xml').get('id'),'skin.milionar')
            self.assertEqual(self.xml(choice,'addon.xml').get('name'),'Milionář')

    def test_all_combinations_parse(self):
        for choice,files in self.plans.items():
            for name,entry in files.items():
                if name.endswith('.xml'):
                    with self.subTest(choice=choice,name=name):ET.fromstring(compose.read(entry))

    def test_menu_axis_and_items_are_independent_of_style(self):
        contents=[]
        for choice in self.plans:
            menu=self.xml(choice,'xml/Home.xml').find(".//control[@id='9000']")
            self.assertEqual(menu.findtext('orientation')=='horizontal',choice[0]=='horizontal')
            contents.append(ET.canonicalize(ET.tostring(menu.find('content')),strip_text=True))
        self.assertEqual(len(set(contents)),1)

    def test_shared_cinematic_actions_ids_and_directories_are_preserved(self):
        for name in ('Includes_MilionarCinema.xml','Includes_MilionarDetail.xml','Includes_MilionarGenre.xml'):
            baseline=ET.parse(ROOT/'resources/skin.milionar/xml'/name).getroot()
            def contract(root):
                return ([n.text for n in root.iter('content')],Counter(n.get('id') for n in root.iter('control') if n.get('id')),
                        [(n.tag,n.text,n.get('condition')) for n in root.iter() if n.tag in ('onclick','oninfo','onback')])
            for choice in self.plans:self.assertEqual(contract(baseline),contract(self.xml(choice,'xml/'+name)))

    def test_background_does_not_change_with_material(self):
        for menu in ('sidebar','horizontal'):
            nodes=[self.xml((menu,style),'xml/Includes_Presentation.xml').find("include[@name='MilionarCinemaBackdrop']") for style in ('normal','glass')]
            self.assertEqual(ET.canonicalize(ET.tostring(nodes[0]),strip_text=True),ET.canonicalize(ET.tostring(nodes[1]),strip_text=True))

    def test_current_gold_is_not_replaced_or_recoloured(self):
        from wcs.skin.palette import PALETTE
        self.assertEqual(PALETTE[0][:2],('gold.xml','C49A45'))
        for choice in self.plans:
            root=self.xml(choice,'colors/gold.xml')
            self.assertEqual(root.findtext("color[@name='button_focus']"),'FFC49A45')

    def test_normal_native_button_padding_and_focus_accent(self):
        for menu in ('sidebar','horizontal'):
            files=self.plans[(menu,'normal')]
            with Image.open(BytesIO(compose.read(files['media/flat/dialog-focus.png']))) as im:
                self.assertEqual(im.getchannel('A').getbbox(),(20,20,60,60))
            root=self.xml((menu,'normal'),'xml/Includes_MilionarCinema.xml')
            for tex in root.iter('texture'):
                if tex.text=='milionar/cinema/focus.png':self.assertEqual(tex.get('colordiffuse'),'button_focus')

    def test_all_accent_themes_and_focus_frames_use_the_selected_colour(self):
        from wcs.skin.palette import PALETTE
        for choice in self.plans:
            for filename,colour,_label in PALETTE:
                root=self.xml(choice,'colors/'+filename)
                self.assertEqual(root.findtext("color[@name='button_focus']"),'FF'+colour)
                self.assertFalse({n.get('name') for n in root}&{'background','primary_background','dialog_tint'})
            for filename in ('Includes_MilionarCinema.xml','Includes_MilionarDetail.xml','Includes_MilionarGenre.xml'):
                for tex in self.xml(choice,'xml/'+filename).iter('texture'):
                    if tex.text=='milionar/cinema/focus.png':self.assertEqual(tex.get('colordiffuse'),'button_focus')

    def test_every_module_texture_exists_in_all_combinations(self):
        for choice,files in self.plans.items():
            named=set()
            for name,entry in files.items():
                if name.endswith('.xml'):
                    named.update(re.findall(r'(?:>|")((?:modern|flat|presentation|material|milionar/cinema)/[\w./-]+\.(?:png|jpg))(?:<|")',compose.read(entry).decode()))
            self.assertEqual(sorted(name for name in named if 'media/'+name not in files),[],choice)

    def test_accent_foreground_contrasts_with_every_theme(self):
        def luminance(color):
            rgb = [int(color[i:i+2], 16) / 255 for i in (2, 4, 6)]
            return sum((v / 12.92 if v <= .04045 else ((v + .055) / 1.055) ** 2.4) * w
                       for v, w in zip(rgb, (.2126, .7152, .0722)))
        for choice in self.plans:
            for name in self.plans[choice]:
                if not name.startswith('colors/'):
                    continue
                colors = {node.get('name'): node.text for node in self.xml(choice, name)}
                ink, fill = colors['flat_ink'], colors['button_focus']
                light, dark = sorted((luminance(ink), luminance(fill)), reverse=True)
                # The skin's large labels exceed the 3:1 large-text threshold with margin.
                self.assertGreaterEqual((light + .05) / (dark + .05), 4, (choice, name))
                self.assertEqual(colors['cinema_ink'], ink, (choice, name))
                self.assertGreaterEqual((luminance(colors['accent_text']) + .05) /
                                        (luminance('FF26354A') + .05), 4.5, (choice, name))

    def test_both_materials_share_focused_text_and_icons(self):
        for choice in self.plans:
            common = self.xml(choice, 'xml/Includes_Presentation.xml')
            self.assertEqual(common.findtext("variable[@name='FlatPlayInk']/value"), 'flat_ink')
            self.assertEqual(common.findtext("variable[@name='FlatNavText']/value"), 'flat_ink')
            material = self.xml(choice, 'xml/Includes_Material.xml')
            self.assertEqual(material.findall('variable'), [])
            defaults = self.xml(choice, 'xml/Defaults.xml')
            for kind in ('button', 'togglebutton', 'radiobutton', 'spincontrolex', 'sliderex', 'edit'):
                self.assertEqual(defaults.findtext("default[@type='%s']/focusedcolor" % kind), 'flat_ink')
            cinema = self.xml(choice, 'xml/Includes_MilionarCinema.xml')
            for control in cinema.iter('control'):
                if control.find('focusedcolor') is not None:
                    self.assertEqual(control.findtext('focusedcolor'), 'flat_ink')
            self.assertEqual(cinema.findtext(".//texture[@colordiffuse='$VAR[FlatPlayInk]']"), 'icons/now-playing/play.png')

    def test_every_material_border_fits_its_texture(self):
        for material in ('normal','glass'):
            folder=ROOT/'resources/skin-modules/materials'/material
            for old,rule in compose.recipe(str(folder))['textures'].items():
                if 'border' not in rule:continue
                with Image.open(folder/'media'/rule['to']) as im:width,height=im.size
                values=[int(v) for v in rule['border'].split(',')]
                left,top,right,bottom=values*4 if len(values)==1 else values
                self.assertLessEqual(left+right,width,(material,old))
                self.assertLessEqual(top+bottom,height,(material,old))

    def test_no_duplicate_settings_entry_or_system_skin_settings_shortcut(self):
        for choice in self.plans:
            root=self.xml(choice,'xml/Custom_1108_MilionarSettingsMenu.xml')
            labels=[n.text for n in root.iter('label')]
            self.assertEqual(labels.count('$ADDON[plugin.video.milionar 35615]'),1)
            self.assertNotIn('$LOCALIZE[31909]',labels)
            self.assertFalse(any('ActivateWindow(skinsettings)' in (n.text or '') for n in root.iter('onclick')))

    def test_appearance_dialog_and_preview_fit_tv(self):
        root=ET.parse(ROOT/'resources/skins/Default/1080i/skin/DialogMilionarAppearance.xml').getroot()
        self.assertEqual(len(root.findall(".//control[@id='50']")),1)
        for identifier in (51,52):self.assertEqual(len(root.findall(".//control[@id='{}']".format(identifier))),1)
        image=root.find(".//control[@id='60']")
        self.assertEqual(int(image.findtext('width'))*9,int(image.findtext('height'))*16)
        self.assertLessEqual(int(image.findtext('top'))+int(image.findtext('height')),936)

    def test_all_original_skin_preferences_remain_in_central_model(self):
        source=ET.parse(ROOT/'scripts/skin_harness/templates/appearance-settings.xml').getroot()
        model=ET.parse(ROOT/'resources/skin-modules/settings.xml').getroot()
        self.assertEqual(ET.canonicalize(ET.tostring(source),strip_text=True),ET.canonicalize(ET.tostring(model),strip_text=True))


class Transition(unittest.TestCase):
    def setUp(self):
        self.settings={modular.MENU:'horizontal',modular.MATERIAL:'normal'}
        self.addon=Mock();self.addon.getSetting.side_effect=lambda key:self.settings.get(key,'')
        self.addon.setSetting.side_effect=self.settings.__setitem__
        self.props={};self.home=Mock();self.home.getProperty.side_effect=lambda key:self.props.get(key,'')
        self.home.setProperty.side_effect=self.props.__setitem__;self.home.clearProperty.side_effect=lambda key:self.props.pop(key,None)
        self.skin='skin.milionar.flat'
        self.xbmc=types.ModuleType('xbmc');self.xbmc.getSkinDir=lambda:self.skin
        self.xbmc.getCondVisibility=lambda condition:condition=='Window.IsActive(home)'
        self.xbmc.executebuiltin=Mock();self.xbmc.LOGWARNING=2;self.xbmc.log=Mock();self.xbmc.Monitor=Mock()
        gui=types.ModuleType('xbmcgui');gui.Window=lambda _:self.home
        addon=types.ModuleType('xbmcaddon');addon.Addon=lambda _:self.addon
        family=types.SimpleNamespace(CLASSIC='skin.milionar',LEGACY=('skin.milionar.modern','skin.milionar.flat','skin.milionar.glass'))
        self.installer=types.SimpleNamespace(ADDON_ID='plugin.video.milionar',install=Mock(return_value={'ready':True}),switch=Mock(return_value=True),retire_legacy=Mock())
        self.accent=types.SimpleNamespace(_apply=Mock(return_value=True))
        import wcs.skin
        with patch.dict(sys.modules,{'xbmc':self.xbmc,'xbmcgui':gui,'xbmcaddon':addon}),patch.multiple(wcs.skin,family=family,installer=self.installer,appearance=self.accent,create=True):
            spec=importlib.util.spec_from_file_location('transition_under_test',ROOT/'wcs/skin/transition.py')
            self.mod=importlib.util.module_from_spec(spec);spec.loader.exec_module(self.mod)
        self.context=patch.multiple(wcs.skin,appearance=self.accent,create=True);self.context.start();self.addCleanup(self.context.stop)
        self.defaults=types.SimpleNamespace(first_setup=Mock())
        # run() imports at call time too (the guide's state, the skin defaults): Kodi's modules stay faked meanwhile
        modules={'wcs.skin.appearance':self.accent,'wcs.skin.defaults':self.defaults,'xbmc':self.xbmc,'xbmcgui':gui,'xbmcaddon':addon}
        imported=patch.dict(sys.modules,modules);imported.start();self.addCleanup(imported.stop)
        sys.modules.pop('wcs.onboarding.state',None)
        defaults=patch.object(wcs.skin,'defaults',self.defaults,create=True);defaults.start();self.addCleanup(defaults.stop)
        self.mod._confirm=Mock(return_value=True)

    def test_first_update_forces_exact_defaults_then_marks_complete(self):
        self.assertTrue(self.mod.run())
        self.assertEqual((self.settings[modular.MENU],self.settings[modular.MATERIAL]),('sidebar','glass'))
        self.accent._apply.assert_called_once_with('gold.xml')
        self.assertEqual(self.settings[self.mod.COMPLETED],'1')
        self.assertEqual(self.mod.COMPLETED,'skin_unified_v2')
        self.installer.retire_legacy.assert_called_once()
        self.assertNotIn('milionar.skin.choosing',self.props)
        self.assertFalse(any('skin_picker' in str(call) for call in self.xbmc.executebuiltin.call_args_list))

    def test_new_install_sets_all_skin_defaults_before_the_palette(self):
        self.props['milionar.onboarding']='1'                 # the guide is due: its cover is up (onboarding D2)
        self.props['milionar.onboarding.fresh']='1'           # a new install (onboarding D27)
        self.assertTrue(self.mod.run())
        self.defaults.first_setup.assert_called_once()

    def test_existing_user_getting_the_guide_gets_the_waiting_skin_defaults(self):
        # the guide is due for an existing install (D27): Home's <onload> defaults wait under the cover and Home does
        # not load again after the guide (Windows Kodi with addon 1.0: Home empty until a restart); first_setup writes
        # only what the skin lacks
        self.props['milionar.onboarding']='1'
        self.assertTrue(self.mod.run())
        self.defaults.first_setup.assert_called_once()

    def test_update_leaves_the_skin_defaults_to_the_skin(self):
        self.assertTrue(self.mod.run())
        self.defaults.first_setup.assert_not_called()

    def test_open_dialogs_close_before_home(self):
        self.assertTrue(self.mod.run())
        calls=[call.args[0] for call in self.xbmc.executebuiltin.call_args_list]
        self.assertLess(calls.index('Dialog.Close(all,true)'),calls.index('ActivateWindow(Home)'))

    def test_skin_just_installed_is_not_copied_again(self):
        self.settings[modular.MENU],self.settings[modular.MATERIAL]='sidebar','glass'
        self.settings[modular.APPLIED]=modular.key(self.addon)
        self.assertTrue(self.mod.run())
        self.assertFalse(self.installer.install.call_args.kwargs['force'])

    def test_later_updates_do_not_override_user_choices(self):
        self.settings[self.mod.COMPLETED]='1'
        self.assertTrue(self.mod.run())
        self.assertEqual((self.settings[modular.MENU],self.settings[modular.MATERIAL]),('horizontal','normal'))
        self.installer.install.assert_not_called();self.accent._apply.assert_not_called()

    def test_failed_install_does_not_complete_or_remove_old_skins(self):
        self.installer.install.return_value={'ready':False}
        self.assertFalse(self.mod.run())
        self.assertNotIn(self.mod.COMPLETED,self.settings);self.installer.retire_legacy.assert_not_called()

    def test_failed_confirmation_does_not_complete_or_remove_old_skins(self):
        self.mod._confirm.return_value=False
        self.assertFalse(self.mod.run())
        self.assertNotIn(self.mod.COMPLETED,self.settings);self.installer.retire_legacy.assert_not_called()

    def test_failed_accent_is_retryable(self):
        self.accent._apply.return_value=False
        self.assertFalse(self.mod.run());self.assertNotIn(self.mod.COMPLETED,self.settings)

    def test_completed_offer_is_a_noop(self):
        self.settings[self.mod.COMPLETED]='1'
        self.assertTrue(self.mod.offer_startup());self.installer.install.assert_not_called()

    def test_transition_also_starts_outside_home(self):
        self.mod._next_attempt=0
        self.xbmc.getCondVisibility=lambda _:False
        with patch.object(self.mod.threading,'Thread') as thread:
            self.assertFalse(self.mod.offer_startup())
            thread.return_value.start.assert_called_once_with()

    def test_offer_waits_only_for_installation(self):
        self.mod._next_attempt=0
        with patch.object(self.mod.threading,'Thread') as thread:
            for key in ('milionar.skin.installing','milionar.skin.choosing'):
                self.props[key]='1';self.assertFalse(self.mod.offer_startup());self.props.clear()
            thread.assert_not_called()

    def test_offer_does_not_wait_for_video_or_dialogs(self):
        self.mod._next_attempt=0
        self.xbmc.getCondVisibility=lambda _:True
        with patch.object(self.mod.threading,'Thread') as thread:
            self.mod.offer_startup()
            thread.return_value.start.assert_called_once_with()


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