# -*- coding: utf-8 -*-
"""CZ services, readable texts and the one cache (docs/plan/genre-browser/070, 080, 090 §Headless).

Run: python3 -m unittest scripts/library_harness/test_services.py -v   (from the addon folder)
"""
import os
import sys
import tempfile
import threading
import time
import unittest
from unittest import mock

HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
import stubs  # noqa: E402

stubs.install()

from wcs.foryou import api  # noqa: E402
from wcs.library2 import meta, store as library  # noqa: E402
from wcs.metadata import texts  # noqa: E402
from wcs.services import catalog, store  # noqa: E402

NETFLIX = {'provider_id': 8, 'provider_name': 'Netflix', 'logo_path': '/netflix.png'}
HBO = {'provider_id': 1899, 'provider_name': 'HBO Max', 'logo_path': '/hbo.png'}
APPLE_STORE = {'provider_id': 2, 'provider_name': 'Apple TV Store', 'logo_path': '/apple.png'}
FILMZIE = {'provider_id': 559, 'provider_name': 'Filmzie', 'logo_path': '/filmzie.png'}
LEPSI = {'provider_id': 1939, 'provider_name': 'Lepsi TV', 'logo_path': '/lepsi.png'}


def fresh_db():
    library.set_path(os.path.join(tempfile.mkdtemp(prefix='milionar-svc-'), 'library.db'))


class CatalogTest(unittest.TestCase):
    def test_classes(self):
        self.assertEqual(catalog.class_of(None), catalog.NONE)
        self.assertEqual(catalog.class_of({}), catalog.NONE)
        self.assertEqual(catalog.class_of(catalog.compact({'flatrate': [NETFLIX]})), catalog.BIG_CLASS)
        self.assertEqual(catalog.class_of(catalog.compact({'flatrate': [LEPSI]})), catalog.BIG_CLASS)
        self.assertEqual(catalog.class_of(catalog.compact({'rent': [APPLE_STORE]})), catalog.RENT_CLASS)
        self.assertEqual(catalog.class_of(catalog.compact({'flatrate': [FILMZIE]})), catalog.SMALL)
        # Netflix only for rent is no subscription: what counts is the kind
        self.assertEqual(catalog.class_of(catalog.compact({'buy': [NETFLIX]})), catalog.SMALL)

    def test_badges_order_and_rest(self):
        services = catalog.compact({'flatrate': [FILMZIE, HBO], 'rent': [APPLE_STORE], 'buy': [APPLE_STORE, NETFLIX]})
        names = [p[2] for p in catalog.providers(services)]
        self.assertEqual(names, ['Netflix', 'HBO Max', 'Apple TV Store', 'Filmzie'])     # big, rental, small
        logos, more = catalog.badges(services)
        self.assertEqual(logos, [catalog.LOGO_BASE + '/netflix.png', catalog.LOGO_BASE + '/hbo.png'])
        self.assertEqual(more, '+2')
        self.assertEqual(catalog.badges({}), ([], ''))

    def test_summary(self):
        services = catalog.compact({'flatrate': [HBO, LEPSI], 'rent': [APPLE_STORE], 'buy': [APPLE_STORE]})
        labels = {'subscription': 'Předplatné', 'rent': 'Půjčovna', 'buy': 'Koupě'}
        self.assertEqual(catalog.summary(services, labels),
                         'Předplatné: HBO Max, Lepsi TV · Půjčovna: Apple TV Store · Koupě: Apple TV Store')
        self.assertEqual(catalog.summary({}, labels), '')


class StoreTest(unittest.TestCase):
    def setUp(self):
        fresh_db()
        self.calls = []

        def fake(path, params):
            self.calls.append(path)
            if '/404/' in path:
                raise IOError('offline')
            return {'id': 1, 'results': {'CZ': {'flatrate': [NETFLIX]}, 'US': {'flatrate': [HBO]}}}
        patcher = mock.patch.object(api, 'FETCH', fake)
        patcher.start()
        self.addCleanup(patcher.stop)

    def test_fetch_lookup_and_never_twice(self):
        found, missing = store.lookup([('movie', 603), ('tv', 1)])
        self.assertEqual((found, sorted(missing)), ({}, ['svc:movie:603', 'svc:tv:1']))
        self.assertEqual(store.ensure([('movie', 603), ('tv', 1)]),
                         {'svc:movie:603': {'flatrate': [[8, '/netflix.png', 'Netflix']]},
                          'svc:tv:1': {'flatrate': [[8, '/netflix.png', 'Netflix']]}})
        self.assertEqual(len(self.calls), 2)
        store.ensure([('movie', 603), ('tv', 1)])                       # fresh: never asked again
        self.assertEqual(len(self.calls), 2)
        _found, missing = store.lookup([('movie', 603)])
        self.assertEqual(missing, [])

    def test_errors_are_not_cached_and_nothing_is_an_answer(self):
        self.assertIsNone(store.fetch('movie', 404))
        self.assertEqual(store.lookup([('movie', 404)])[1], ['svc:movie:404'])
        self.assertEqual(store.store('movie', 5, None), {})               # runs nowhere: stored
        self.assertEqual(store.lookup([('movie', 5)]), ({'svc:movie:5': {}}, []))

    def test_a_locked_database_keeps_the_answer(self):
        # Windows Kodi, the guide: six fetches at once, one write waited out the lock ("database is locked")
        import sqlite3
        with mock.patch.object(meta, 'put', side_effect=sqlite3.OperationalError('database is locked')):
            self.assertEqual(store.ensure([('movie', 603)]),
                             {'svc:movie:603': {'flatrate': [[8, '/netflix.png', 'Netflix']]}})
        self.assertEqual(store.lookup([('movie', 603)])[1], ['svc:movie:603'])     # not cached: asked again later

    def test_details_bring_their_services(self):
        detail = {'watch/providers': {'results': {'CZ': {'rent': [APPLE_STORE]}}}}
        found = store.from_details([('movie', 7, detail), ('tv', 8, {'id': 8}), ('tv', 9, None)])
        self.assertEqual(found, {'movie:7': {'rent': [[2, '/apple.png', 'Apple TV Store']]}})
        self.assertEqual(store.lookup([('movie', 7)])[1], [])
        self.assertEqual(self.calls, [])

    def test_expired_entries_show_but_are_refreshed(self):
        store.store('movie', 11, {'flatrate': [NETFLIX]})
        with mock.patch('time.time', return_value=time.time() + store.TTL + 10):
            found, missing = store.lookup([('movie', 11)])
        self.assertIn('svc:movie:11', found)
        self.assertEqual(missing, ['svc:movie:11'])

    def test_request_asks_the_service(self):
        with mock.patch('wcs.skin.refresh.notify') as notify:
            store.request(['svc:movie:1', 'svc:movie:1'])
            store.request([])
        notify.assert_called_once()
        self.assertEqual(notify.call_args.args[0], 'skin_widget_refresh')
        self.assertEqual(store.parse_key('svc:tv:12'), ('tv', 12))
        self.assertIsNone(store.parse_key('library:movie:12'))

    def test_badge_properties(self):
        import xbmcgui
        item = xbmcgui.ListItem('X')
        store.apply(item, catalog.compact({'flatrate': [NETFLIX]}))
        self.assertEqual(item.getProperty('milionar.svc.1'), catalog.LOGO_BASE + '/netflix.png')
        self.assertEqual(item.getProperty('milionar.svc.2'), '')
        self.assertEqual(item.getProperty('milionar.svc.more'), '')


class RowsTest(unittest.TestCase):
    def test_cards_carry_their_services_in_the_snapshot(self):
        fresh_db()
        from wcs.library2 import rows
        store.store('movie', 603, {'flatrate': [NETFLIX]})
        store.store('tv', 7, {'flatrate': [HBO]})
        descriptors = [{'kind': 'movie', 'card': {'id': 603}}, {'kind': 'movie', 'card': {'id': 604}},
                       {'kind': 'genre', 'args': ()}, {'kind': 'tv', 'card': {'id': 7}}]
        with mock.patch('wcs.skin.refresh.notify') as notify:
            rows._services(descriptors)
        self.assertEqual(descriptors[0]['svc'], {'flatrate': [[8, '/netflix.png', 'Netflix']]})
        self.assertIsNone(descriptors[1]['svc'])
        self.assertNotIn('svc', descriptors[2])
        self.assertEqual(descriptors[3]['svc'], {'flatrate': [[1899, '/hbo.png', 'HBO Max']]})   # Pro tebe's series kind
        self.assertEqual(notify.call_args.args[1], ['svc:movie:604'])     # the missing one goes to the service


class ForYouRowsTest(unittest.TestCase):
    def test_a_row_with_its_first_titles_is_reported(self):
        from wcs.foryou import service
        old = {'modes': {'all': [{'kind': 'top10', 'items': ['movie:1']}, {'kind': 'services', 'items': []}]}}
        new = {'modes': {'all': [{'kind': 'top10', 'items': ['movie:1']}, {'kind': 'services', 'items': ['tv:2']}]}}
        self.assertEqual(service.new_rows(old, new), ['fy_services'])
        self.assertEqual(service.new_rows(new, new), [])
        self.assertIn('fy_top10', service.new_rows(None, new))           # the very first snapshot


class TextsTest(unittest.TestCase):
    def test_readable_titles_and_filled_overviews(self):
        self.assertTrue(texts.readable('Kulový blesk – Pelíšky… „Ž“'))
        self.assertFalse(texts.readable('メイドインアビス'))
        self.assertFalse(texts.readable('Видеопрокат'))
        local = [{'id': 1, 'title': 'メイドインアビス', 'original_title': 'メイドインアビス', 'overview': ''},
                 {'id': 2, 'title': 'Matrix', 'overview': 'Neo.'},
                 {'id': 3, 'title': 'ஜெயிலர்', 'original_title': 'ஜெயிலர்', 'overview': 'x'},
                 {'id': 4, 'name': '실낙원', 'original_name': 'Paradise Lost', 'overview': ''}]
        english = [{'id': 1, 'title': 'Made in Abyss', 'overview': 'Riko.'}, {'id': 3, 'title': 'ஜெயிலர்'}]
        self.assertTrue(texts.needs_english(local))
        fixed = texts.fix(local, english)
        self.assertEqual([(i['id'], i.get('title') or i.get('name'), i['overview']) for i in fixed],
                         [(1, 'Made in Abyss', 'Riko.'), (2, 'Matrix', 'Neo.'), (4, 'Paradise Lost', '')])
        self.assertFalse(texts.needs_english([{'title': 'Matrix', 'overview': 'Neo.'}]))


class CacheTest(unittest.TestCase):
    """The one cache (080): fresh never twice, one request for many askers, errors never cached, stale on failure."""

    def setUp(self):
        fresh_db()
        self.calls = 0
        self.fail = False
        self.gate = threading.Event()

        def fake(path, params):
            self.calls += 1
            self.gate.wait(2)
            if self.fail:
                raise IOError('offline')
            return {'page': 1, 'results': [{'id': self.calls}]}
        patcher = mock.patch.object(api, 'FETCH', fake)
        patcher.start()
        self.addCleanup(patcher.stop)

    def test_concurrent_askers_make_one_request(self):
        answers = []
        threads = [threading.Thread(target=lambda: answers.append(api.get('discover/movie', {'page': 1}, 60)))
                   for _ in range(5)]
        for thread in threads:
            thread.start()
        time.sleep(0.2)
        self.gate.set()
        for thread in threads:
            thread.join(5)
        self.assertEqual(self.calls, 1)
        self.assertEqual(len(answers), 5)
        self.assertTrue(all(a == answers[0] for a in answers))
        api.get('discover/movie', {'page': 1}, 60)                     # fresh: from the cache
        self.assertEqual(self.calls, 1)

    def test_errors_fall_back_to_the_expired_answer(self):
        self.gate.set()
        first = api.get('discover/tv', {'page': 1}, 60)
        self.fail = True
        with mock.patch('time.time', return_value=time.time() + 120):
            self.assertEqual(api.get('discover/tv', {'page': 1}, 60), first)     # stale beats nothing
        self.assertIsNone(api.get('discover/tv', {'page': 2}, 60))               # nothing to fall back to
        self.assertIsNone(meta.get_aged(__import__('wcs.metadata.TMDbCache', fromlist=['x']).key_of(
            'discover/tv', {'page': 2, 'language': api.LANGUAGE})))              # the error was not cached


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