#!/usr/bin/env python3
"""Offline checks of reloading Kodi's copy of the addon's texts after an update (wcs/skin/texts.py,
docs/plan/skin-milionar/251-texts-after-update.md).

Run: python3 scripts/skin_harness/test_texts.py
"""
import importlib
import json
import os
import re
import shutil
import sys
import tempfile
import types
import unittest
from unittest.mock import Mock

ROOT = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..'))
sys.path.insert(0, ROOT)
sys.path.insert(0, os.path.join(ROOT, 'scripts'))
import strings_stamp  # noqa: E402

LANGUAGES = ('resource.language.cs_cz', 'resource.language.sk_sk', 'resource.language.en_gb')
# addon.xml's context menu: Kodi resolves these labels when the addon is enabled, before the new service can reload
# the texts, so they must read the same in every version (251 §4)
CONTEXT_LABELS = {
    'resource.language.en_gb': {32250: 'Milionář', 32251: 'Search sources', 32252: 'Milionář game',
                                32253: 'Similar titles', 32254: 'Add to MyTV / MyCinema'},
    'resource.language.cs_cz': {32250: 'Milionář', 32251: 'Hledat zdroje', 32252: 'Hra Milionář',
                                32253: 'Podobné tituly', 32254: 'Přidat do MyTV / MyCinema'},
    'resource.language.sk_sk': {32250: 'Milionář', 32251: 'Hľadať zdroje', 32252: 'Hra Milionář',
                                32253: 'Podobné tituly', 32254: 'Pridať do MyTV / MyCinema'},
}

def _po(path):
    with open(path, encoding='utf-8') as handle:
        text = handle.read()
    return {int(i): (m, s) for i, m, s in re.findall(r'msgctxt "#(\d+)"\nmsgid "(.*)"\nmsgstr "(.*)"', text)}


class FakeKodi:
    """Kodi's thread: builtins run in order; SetGUILanguage changes the language and reloads the texts."""

    def __init__(self, folder, language='resource.language.cs_cz'):
        self.folder, self.language = folder, language
        self.props, self.builtins, self.rpcs = {}, [], []
        self.kodi_stamp = 'texts-old'
        self.disk = 'texts-new'
        self.window, self.dialog, self.video = 10000, 9999, False
        self.languages = [{'addonid': 'resource.language.en_gb'}, {'addonid': 'resource.language.cs_cz'}]
        self.switch_ok = True

    def builtin(self, command):
        self.builtins.append(command)
        match = re.match(r'SetGUILanguage\((.*)\)$', command)
        if match and self.switch_ok:
            if match.group(1) != self.language:
                self.language = match.group(1)
                self.kodi_stamp = self.disk
        match = re.match(r'SetProperty\(([^,]*),([^,]*),home\)$', command)
        if match:
            self.props[match.group(1)] = match.group(2)

    def rpc(self, raw):
        request = json.loads(raw)
        self.rpcs.append(request['method'])
        if request['method'] == 'Settings.GetSettingValue':
            return json.dumps({'result': {'value': self.language}})
        if request['method'] == 'Addons.GetAddons':
            return json.dumps({'result': {'addons': self.languages}})
        return json.dumps({'result': 'OK'})


class TextsTests(unittest.TestCase):
    def setUp(self):
        self.tmp = tempfile.mkdtemp()
        self.addCleanup(shutil.rmtree, self.tmp)
        self.addon_path = os.path.join(self.tmp, 'addons', 'plugin.video.milionar')
        self.profile = os.path.join(self.tmp, 'addon_data', 'plugin.video.milionar')
        en = os.path.join(self.addon_path, 'resources', 'language', 'resource.language.en_gb')
        os.makedirs(en)
        self.kodi = kodi = FakeKodi(self.tmp)
        self._write_po('texts-new')
        home = Mock()
        home.getProperty.side_effect = lambda key: kodi.props.get(key, '')
        home.setProperty.side_effect = lambda key, value: kodi.props.__setitem__(key, value)
        home.clearProperty.side_effect = lambda key: kodi.props.pop(key, None)
        xbmc = types.ModuleType('xbmc')
        xbmc.LOGINFO, xbmc.LOGWARNING, xbmc.LOGERROR = 1, 2, 3
        xbmc.log = Mock()
        xbmc.executebuiltin = Mock(side_effect=kodi.builtin)
        xbmc.executeJSONRPC = Mock(side_effect=kodi.rpc)
        xbmc.getCondVisibility = Mock(side_effect=lambda c: kodi.video if c == 'Player.HasVideo' else False)
        addon = Mock()
        addon.getAddonInfo.side_effect = lambda key: self.addon_path if key == 'path' else ''
        addon.getLocalizedString.side_effect = lambda i: kodi.kodi_stamp if i == 39999 else ''
        xbmcaddon = types.ModuleType('xbmcaddon')
        xbmcaddon.Addon = Mock(return_value=addon)
        xbmcgui = types.ModuleType('xbmcgui')
        xbmcgui.Window = Mock(return_value=home)
        xbmcgui.getCurrentWindowId = Mock(side_effect=lambda: kodi.window)
        xbmcgui.getCurrentWindowDialogId = Mock(side_effect=lambda: kodi.dialog)
        xbmcvfs = types.ModuleType('xbmcvfs')
        xbmcvfs.translatePath = lambda path: (self.profile + '/' if path.startswith('special://profile/') else path)
        self.saved = {name: sys.modules.get(name) for name in ('xbmc', 'xbmcaddon', 'xbmcgui', 'xbmcvfs')}
        sys.modules.update(xbmc=xbmc, xbmcaddon=xbmcaddon, xbmcgui=xbmcgui, xbmcvfs=xbmcvfs)
        self.addCleanup(self._restore)
        sys.modules.pop('wcs.skin.texts', None)
        self.texts = importlib.import_module('wcs.skin.texts')
        self.monitor = Mock()
        self.monitor.waitForAbort.return_value = False

    def _restore(self):
        for name, module in self.saved.items():
            if module is None:
                sys.modules.pop(name, None)
            else:
                sys.modules[name] = module
        sys.modules.pop('wcs.skin.texts', None)

    def _write_po(self, stamp):
        path = os.path.join(self.addon_path, 'resources', 'language', 'resource.language.en_gb', 'strings.po')
        with open(path, 'w', encoding='utf-8') as handle:
            handle.write('# XBMC Media Center language file\n\nmsgid ""\nmsgstr ""\n\n'
                         '"Content-Type: text/plain; charset=UTF-8\\n"\n"Language: en\\n"\n\n'
                         + ('msgctxt "#39999"\nmsgid "{}"\nmsgstr ""\n\n'.format(stamp) if stamp else '')
                         + 'msgctxt "#30011"\nmsgid "Category"\nmsgstr ""\n')
        self.kodi.disk = stamp

    # --- the stamp of the workspace ---
    def test_workspace_stamp_is_current_and_first(self):
        self.assertEqual(strings_stamp.current(), strings_stamp.compute(),
                         'run python3 scripts/strings_stamp.py (release.py does it too)')
        with open(strings_stamp.EN, 'rb') as handle:
            head = handle.read(self.texts.HEAD_BYTES).decode('utf-8', 'replace')
        self.assertIn('msgid "{}"'.format(strings_stamp.current()), head)
        self.assertEqual(self.texts.STAMP_ID, strings_stamp.STAMP_ID)

    def test_stamp_changes_with_any_text_and_write_is_idempotent(self):
        root = os.path.join(self.tmp, 'ws')
        shutil.copytree(os.path.join(ROOT, 'resources', 'language'), os.path.join(root, 'resources', 'language'))
        first = strings_stamp.write(root)
        self.assertEqual(strings_stamp.write(root), first)
        cs = os.path.join(root, 'resources', 'language', 'resource.language.cs_cz', 'strings.po')
        with open(cs, 'a', encoding='utf-8') as handle:
            handle.write('\nmsgctxt "#36999"\nmsgid "New"\nmsgstr "Nové"\n')
        self.assertNotEqual(strings_stamp.compute(root), first)
        self.assertEqual(strings_stamp.write(root), strings_stamp.compute(root))

    def test_release_writes_the_stamp(self):
        import release
        root = os.path.join(self.tmp, 'rel')
        shutil.copytree(os.path.join(ROOT, 'resources', 'language'), os.path.join(root, 'resources', 'language'))
        cs = os.path.join(root, 'resources', 'language', 'resource.language.cs_cz', 'strings.po')
        with open(cs, 'a', encoding='utf-8') as handle:
            handle.write('\nmsgctxt "#36999"\nmsgid "New"\nmsgstr "Nové"\n')
        saved, release.ROOT = release.ROOT, root
        try:
            stamp = release.write_strings_stamp()
        finally:
            release.ROOT = saved
        self.assertEqual(stamp, strings_stamp.compute(root))
        self.assertEqual(strings_stamp.current(root), stamp)
        self.assertNotEqual(stamp, strings_stamp.current())

    def test_context_menu_labels_never_change(self):
        for language, labels in CONTEXT_LABELS.items():
            strings = _po(os.path.join(ROOT, 'resources', 'language', language, 'strings.po'))
            for string_id, text in labels.items():
                msgid, msgstr = strings[string_id]
                self.assertEqual(msgstr or msgid, text, '{} #{}'.format(language, string_id))
        with open(os.path.join(ROOT, 'addon.xml'), encoding='utf-8') as handle:
            used = {int(i) for i in re.findall(r'<label>(\d+)</label>', handle.read())}
        self.assertEqual(used, set(CONTEXT_LABELS['resource.language.en_gb']))

    # --- when ---
    def test_due_only_when_kodi_holds_another_stamp(self):
        self.assertTrue(self.texts.due())
        self.kodi.kodi_stamp = 'texts-new'
        self.assertFalse(self.texts.due())

    def test_old_version_without_stamp_in_kodi_is_due(self):
        self.kodi.kodi_stamp = ''
        self.assertTrue(self.texts.due())

    def test_files_without_stamp_never_reload(self):
        self._write_po('')
        self.kodi.kodi_stamp = ''
        self.assertFalse(self.texts.due())

    def test_never_twice_in_one_session(self):
        self.kodi.props[self.texts.TRIED] = 'texts-new'
        self.assertFalse(self.texts.due())

    # --- how ---
    def test_refresh_switches_both_at_once_then_marks(self):
        self.assertTrue(self.texts.refresh(self.monitor))
        commands = self.kodi.builtins
        self.assertEqual(commands[:2], ['SetGUILanguage(resource.language.en_gb)',
                                        'SetGUILanguage(resource.language.cs_cz)'])
        self.assertEqual([c for c in commands[2:]], ['SetProperty(milionar.texts.mark,{},home)'.format(n)
                                                     for n in (1, 2, 3)])
        self.assertEqual(self.kodi.language, 'resource.language.cs_cz')
        self.assertEqual(self.kodi.kodi_stamp, 'texts-new')
        self.assertFalse(os.path.exists(os.path.join(self.profile, self.texts.JOURNAL)))
        self.assertEqual(self.kodi.props.get(self.texts.TRIED), 'texts-new')
        self.assertNotIn(self.texts.MARK, self.kodi.props)

    def test_english_user_goes_through_another_language(self):
        self.kodi.language = 'resource.language.en_gb'
        self.assertTrue(self.texts.refresh(self.monitor))
        self.assertEqual(self.kodi.builtins[:2], ['SetGUILanguage(resource.language.cs_cz)',
                                                  'SetGUILanguage(resource.language.en_gb)'])
        self.assertEqual(self.kodi.language, 'resource.language.en_gb')

    def test_english_only_kodi_leaves_texts(self):
        self.kodi.language = 'resource.language.en_gb'
        self.kodi.languages = [{'addonid': 'resource.language.en_gb'}]
        self.assertTrue(self.texts.refresh(self.monitor))
        self.assertEqual(self.kodi.builtins[0], 'SetGUILanguage(resource.language.milionar_reload)')
        self.assertEqual(self.kodi.language, 'resource.language.en_gb')

    def test_language_left_elsewhere_comes_back(self):
        original = self.kodi.builtin

        def lose_second(command):                       # Kodi did the first switch only
            if command == 'SetGUILanguage(resource.language.cs_cz)' and not getattr(self, 'lost', False):
                self.lost = True
                self.kodi.builtins.append(command)
                return
            original(command)
        sys.modules['xbmc'].executebuiltin.side_effect = lose_second
        self.texts.refresh(self.monitor)
        self.assertEqual(self.kodi.language, 'resource.language.cs_cz')
        self.assertEqual(self.kodi.builtins.count('SetGUILanguage(resource.language.cs_cz)'), 2)

    def test_waits_for_a_quiet_moment(self):
        states = iter([(13001, 9999, False), (10000, 10100, False), (10000, 9999, True), (10000, 1124, False),
                       (10000, 11124, False), (10000, 11124, False)])

        def step(seconds):
            if self.kodi.builtins:
                return False
            try:
                self.kodi.window, self.kodi.dialog, self.kodi.video = next(states)
            except StopIteration:
                pass
            return False
        self.kodi.window, self.kodi.dialog = 13001, 9999       # a Python window: never during it
        self.monitor.waitForAbort.side_effect = step
        self.assertTrue(self.texts.refresh(self.monitor))
        self.assertEqual((self.kodi.window, self.kodi.dialog), (10000, 11124))   # measured on the TV: 1124 is 11124

    def test_kodi_stopping_while_waiting_does_nothing(self):
        self.kodi.dialog = 10100
        self.monitor.waitForAbort.return_value = True
        self.assertFalse(self.texts.refresh(self.monitor))
        self.assertEqual(self.kodi.builtins, [])

    def test_cec_adapter_following_the_tv_is_left_alone(self):
        folder = os.path.join(self.tmp, 'peripheral_data')
        os.makedirs(folder)
        sys.modules['xbmcvfs'].translatePath = lambda path: (
            folder + '/' if path.startswith('special://profile/peripheral_data') else
            self.profile + '/' if path.startswith('special://profile/') else path)
        cec = os.path.join(folder, 'cec_CEC_Adapter.xml')
        with open(cec, 'w') as handle:
            handle.write('<settings>\n    <setting id="use_tv_menu_language" value="1" />\n</settings>\n')
        self.assertFalse(self.texts.refresh(self.monitor))
        self.assertEqual(self.kodi.builtins, [])
        with open(cec, 'w') as handle:
            handle.write('<settings>\n    <setting id="use_tv_menu_language" value="0" />\n</settings>\n')
        self.assertTrue(self.texts.refresh(self.monitor))

    def test_journal_brings_the_language_back_at_start(self):
        os.makedirs(self.profile)
        with open(os.path.join(self.profile, self.texts.JOURNAL), 'w') as handle:
            json.dump({'language': 'resource.language.sk_sk'}, handle)
        self.texts.recover_language()
        self.assertEqual(self.kodi.builtins, ['SetGUILanguage(resource.language.sk_sk)'])
        self.assertFalse(os.path.exists(os.path.join(self.profile, self.texts.JOURNAL)))
        self.kodi.builtins.clear()
        self.texts.recover_language()
        self.assertEqual(self.kodi.builtins, [])

    def test_reloading_marks_until_texts_are_current(self):
        xbmc = sys.modules['xbmc']
        xbmc.getInfoLabel = Mock(side_effect=lambda label: self.kodi.props.get(
            label[len('Window(Home).Property('):-1], '') if label.startswith('Window(Home).Property(') else '')
        self.assertTrue(self.texts.due())
        self.assertTrue(self.texts.reloading())
        seen = []
        original = self.kodi.builtin

        def watch(command):
            original(command)
            if command.startswith('SetProperty(milionar.texts.mark,'):
                seen.append((command[-7], self.kodi.props.get(self.texts.RELOADING, ''),
                             self.kodi.props.get(self.texts.PUBLISHED, '')))
        xbmc.executebuiltin.side_effect = watch
        self.assertTrue(self.texts.refresh(self.monitor))
        # mark 1 and 2 queued while still reloading; after mark 2 the stamp is published and the mark is gone
        self.assertEqual([state for _, state, _ in seen], ['1', '1', ''])
        self.assertEqual(seen[2][2], 'texts-new')
        self.assertFalse(self.texts.reloading())

    def test_reloading_cleared_when_refresh_cannot_run(self):
        self.texts.due()
        self.kodi.dialog = 10100
        self.monitor.waitForAbort.return_value = True
        self.texts.refresh(self.monitor)
        self.assertNotIn(self.texts.RELOADING, self.kodi.props)

    def test_publish_is_the_stamp_kodi_holds(self):
        self.texts.publish()
        self.assertEqual(self.kodi.props[self.texts.PUBLISHED], 'texts-old')

    def test_repair_once_per_current_texts(self):
        repairs = []
        self.assertFalse(self.texts.repair_once(lambda: repairs.append(1)))        # old texts: never
        self.kodi.kodi_stamp = 'texts-new'
        self.assertTrue(self.texts.repair_once(lambda: repairs.append(1)))
        self.assertFalse(self.texts.repair_once(lambda: repairs.append(1)))
        self._write_po('texts-newer')
        self.kodi.kodi_stamp = 'texts-newer'
        self.assertTrue(self.texts.repair_once(lambda: repairs.append(1)))
        self.assertEqual(repairs, [1, 1])

    def test_failure_never_raises(self):
        sys.modules['xbmc'].executeJSONRPC.side_effect = RuntimeError('rpc')
        self.assertFalse(self.texts.refresh(self.monitor))
        sys.modules['xbmcaddon'].Addon.side_effect = RuntimeError('addon')
        self.assertFalse(self.texts.due())


class ServiceOrderTests(unittest.TestCase):
    """service.start_skin_installer: texts first, the gate open only after them, the owed skin load if they failed."""

    def run_install(self, due, refreshed, owed):
        calls = []
        texts = types.SimpleNamespace(due=lambda: calls.append('due') or due,
                                      refresh=lambda monitor: calls.append('refresh') or refreshed,
                                      repair_once=lambda fn: calls.append('repair'))
        journal = types.SimpleNamespace(request_all=lambda: calls.append('rows'))
        family = types.SimpleNamespace(active=lambda: True)
        slots = types.SimpleNamespace(repair_titles=lambda: None)
        installer = types.SimpleNamespace(run=lambda **kw: calls.append(('run', kw)) or owed)
        home = Mock()
        home.clearProperty.side_effect = lambda key: calls.append(('clear', key))
        xbmc = types.ModuleType('xbmc')
        xbmc.LOGERROR = 3
        xbmc.log = Mock()
        xbmc.executebuiltin = Mock(side_effect=lambda c: calls.append(c))
        xbmcgui = types.ModuleType('xbmcgui')
        xbmcgui.Window = Mock(return_value=home)
        update = types.SimpleNamespace(is_workspace=lambda addon: True, resume=lambda: calls.append('resume'),
                                       tidy=lambda: None)
        xbmcaddon = types.ModuleType('xbmcaddon')
        xbmcaddon.Addon = Mock()
        threads = []
        threading = types.SimpleNamespace(Thread=lambda target, name, daemon: types.SimpleNamespace(
            start=lambda: threads.append(target)))
        modules = {'xbmc': xbmc, 'xbmcgui': xbmcgui, 'xbmcaddon': xbmcaddon, 'threading': threading,
                   'wcs.skin.texts': texts, 'wcs.skin.installer': installer, 'wcs.skin.update': update,
                   'wcs.skin.journal': journal, 'wcs.skin.family': family, 'wcs.skin.slots': slots,
                   'wcs.net': types.SimpleNamespace(install=lambda: None)}
        saved = {name: sys.modules.get(name) for name in modules}
        sys.modules.update(modules)
        package = sys.modules['wcs.skin']
        saved_attrs = {name: getattr(package, name, None) for name in ('texts', 'update', 'journal', 'family', 'slots')}
        package.texts, package.update, package.journal, package.family, package.slots = (
            texts, update, journal, family, slots)
        try:
            spec = importlib.util.spec_from_file_location('milionar_service', os.path.join(ROOT, 'service.py'))
            service = importlib.util.module_from_spec(spec)
            spec.loader.exec_module(service)
            monitor = Mock()
            monitor.abortRequested.return_value = False
            service.start_skin_installer(monitor)
            threads[0]()
        finally:
            for name, module in saved.items():
                if module is None:
                    sys.modules.pop(name, None)
                else:
                    sys.modules[name] = module
            for name, value in saved_attrs.items():
                if value is None:
                    if hasattr(package, name):
                        delattr(package, name)
                else:
                    setattr(package, name, value)
        return calls

    def setUp(self):
        import wcs.skin                                     # noqa: F401  (the package, for the stand-in modules)

    def test_no_texts_due_is_as_before(self):
        calls = self.run_install(False, False, False)
        self.assertEqual(calls[:2], ['due', ('run', {'reload': True, 'release': True})])
        self.assertNotIn('refresh', calls)
        self.assertLess(calls.index(('clear', 'milionar.skin.installing')), calls.index('resume'))

    def test_texts_reload_before_the_gate_opens(self):
        calls = self.run_install(True, True, True)
        self.assertEqual(calls[:5], ['due', ('run', {'reload': False, 'release': False}), 'refresh', 'rows', 'repair'])
        self.assertNotIn('ReloadSkin()', calls)
        self.assertLess(calls.index('refresh'), calls.index(('clear', 'milionar.skin.installing')))
        self.assertLess(calls.index(('clear', 'milionar.skin.installing')), calls.index('resume'))

    def test_no_texts_due_still_repairs_once(self):
        self.assertIn('repair', self.run_install(False, False, False))

    def test_failed_text_reload_still_loads_a_new_skin(self):
        calls = self.run_install(True, False, True)
        self.assertNotIn('rows', calls)
        self.assertLess(calls.index('refresh'), calls.index('ReloadSkin()'))
        self.assertLess(calls.index('ReloadSkin()'), calls.index(('clear', 'milionar.skin.installing')))


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