"""Beta publication (docs/plan/skin-milionar/340-beta-channel.md): never the stable repository or dev/, its own index,
its own changelog entry and a library the stable version can read.

Run: python3 scripts/skin_harness/test_release_beta.py
"""
import importlib.util
from io import BytesIO
import os
from pathlib import Path
import shutil
import sys
import tempfile
import unittest
from unittest.mock import patch
import xml.etree.ElementTree as ET
import zipfile

ROOT = Path(__file__).resolve().parents[2]
spec = importlib.util.spec_from_file_location('release_beta', ROOT / 'scripts/release.py')
release = importlib.util.module_from_spec(spec)
spec.loader.exec_module(release)
PLUGIN = '<addon id="plugin.video.milionar" version="{}"><extension point="xbmc.addon.metadata"></extension></addon>'
SKIN = '<addon id="skin.milionar" version="1.3.117"><requires><import addon="plugin.video.milionar" version="2.3.5"/></requires></addon>'


class BetaReleaseTests(unittest.TestCase):
    def setUp(self):
        folder = tempfile.TemporaryDirectory()
        self.addCleanup(folder.cleanup)
        self.root = Path(folder.name)
        patcher = patch.object(release, 'ROOT', folder.name)
        patcher.start()
        self.addCleanup(patcher.stop)

    def workspace(self, changelog='[B]beta[/B]\n• Season cards.\n\n[B]2.3.5[/B]\n• Beta channel.\n'):
        (self.root / 'resources/skin.milionar').mkdir(parents=True)
        (self.root / 'resources/skin-modules').mkdir()
        (self.root / 'scripts/skin_harness').mkdir(parents=True)
        shutil.copy(ROOT / 'scripts/skin_harness/deploy_check.py', self.root / 'scripts/skin_harness/deploy_check.py')
        (self.root / 'addon.xml').write_text(PLUGIN.format('2.3.5'))
        (self.root / 'changelog.txt').write_text(changelog)
        (self.root / 'resources/skin.milionar/addon.xml').write_text(SKIN)
        (self.root / 'resources/skin.milionar/changelog.txt').write_text('[B]1.3.117[/B]\n• Skin.\n')
        guard = release._module('guard_for_state', str(self.root / 'scripts/skin_harness/deploy_check.py'))
        guard.main.__globals__['sys'].argv = ['deploy_check.py', 'record']
        guard.main()                                      # the stable release recorded this skin

    def prepare(self, beta=True):
        with patch.object(release, 'ensure_new_version', return_value='2.3.6'), \
                patch.object(release.time, 'strftime', return_value='20261116190000'), \
                patch.object(release, 'write_strings_stamp'), patch.object(release, 'scan_secrets'), \
                patch.object(release, 'dev_files', return_value=[]):
            release.prepare(beta=beta)

    def skin(self):
        return ET.parse(self.root / 'resources/skin.milionar/addon.xml').getroot()

    def test_beta_dispatch_never_publishes_stable_index_sources_or_records(self):
        stage = self.root / 'stage'
        with patch.object(sys, 'argv', ['release.py', 'publish', '--beta']), \
                patch.object(release.tempfile, 'mkdtemp', return_value=str(stage)), \
                patch.object(release, 'dev_files', return_value=[]), \
                patch.object(release, 'prepare') as prepare, patch.object(release, 'check_beta_data') as data, \
                patch.object(release, 'build', return_value='2.3.6~beta1'), \
                patch.object(release, 'publish_beta', return_value=['old/beta/x.zip']) as beta, \
                patch.object(release, 'report') as report, patch.object(release, 'publish') as stable, \
                patch.object(release, 'publish_dev') as sources, patch.object(release, 'prune') as prune, \
                patch.object(release, 'run') as run, patch.object(release, 'remote'):
            release.main()
        prepare.assert_called_once_with(snapshot=False, bump=True, beta=True)
        data.assert_called_once_with()
        beta.assert_called_once_with(str(stage), '2.3.6~beta1')
        report.assert_called_once_with(str(stage), '2.3.6~beta1', 'beta', ['old/beta/x.zip'])
        for call in (stable, sources, prune, run):
            call.assert_not_called()

    def test_beta_dry_run_uploads_nothing(self):
        with patch.object(sys, 'argv', ['release.py', 'publish', '--beta', '--dry-run']), \
                patch.object(release.tempfile, 'mkdtemp', return_value=str(self.root / 'stage')), \
                patch.object(release, 'dev_files', return_value=[]), patch.object(release, 'prepare'), \
                patch.object(release, 'check_beta_data'), patch.object(release, 'build', return_value='2.3.6~beta1'), \
                patch.object(release, 'publish_beta') as beta, patch.object(release, 'report'), \
                patch.object(release, 'remote') as remote:
            release.main()
        beta.assert_not_called()
        remote.assert_not_called()

    def test_beta_versions_its_plugin_skin_dependency_and_changelog_in_the_candidate(self):
        self.workspace()
        (self.root / 'resources/skin.milionar/Home.xml').write_text('<window/>')     # the skin changed
        self.prepare()
        version = '2.3.6~beta20261116190000'
        self.assertEqual(ET.parse(self.root / 'addon.xml').getroot().get('version'), version)
        self.assertEqual(self.skin().get('version'), '1.3.118~beta20261116190000')
        self.assertEqual(self.skin().find('requires/import').get('version'), version)
        self.assertTrue((self.root / 'changelog.txt').read_text().startswith('[B]{}[/B]\n• Season cards.'.format(version)))
        self.assertIn('<news>Season cards.</news>', (self.root / 'addon.xml').read_text())

    def test_an_unchanged_skin_keeps_its_version(self):
        self.workspace()
        self.prepare()
        self.assertEqual((self.skin().get('version'), self.skin().find('requires/import').get('version')), ('1.3.117', '2.3.5'))

    def test_a_beta_needs_its_changelog_entry(self):
        self.workspace(changelog='[B]2.3.5[/B]\n• Beta channel.\n')
        with self.assertRaises(SystemExit):
            self.prepare()

    def test_a_stable_release_never_ships_a_beta_entry(self):
        self.workspace()
        with self.assertRaises(SystemExit):
            self.prepare(beta=False)

    def stable_zip(self, readable):
        path = self.root / 'stable.zip'
        with zipfile.ZipFile(path, 'w') as archive:
            archive.writestr('plugin.video.milionar/wcs/library2/store.py', 'def readable(path):\n    return {}\n'.format(readable))
        return path

    def check_data(self, readable):
        (self.root / 'wcs/library2').mkdir(parents=True)
        shutil.copy(ROOT / 'wcs/library2/store.py', self.root / 'wcs/library2/store.py')
        index = b'<addons><addon id="plugin.video.milionar" version="2.3.5"/></addons>'
        package = self.stable_zip(readable)
        with patch.object(release.urllib.request, 'urlopen', return_value=BytesIO(index)), \
                patch.object(release.urllib.request, 'urlretrieve',
                             side_effect=lambda url, target: shutil.copy(package, target)) as fetched:
            release.check_beta_data()
        self.assertEqual(fetched.call_args.args[0], release.PUBLIC + '/repo/plugin.video.milionar/plugin.video.milionar-2.3.5.zip')

    def test_a_library_the_stable_version_reads_passes(self):
        self.check_data(True)

    def test_a_library_the_stable_version_cannot_read_stops_the_beta(self):
        with self.assertRaises(SystemExit):
            self.check_data(False)

    def test_beta_goes_to_its_own_series_index_last_and_replaced_betas_to_old(self):
        name = 'plugin.video.milionar-2.3.6~beta2.zip'
        with zipfile.ZipFile(self.root / name, 'w') as archive:
            archive.writestr('plugin.video.milionar/addon.xml', PLUGIN.format('2.3.6~beta2'))
        commands, uploads = [], []
        hashes = {}

        def run(*command, **kwargs):
            uploads.append(command[-1])
            hashes[command[-1].split(':', 1)[1]] = release.sha256(command[-2])

        def remote(command):
            commands.append(command)
            if 'sha256sum' in command:
                return hashes[command.rsplit(' ', 1)[1]] + ' file'
            if command.endswith('&& ls -1'):
                return 'plugin.video.milionar\nplugin.video.milionar-2.3.4~beta1.zip\n' if command.endswith('beta && ls -1') \
                    else name + '\nplugin.video.milionar-2.3.6~beta1.zip\n'
            return ''

        def urlopen(url, timeout):
            source = self.root / name if url.endswith('.zip') else self.root / 'beta-addons.xml'
            return BytesIO(source.read_bytes())
        with patch.object(release, 'remote', side_effect=remote), patch.object(release, 'run', side_effect=run), \
                patch.object(release.urllib.request, 'urlopen', side_effect=urlopen):
            moved = release.publish_beta(str(self.root), '2.3.6~beta2')
        index = ET.parse(self.root / 'beta-addons.xml').getroot()
        self.assertEqual([node.get('version') for node in index.iter('addon')], ['2.3.6~beta2'])
        switch = [cmd for cmd in commands if 'mv -f' in cmd][0]
        self.assertLess(switch.index('beta/plugin.video.milionar/' + name), switch.index('beta/addons.xml'))
        self.assertEqual(moved, ['old/beta/plugin.video.milionar-2.3.4~beta1.zip', 'old/beta/plugin.video.milionar-2.3.6~beta1.zip'])
        self.assertTrue(all('/beta/.upload-' in upload for upload in uploads))
        self.assertFalse(any('repo/' in cmd or 'latest' in cmd or 'dev/' in cmd or 'rm -rf' in cmd and '.upload-' not in cmd
                             for cmd in commands))


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