"""Per-addon manual updates: use Kodi's existing rules, retain all other data."""
from contextlib import closing
import importlib.util
import os
from pathlib import Path
import sqlite3
import sys
import tempfile
import types
import unittest
from unittest.mock import Mock, patch

ROOT = Path(__file__).resolve().parents[2]


class PolicyTests(unittest.TestCase):
    def setUp(self):
        self.folder = tempfile.TemporaryDirectory()
        self.addCleanup(self.folder.cleanup)
        self.path = os.path.join(self.folder.name, 'Addons33.db')
        with closing(sqlite3.connect(self.path)) as database:
            database.executescript('CREATE TABLE update_rules(id INTEGER PRIMARY KEY, addonID TEXT, updateRule INTEGER);'
                                  'CREATE UNIQUE INDEX rules ON update_rules(addonID, updateRule);'
                                  "INSERT INTO update_rules(addonID, updateRule) VALUES ('other.addon', 2);")
        self.xbmc = types.SimpleNamespace(executebuiltin=Mock(), log=Mock(), LOGERROR=3)
        modules = {'xbmc': self.xbmc, 'xbmcvfs': types.SimpleNamespace(translatePath=lambda _: self.folder.name)}
        with patch.dict(sys.modules, modules):
            spec = importlib.util.spec_from_file_location('policy_tested', ROOT/'wcs/update_policy.py')
            self.policy = importlib.util.module_from_spec(spec)
            spec.loader.exec_module(self.policy)

    def rows(self):
        with closing(sqlite3.connect(self.path)) as database:
            return database.execute('SELECT addonID, updateRule FROM update_rules ORDER BY addonID').fetchall()

    def test_manual_rule_preserves_foreign_addons_and_refreshes_native_cache(self):
        self.assertTrue(self.policy.enforce())
        self.assertEqual(self.rows(), [('other.addon', 2), ('plugin.video.milionar', 1), ('skin.milionar', 1)])
        self.xbmc.executebuiltin.assert_called_once_with('UpdateLocalAddons', True)

    def test_idempotent_and_keeps_other_rules_on_our_addon(self):
        with closing(sqlite3.connect(self.path)) as database:
            database.execute("INSERT INTO update_rules(addonID, updateRule) VALUES ('plugin.video.milionar', 3)")
            database.commit()
        self.assertTrue(self.policy.enforce()); self.assertTrue(self.policy.enforce())
        self.assertIn(('plugin.video.milionar', 3), self.rows())
        self.assertEqual(self.xbmc.executebuiltin.call_count, 1)

    def test_missing_database_is_not_created(self):
        os.unlink(self.path)
        self.assertFalse(self.policy.enforce())
        self.assertFalse(os.path.exists(self.path)); self.xbmc.executebuiltin.assert_not_called()

    def test_unknown_schema_fails_without_modifying_it(self):
        with closing(sqlite3.connect(self.path)) as database:
            database.execute('ALTER TABLE update_rules RENAME TO original_rules')
            database.commit()
        self.assertFalse(self.policy.enforce()); self.xbmc.executebuiltin.assert_not_called()
        with closing(sqlite3.connect(self.path)) as database:
            self.assertEqual(database.execute('SELECT count(*) FROM original_rules').fetchone()[0], 1)


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