# -*- coding: utf-8 -*-
"""Genre browser (docs/plan/genre-browser/040, 090): catalog, scoring, date cursor, film + series merge, Původ, options.

Run: python3 -m unittest scripts/library_harness/test_genres.py -v   (from the addon folder)
"""
import os
import random
import sys
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.genres import catalog, contract, cursor, options, rows, tmdb  # noqa: E402
from wcs.quality import rules as quality  # noqa: E402

ROOT = os.path.join(HERE, '..', '..')


class FakeTMDb(object):
    """discover/<media> over a fixed list: date filters, sort, 20 per page, page limit 500, a stable tie order."""

    def __init__(self, items, short=True):
        self.items = items
        self.calls = 0
        self.short = short

    def __call__(self, media, params):
        self.calls += 1
        field = cursor.DATE_FIELD[media]
        rows = [i for i in self.items[media] if i['date']]
        if params.get(field + '.lte'):
            rows = [i for i in rows if i['date'] <= params[field + '.lte']]
        if params.get(field + '.gte'):
            rows = [i for i in rows if i['date'] >= params[field + '.gte']]
        sort = params['sort_by']
        if sort.endswith('date.desc') or sort == 'first_air_date.desc':
            rows.sort(key=lambda i: (i['date'], -i['id']), reverse=True)
        elif sort == 'vote_average.desc':
            rows.sort(key=lambda i: (i['vote_average'], -i['id']), reverse=True)
        else:
            rows.sort(key=lambda i: (i['popularity'], -i['id']), reverse=True)
        page = int(params['page'])
        if page > cursor.LAST_PAGE:
            return []
        chunk = rows[(page - 1) * 20:page * 20]
        if self.short:                                 # TMDb drops adult titles after paging: pages of 19 (measured)
            chunk = [i for i in chunk if not hidden(i)]
        key = cursor.ITEM_DATE[media]
        return [dict(i, **{key: i['date']}) for i in chunk]


def hidden(item):
    return item['id'] % 37 == 0


def world(seed=1, movies=700, series=300, crowded=65):
    rnd = random.Random(seed)
    out = {'movie': [], 'tv': []}
    for media, count, start in (('movie', movies, 1), ('tv', series, 100000)):
        for n in range(count):
            year = rnd.randint(1920, 2026)
            when = '{}-{:02d}-{:02d}'.format(year, rnd.randint(1, 12), rnd.randint(1, 28))
            out[media].append({'id': start + n, 'date': when, 'vote_average': round(rnd.uniform(3, 9), 1),
                               'vote_count': rnd.choice([0, 0, 1, 3, 12, 40, 300, 5000]),
                               'popularity': rnd.choice([0.2, 0.6, 1.5, 4.0, 20.0])})
    # many titles on one date (the 1st of January of a year is common on TMDb): more than three TMDb pages
    for n in range(crowded):
        out['movie'].append({'id': 50000 + n, 'date': '2000-01-01', 'vote_average': 6.0, 'vote_count': 5, 'popularity': 1.0})
    out['movie'].append({'id': 60000, 'date': '', 'vote_average': 0, 'vote_count': 0, 'popularity': 0})   # no date
    return out


def walk(fetch, queries, sort='date', accept=None, max_requests=5, size=20):
    seen, pages, state = [], 0, None
    while True:
        items, state, info = cursor.page(fetch, queries, sort, state, size=size, max_requests=max_requests, accept=accept)
        pages += 1
        seen.extend((m, i['id']) for m, i in items)
        if info['end'] or pages > 2000:
            return seen, pages, state


class CursorTest(unittest.TestCase):
    def test_whole_listing_without_holes_or_duplicates(self):
        data = world()
        fetch = FakeTMDb(data)
        seen, _pages, _state = walk(fetch, {'movie': {}})
        self.assertEqual(len(seen), len(set(seen)))
        expected = {('movie', i['id']) for i in data['movie'] if i['date'] and not hidden(i)}
        self.assertEqual(set(seen), expected)
        dates = [next(i['date'] for i in data['movie'] if i['id'] == tid) for _m, tid in seen]
        self.assertEqual(dates, sorted(dates, reverse=True))

    def test_films_and_series_merge_by_date(self):
        data = world()
        seen, _pages, _state = walk(FakeTMDb(data), {'movie': {}, 'tv': {}})
        index = {(m, i['id']): i['date'] for m in data for i in data[m]}
        self.assertEqual(set(seen), {k for k, d in index.items() if d and k[1] % 37})
        dates = [index[k] for k in seen]
        self.assertEqual(dates, sorted(dates, reverse=True))

    def test_filter_and_request_limit_lose_nothing(self):
        data = world(seed=3)
        accept = lambda media, item: item['vote_count'] >= 12      # noqa: E731
        seen, _pages, _state = walk(FakeTMDb(data), {'movie': {}, 'tv': {}}, accept=accept, max_requests=1)
        expected = {(m, i['id']) for m in data for i in data[m] if i['date'] and i['vote_count'] >= 12 and not hidden(i)}
        self.assertEqual(len(seen), len(set(seen)))
        self.assertEqual(set(seen), expected)

    def test_rules_merge_once_and_load_in_parallel(self):
        data = world(seed=5)
        fetch = FakeTMDb(data)
        calls = []

        def parallel(functions):
            calls.append(len(functions))
            return [f() for f in functions]
        # two rules over the same titles (one keeps the famous, the other everything): each title once, by date
        queries = {'movie/votes': {}, 'movie/all': {}}
        accept = lambda name, item: name == 'movie/all' or item['vote_count'] >= 300      # noqa: E731
        seen, state = [], None
        while True:
            items, state, info = cursor.page(fetch, queries, 'date', state, max_requests=4, accept=accept,
                                             parallel=parallel)
            seen.extend((m, i['id']) for m, i in items)
            if info['end']:
                break
        expected = {('movie', i['id']) for i in data['movie'] if i['date'] and not hidden(i)}
        self.assertEqual(len(seen), len(set(seen)))
        self.assertEqual(set(seen), expected)
        self.assertEqual(calls[0], 2)                                            # both rules asked at once

    def test_previous_page_is_the_stored_cursor(self):
        fetch = FakeTMDb(world())
        first, after_first, _ = cursor.page(fetch, {'movie': {}}, 'date')
        second, _after, _ = cursor.page(fetch, {'movie': {}}, 'date', after_first)
        again, _x, _ = cursor.page(fetch, {'movie': {}}, 'date', after_first)
        self.assertEqual([i['id'] for _m, i in second], [i['id'] for _m, i in again])
        self.assertFalse({i['id'] for _m, i in first} & {i['id'] for _m, i in second})

    def test_year_and_today_limits(self):
        data = world()
        base = {'primary_release_date.gte': '1985-01-01', 'primary_release_date.lte': '1985-12-31'}
        seen, _pages, _state = walk(FakeTMDb(data), {'movie': base})
        self.assertEqual(set(seen), {('movie', i['id']) for i in data['movie'] if i['date'][:4] == '1985' and not hidden(i)})

    def test_rating_sort_pages(self):
        data = world(movies=90, series=50, crowded=0)
        seen, _pages, _state = walk(FakeTMDb(data), {'movie': {}, 'tv': {}}, sort='rating')
        self.assertEqual(len(seen), len(set(seen)))
        index = {(m, i['id']): i['vote_average'] for m in data for i in data[m] if i['date'] and not hidden(i)}
        self.assertEqual(set(seen), set(index))
        ratings = [index[k] for k in seen]
        self.assertEqual(ratings, sorted(ratings, reverse=True))

    def test_failed_request_keeps_the_cursor(self):
        data = world()
        fetch = FakeTMDb(data)
        _items, state, _info = cursor.page(fetch, {'movie': {}}, 'date')
        items, after, info = cursor.page(lambda m, p: None, {'movie': {}}, 'date', state)
        self.assertTrue(info['failed'])
        self.assertEqual(items, [])
        self.assertEqual(after, state)


class CatalogTest(unittest.TestCase):
    def test_modes(self):
        self.assertEqual(len(catalog.MOVIE), 19)
        self.assertEqual(len(catalog.TV), 16)
        all_keys = catalog.listed('')
        self.assertNotIn('kids', all_keys)
        self.assertIn('kids', catalog.listed('', show_tv_only=True))
        self.assertNotIn('scifi_fantasy', all_keys)                  # Vše: folded onto Sci-Fi and Fantasy
        self.assertEqual(set(catalog.listed('tv', True)), set(catalog.TV))
        self.assertEqual(set(catalog.listed('movie')), set(catalog.MOVIE))
        self.assertEqual(set(catalog.POPULARITY), set(catalog.GENRES))

    def test_folding(self):
        self.assertEqual(catalog.ids('scifi', 'tv'), (10765,))
        self.assertEqual(catalog.ids('fantasy', 'tv'), (10765,))
        self.assertEqual(catalog.ids('action', 'tv'), (10759,))
        self.assertEqual(catalog.ids('war', 'tv'), (10768,))
        self.assertEqual(catalog.media_of('horror', ''), ('movie',))
        self.assertEqual(catalog.media_of('kids', ''), ('tv',))
        self.assertEqual(catalog.media_of('drama', ''), ('movie', 'tv'))
        self.assertEqual(catalog.taste_ids('scifi_fantasy'), (878, 14))

    def test_extra_tmdb_genre(self):
        extra = catalog.extras({'movie': [{'id': 28, 'name': 'Akční'}, {'id': 4242, 'name': 'Nový'}]})
        self.assertEqual(list(extra), ['tmdb4242'])
        self.assertIn('tmdb4242', catalog.listed('movie', extra=extra))
        self.assertNotIn('tmdb4242', catalog.listed('tv', extra=extra))
        self.assertEqual(catalog.ids('tmdb4242', 'movie', extra), (4242,))

    def test_scoring(self):
        sources = catalog.genre_sources([('watched', 1.0, [878]), ('watched', 0.8, [878, 28]), ('list', 0.25, [35]),
                                         ('like', 1.4, [27]), ('dislike', -1.0, [10749]), ('unknown', 3, [18])])
        weights = {s: 1.0 for s in catalog.SOURCES}
        keys = catalog.listed('movie')
        order, mine = catalog.ordered(keys, sources, weights, 0.2)
        self.assertEqual(set(mine[:2]), {'scifi', 'horror'})        # 1.0 + 0.8 / 2 = 1.4 each: a tie keeps the fixed order
        self.assertNotIn('romance', mine)
        self.assertNotIn('drama', mine)                              # an unknown seed kind counts for nothing
        self.assertEqual(len(order), len(keys))
        self.assertEqual(order[len(mine):], [k for k in keys if k not in mine])
        # a source switched off no longer counts
        _order, mine = catalog.ordered(keys, sources, dict(weights, like=0.0), 0.2)
        self.assertNotIn('horror', mine)
        # no taste: the fixed order
        order, mine = catalog.ordered(keys, {}, weights, 0.2)
        self.assertEqual((order, mine), (keys, []))


class QualityTest(unittest.TestCase):
    """Filter Původ (docs/plan/genre-browser/070 §Filtr): one discover query per rule, a client test per rule."""
    values = options.defaults('gn_list')

    def item(self, **kw):
        data = {'id': 1, 'poster_path': '/p.jpg', 'overview': 'Děj.', 'vote_average': 7.0, 'vote_count': 50}
        data.update(kw)
        return data

    def test_western_rules(self):
        rules = dict(quality.queries('western', self.values))
        self.assertEqual(list(rules), ['svc', 'home', 'rent', 'votes', 'nw_svc', 'nw'])
        self.assertEqual(rules['svc']['watch_region'], 'CZ')
        self.assertIn('8', rules['svc']['with_watch_providers'].split('|'))           # Netflix
        self.assertIn('1939', rules['svc']['with_watch_providers'].split('|'))        # Lepší TV
        self.assertIn('cs', rules['svc']['with_original_language'].split('|'))
        self.assertNotIn('ja', rules['svc']['with_original_language'].split('|'))
        self.assertEqual(rules['rent']['with_watch_monetization_types'], 'rent|buy')
        self.assertEqual(rules['votes']['vote_count.gte'], 10)
        self.assertEqual(rules['nw_svc']['vote_count.gte'], 50)
        self.assertEqual(rules['nw']['vote_count.gte'], 150)
        self.assertEqual(rules['nw']['without_keywords'], quality.ANIME_KEYWORD)      # anime has its own filter
        self.assertNotIn('watch_region', rules['home'])
        anime = dict(quality.queries('anime', self.values))
        self.assertEqual(anime['votes']['with_keywords'], quality.ANIME_KEYWORD)
        self.assertTrue(dict(quality.queries('world', self.values)))
        asia = dict(quality.queries('asia', self.values))
        self.assertEqual(asia['votes']['without_genres'], quality.ANIMATION)          # Asie = live action

    def test_keep(self):
        v = self.values
        self.assertFalse(quality.keep('svc', self.item(poster_path=None), v))         # never a card without a poster
        self.assertFalse(quality.keep('svc', self.item(overview=''), v))             # never an empty hero
        self.assertTrue(quality.keep('svc', self.item(vote_count=0, vote_average=0), v))   # a big service overrides
        self.assertTrue(quality.keep('home', self.item(vote_count=0), v))            # Czech titles have no votes
        one_ten = self.item(vote_count=1, vote_average=10.0)
        self.assertFalse(quality.keep('votes', dict(one_ten, vote_count=12, vote_average=5.0), v))
        self.assertTrue(quality.keep('votes', self.item(vote_count=5000, vote_average=5.4), v))   # known: stays
        self.assertTrue(quality.keep('votes', self.item(vote_count=40, vote_average=7.4), v))
        self.assertFalse(quality.keep('nw', self.item(vote_count=200, vote_average=6.0), v))
        self.assertTrue(quality.keep('nw', self.item(vote_count=900, vote_average=7.3), v))
        self.assertTrue(quality.keep('votes', self.item(poster_path=None), v, known=True))
        self.assertTrue(quality.junk({'votes': 0, 'popularity': 0.3}))
        self.assertLess(quality.bayes(9.0, 2), 7.0)


class OptionsTest(unittest.TestCase):
    def test_encode_decode_and_defaults(self):
        values = options.values('gn_list', '')
        self.assertEqual(values, options.defaults('gn_list'))
        changed = dict(values, west_votes=values['west_votes'] + 1)
        text = options.encode('gn_list', changed)
        self.assertNotIn('"', text)
        self.assertEqual(options.values('gn_list', text), changed)
        self.assertEqual(options.encode('gn_list', values), '')          # defaults are not stored
        self.assertEqual(options.values('gn_list', 'west_votes=abc,unknown=3'), options.defaults('gn_list'))


class SourceTest(unittest.TestCase):
    def test_queries(self):
        from datetime import date
        source = tmdb.Source(today=date(2026, 10, 27))
        both = source.queries('scifi', {'media': '', 'year': '1985', 'country': 'CZ', 'sort': 'date'})
        self.assertEqual(set(both), {'movie', 'tv'})
        self.assertEqual(both['movie']['with_genres'], '878')
        self.assertEqual(both['tv']['with_genres'], '10765')
        self.assertEqual(both['movie']['with_origin_country'], 'CZ|XC')              # Czechoslovakia belongs to it
        self.assertEqual(both['movie']['primary_release_date.gte'], '1985-01-01')
        self.assertEqual(both['tv']['first_air_date.lte'], '1985-12-31')
        self.assertEqual(both['movie']['include_adult'], 'false')
        today = source.queries('horror', {'media': '', 'sort': 'date'})
        self.assertEqual(list(today), ['movie'])                                 # no series genre: films only
        self.assertEqual(today['movie']['primary_release_date.lte'], '2026-10-27')   # nothing from the future
        top = source.queries('drama', {'media': 'movie', 'sort': 'rating', 'rating_votes': 100})
        self.assertEqual(top['movie']['vote_count.gte'], 100)
        ruled = source.queries('drama', {'media': '', 'sort': 'rating', 'rating_votes': 100, 'origin': 'western'}, None,
                               options.defaults('gn_list'))
        self.assertEqual(len(ruled), 12)                                         # 6 rules x films and series
        self.assertEqual(ruled['movie/votes']['vote_count.gte'], 100)            # the larger of the two minimums
        self.assertEqual(ruled['tv/nw']['vote_count.gte'], 150)
        self.assertNotIn('vote_count.gte', source.queries('drama', {'media': 'movie', 'sort': 'date', 'origin': 'western'},
                                                          None, options.defaults('gn_list'))['movie/svc'])
        tv = source.queries('action_adventure', {'media': 'movie', 'sort': 'date'})
        self.assertEqual(tv['movie']['with_genres'], '28|12')

    def test_side_rows(self):
        source = tmdb.Source()
        for row in contract.ROW_TYPES[1:]:
            kind = 'gn_decade' if row.startswith('gn_decade_') else row
            calls = source.row_queries(kind, 'drama', {'media': '', 'country': ''}, None,
                                       contract.decade_years(row) if kind == 'gn_decade' else None)
            self.assertTrue(calls, row)
            self.assertEqual({m for m, _p in calls}, {'movie', 'tv'})
        older = source.row_queries('gn_decade', 'drama', {'media': 'movie'}, None, contract.decade_years('gn_decade_older'))
        self.assertEqual(older[0][1]['primary_release_date.lte'], '1949-12-31')

    def test_ranking_never_repeats_and_drops_posterless(self):
        def item(i, **kw):
            data = {'id': i, 'title': 'T%d' % i, 'poster_path': '/p.jpg', 'vote_average': 7.5, 'vote_count': 800,
                    'popularity': 10.0 + i, 'genre_ids': [18], 'release_date': '2001-01-01'}
            data.update(kw)
            return data
        answers = [('movie', [item(1), item(2, poster_path=None), item(3, vote_count=100, vote_average=8.4)])]
        popular = rows.rank(contract.POPULAR, answers)
        self.assertEqual([c['id'] for c in popular], [3, 1])
        top = rows.rank(contract.TOP, answers, exclude={'movie:3'})
        self.assertEqual([c['id'] for c in top], [1])
        boosted = rows.rank(contract.POPULAR, answers, classes={'movie:1': 3})       # a big CZ service ranks higher
        self.assertEqual([c['id'] for c in boosted], [1, 3])
        self.assertEqual([c['id'] for c in rows.rank(contract.SERVICES, answers)], [3, 1])
        gems = rows.rank(contract.GEMS, answers)
        self.assertEqual([c['id'] for c in gems], [3, 1])
        snapshot = {'items': {'movie:1': {'media': 'movie', 'id': 1, 'genres': [18], 'year': 2001, 'score': 0.5}}}
        mine = rows.rank(contract.FORYOU, answers, snapshot=snapshot)
        self.assertEqual(mine[0]['id'], 1)                                   # a Pro tebe title first
        self.assertEqual(len(rows.snapshot_cards(snapshot, (18,), ('movie',), {'year': ''})), 1)
        self.assertEqual(rows.snapshot_cards(snapshot, (18,), ('movie',), {'country': 'CZ'}), [])


class GenreRowTest(unittest.TestCase):
    def test_genre_cards_follow_the_profile_and_mode(self):
        from wcs.genres import widgets
        values = options.defaults(contract.FY_ROW)
        snapshot = {'genre_sources': catalog.genre_sources([('watched', 1.2, [878]), ('like', 1.0, [27])])}
        keys, mine = widgets.genre_order('', values, snapshot)
        self.assertEqual(set(mine), {'scifi', 'horror'})
        self.assertEqual(set(keys[:2]), {'scifi', 'horror'})
        self.assertNotIn('kids', keys)
        keys, mine = widgets.genre_order('tv', values, snapshot)
        self.assertEqual(mine, ['scifi_fantasy'])                            # no horror series genre
        keys, _mine = widgets.genre_order('tv', dict(values, tv_only=True), snapshot)
        self.assertIn('kids', keys)
        old = widgets.genre_order('movie', values, {'taste': [35]})[1]       # a snapshot from before genre_sources
        self.assertEqual(old, ['comedy'])

    def test_listing_cards(self):
        import xbmcaddon
        from wcs.genres import widgets
        xbmcaddon.Addon.strings.update({35575: 'Další stránka', 35576: 'Předchozí stránka', 35577: 'Strana {}',
                                        35578: 'Nic nenalezeno', 35579: 'Změň filtr'})
        view = {'rows': {'1': []}, 'list': {'page': 2, 'more': True}, 'names': {}}
        items = widgets.view_rows(contract.LIST, view, '1', 'detail')
        labels = [(item.getLabel(), item.getProperty('milionar.card.icon')) for _p, item, _f in items]
        self.assertEqual([label for label, _icon in labels], ['Předchozí stránka', 'Další stránka', 'Nic nenalezeno'])
        self.assertTrue(all(icon for _label, icon in labels))
        self.assertIn('genre_page', items[1][1].getProperty('milionar.exec'))
        self.assertEqual(widgets.view_rows(contract.POPULAR, view, '5', 'detail'), [])

    def test_paging_cards_name_themselves_in_the_hero(self):
        import xbmcaddon
        from wcs.genres import widgets
        xbmcaddon.Addon.strings.update({35575: 'Další stránka', 35576: 'Předchozí stránka', 35577: 'Strana {}'})
        view = {'rows': {'1': [{'id': 1, 'media': 'movie', 'title': 'První'}]},
                'list': {'page': 2, 'more': True}, 'names': {}}
        items = widgets.view_rows(contract.LIST, view, '1', 'detail')
        self.assertEqual([item.getProperty('milionar.hero.title') for _p, item, _f in items],
                         ['Předchozí stránka', 'První', 'Další stránka'])
        self.assertIn('S', items[-1][1].getProperty('milionar.hero.kicker').upper())


class SkinTest(unittest.TestCase):
    def test_generated_page_and_wiring(self):
        sys.path.insert(0, os.path.join(ROOT, 'scripts', 'skin_harness'))
        import gen_genre
        import xml.etree.ElementTree as ET
        with open(gen_genre.OUT, encoding='utf-8') as handle:                    # the committed file is current
            self.assertEqual(ET.canonicalize(handle.read(), strip_text=True),    # (gen_modular writes it, like test_cinema)
                             ET.canonicalize(gen_genre.build(), strip_text=True))
        xml = os.path.join(ROOT, 'resources', 'skin.milionar', 'xml')
        with open(os.path.join(xml, 'Includes.xml'), encoding='utf-8') as handle:
            self.assertIn('<include file="Includes_MilionarGenre.xml" />', handle.read())
        with open(os.path.join(xml, 'Home.xml'), encoding='utf-8') as handle:
            home = handle.read()
        self.assertIn('<include>MilionarGenre</include>', home)
        self.assertIn('<include content="MilCineMenuRight">', home)                 # the menu leads back into the page
        self.assertEqual(home.count('<include content="MilCineMenuClick">'), 10)
        self.assertNotIn('milionar.genre.active', home)                          # no exit when the menu gets the focus
        text = gen_genre.build()
        for _name, control in contract.BUTTONS:
            self.assertIn('<param name="id" value="{}"/>'.format(control), text)
        self.assertEqual(len(set(contract.BUTTON_IDS + (contract.ANCHOR, contract.BUTTON_GROUP, contract.ROWS))),
                         len(contract.BUTTON_IDS) + 3)

    def test_strings_in_every_language(self):
        import re
        ids = set()
        for path in ('wcs/genres/page.py', 'wcs/genres/widgets.py', 'wcs/genres/options.py', 'wcs/genres/catalog.py',
                     'wcs/foryou/service.py', 'resources/settings.xml'):
            with open(os.path.join(ROOT, path), encoding='utf-8') as handle:
                ids.update(int(i) for i in re.findall(r'\b(35[5-6]\d\d)\b', handle.read()))
        ids.update(range(35560, 35569))
        for lang in ('cs_cz', 'sk_sk', 'en_gb'):
            with open(os.path.join(ROOT, 'resources', 'language', 'resource.language.' + lang, 'strings.po'), encoding='utf-8') as handle:
                po = handle.read()
            missing = sorted(i for i in ids if 'msgctxt "#{}"'.format(i) not in po)
            self.assertEqual(missing, [], lang)


class HeaderTest(unittest.TestCase):
    def test_listing_header_names_genre_years_and_page(self):
        import xbmcaddon
        from wcs.genres import page
        xbmcaddon.Addon.strings[35577] = 'Strana {}'
        entries = [{'year': 2026}, {'year': 2024}, {'year': 2025}, {'year': 0}]
        self.assertEqual(page.listing_header('Válečný', entries, 1), 'Válečný · 2024–2026 · Strana 1')
        self.assertEqual(page.listing_header('Válečný', [{'year': 1985}], 3), 'Válečný · 1985 · Strana 3')
        self.assertEqual(page.listing_header('Válečný', [], 2), 'Válečný · Strana 2')


class PageLoadTest(unittest.TestCase):
    """The page opens at once and fills row by row; never a row of the previous view (wcs/skin/pages.Loading)."""

    class Source(object):
        def extras(self, cached_only=True):
            return {}

        def countries(self):
            return []

    def setUp(self):
        import xbmc
        import xbmcgui
        from wcs.genres import page, widgets
        self.page, self.xbmcgui = page, xbmcgui
        xbmcgui.Window.props.clear()
        xbmcgui.PROGRESS.clear()
        for name, value in (('active', 'true'), ('has.1', 'true'), ('token.1', 'old'), ('has.3', 'true'),
                            ('token.3', 'old'), ('fanart', 'old.jpg'), ('listing', 'Old · Strana 4')):
            page._set(name, value)
        self.state = {'key': '28', 'filters': page.default_filters(), 'page': 1, 'cursor': None, 'stack': []}
        self.patches = [mock.patch.object(t, n, v) for t, n, v in (
            (page.settings, 'source', mock.Mock(return_value=self.Source())),
            (page, '_signature', mock.Mock(return_value='new')), (page, '_store', mock.Mock()),
            (page, 'prefetch', mock.Mock()), (page, 'focus_listing', mock.Mock()),
            (widgets, 'load_view', mock.Mock(return_value=None)), (widgets, 'genre_name', mock.Mock(return_value='Akční')),
            (xbmc, 'executebuiltin', mock.Mock()), (xbmc, 'getCondVisibility', mock.Mock(return_value=True)))]
        for patch_ in self.patches:
            patch_.start()

    def tearDown(self):
        for patch_ in self.patches:
            patch_.stop()

    def shown(self):
        return {n: self.page._get('token.{}'.format(n)) for n in range(1, 15) if self.page._get('has.{}'.format(n))}

    def test_rows_of_the_previous_view_go_at_once_and_new_ones_come_one_by_one(self):
        seen = []

        def compute(state, progress, ready):
            seen.append((self.shown(), self.page._get('fanart'), self.page._get('listing'),
                         bool(self.page._get('loading')), self.xbmcgui.PROGRESS[0][:2]))
            view = {'rows': {'1': [{'id': 1, 'year': 2026, 'backdrop': '/b.jpg'}]}, 'list_slot': 1,
                    'list': {'page': 1, 'more': True}}
            ready(view, 1)
            seen.append(self.shown())
            view['rows']['2'] = []                          # a side row without cards stays hidden
            view['rows']['3'] = [{'id': 2}]
            ready(view, 2)
            ready(view, 3)
            return view, {'c': 1}, False
        with mock.patch.object(self.page, 'compute', side_effect=compute):
            self.assertTrue(self.page.load(self.state, 0))
        self.assertEqual(seen[0], ({}, '', '', True, ('create', self.page.text(self.page.S_HEADING).format('Akční'))))
        self.assertEqual(seen[1], {1: 'new'})
        self.assertEqual(self.shown(), {1: 'new', 3: 'new'})
        self.assertEqual(self.page._get('fanart'), 'https://image.tmdb.org/t/p/w1280/b.jpg')
        self.assertEqual(self.page._get('loading'), '')
        self.assertEqual(self.xbmcgui.PROGRESS[-1], ('close',))
        self.assertEqual(json_state(self.page)['next'], {'c': 1})
        self.page.focus_listing.assert_called_once_with(0)

    def test_a_newer_load_stops_this_one_before_it_shows_anything(self):
        from wcs.skin import pages

        def compute(state, progress, ready):
            pages.cancel(self.page.PREFIX)                 # Zpět, another genre or filter meanwhile
            ready({'rows': {'1': [{'id': 1}]}, 'list_slot': 1}, 1)
            raise AssertionError('not reached')
        with mock.patch.object(self.page, 'compute', side_effect=compute):
            self.assertIsNone(self.page.load(self.state, 0))
        self.assertEqual(self.shown(), {})
        self.assertEqual(self.xbmcgui.PROGRESS[-1], ('close',))

    def test_a_failed_open_goes_back(self):
        with mock.patch.object(self.page, 'compute', side_effect=IOError('offline')), \
                mock.patch.object(self.page, 'back') as back, \
                mock.patch.object(self.page, '_focus', return_value={'window': 10000, 'control': 32300, 'position': 0}):
            self.page.open_genre({'genre': '28'})
        back.assert_called_once_with()
        self.assertEqual(self.xbmcgui.NOTIFICATIONS[-1][1], self.page.text(self.page.S_FAILED))


def json_state(page):
    import json
    return json.loads(page._get('state'))


class TileTest(unittest.TestCase):
    def test_a_tile_names_only_the_titles_that_fit_its_three_lines(self):
        from wcs.skin import hero
        with mock.patch.object(hero, '_string', return_value='Např. {}.'):
            self.assertEqual(hero.examples('Věta.', []), 'Věta.')
            self.assertEqual(hero.examples('Věta.', ['A', 'B']), 'Věta. Např. A, B.')
            shown = hero.examples('Věta.', ['Dlouhý název titulu číslo {}'.format(n) for n in range(20)])
        self.assertLessEqual(len(shown), hero.TILE_PLOT_CHARS)
        self.assertTrue(shown.endswith('.'))

    def test_the_abort_monitor_exists_before_anything_can_block_the_service(self):
        source = open(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..', 'service.py'), encoding='utf-8').read()
        main = source.split("if __name__ == '__main__':")[1]
        self.assertLess(main.index('abort_monitor = xbmc.Monitor()'), main.index('update_policy'))
        self.assertIn('abort_monitor.waitForAbort()', main)
        self.assertNotIn('xbmc.Monitor().waitForAbort', main)


class WatchStateTest(unittest.TestCase):
    class Data(object):
        def __init__(self, states, order=(), show=None):
            self.states, self.order, self.details = states, list(order), show or {}

        def episode_states(self):
            return {7: self.states}

        def series_state(self, tmdb_id):
            return self.details, self.order, {}

        def movie_states(self):
            return {5: {'playcount': 2, 'resume_pos': 30.0, 'resume_total': 90.0}}

    def order(self):
        return [{'s': 1, 'e': number, 'aired': number < 4} for number in range(1, 5)]

    def test_a_series_nobody_started_has_no_count_and_reads_no_metadata(self):
        from wcs.library2 import rows
        data = self.Data({(1, 1): {'playcount': 0}})
        with mock.patch.object(data, 'series_state', side_effect=AssertionError):
            self.assertEqual(rows.series_counts(data, 7), (0, 0))

    def test_a_started_series_counts_its_aired_episodes(self):
        from wcs.library2 import rows
        data = self.Data({(1, 1): {'playcount': 1}, (1, 2): {'resume_pos': 10}, (1, 4): {'playcount': 1}}, self.order())
        self.assertEqual(rows.series_counts(data, 7), (3, 1))
        self.assertEqual(rows.series_counts(self.Data({(1, 1): {'playcount': 1}}, show={'number_of_episodes': 9}), 7), (9, 1))

    def test_a_recommendation_gets_the_state_of_the_store(self):
        from wcs.library2 import rows
        card = {'kind': 'movie', 'id': 5, 'outside': True, 'playcount': 0, 'resume': 0.0}
        rows._state_of_outsider(card, self.Data({}))
        self.assertEqual((card['playcount'], card['resume'], card['resume_total']), (2, 30.0, 90.0))
        self.assertNotIn('outside', card)
        series = {'kind': 'tv', 'id': 7, 'outside': True, 'counts': [0, 0]}
        rows._state_of_outsider(series, self.Data({(1, 1): {'playcount': 1}}, self.order()))
        self.assertEqual(series['counts'], [3, 1])

    def test_a_change_builds_only_rows_whose_cards_can_come_and_go(self):
        from wcs.skin import refresh
        rows = refresh.media_rows('movie')
        self.assertTrue({'cont_movies', 'my_movies_watched', 'fy_continue'} <= rows)
        self.assertFalse({'fy_for_you', 'fy_top10', 'widget_tmdb_popular_movies', 'fy_genres'} & rows)

    def test_the_hero_of_an_episode_is_that_episode(self):
        from wcs.skin import hero
        card = {'title': 'Přátelé', 'genre': 'Komedie', 'plot': 'Popis seriálu', 'backdrop': '/b.jpg', 'rating': 8.4}
        episode = {'s': 2, 'e': 3, 'name': 'Hlavně nebýt sám', 'plot': 'Popis epizody', 'rating': 8.3, 'runtime': 23,
                   'air_date': '1995-10-05', 'aired': True}
        with mock.patch.object(hero, '_string', side_effect=lambda number, fallback: fallback or 'bez popisu'):
            texts = hero.episode(card, episode, {'playcount': 1})
            empty = hero.episode(card, dict(episode, plot=''), {})
        self.assertEqual((texts['title'], texts['plot'], texts['badge'], texts['rating']),
                         ('Hlavně nebýt sám', 'Popis epizody', 'S2 · E3', ''))
        self.assertEqual(texts['now'], 'TMDb 8.3 · 23m · 1995')
        self.assertEqual(texts['watchkind'], 'watched')
        self.assertEqual(empty['plot'], 'bez popisu')


class SlotTest(unittest.TestCase):
    def test_no_limit_and_genres_row_once(self):
        from wcs.skin import hero_contract, slots
        for sec, (_name, rows_, _defaults) in slots.SECTIONS.items():
            self.assertGreaterEqual(slots.slot_count(sec), len(rows_), sec)
        ids = [hero_contract.list_id(32000, n) for n in range(1, 15)]
        self.assertEqual(ids[:7], [32100 + 100 * i for i in range(7)])            # the ids every section always had
        self.assertTrue(all(i - 32000 not in hero_contract.BUTTON_OFFSETS for i in ids))
        self.assertLess(int(str(max(ids)) + '666'), 2 ** 31)                     # the row header's id stays 32-bit
        stored = ['fy_continue', 'fy_for_you', 'fy_top10', 'fy_because_1', 'fy_tonight', 'fy_new', 'fy_genres', 'off']
        current = lambda sec, n: {'type': stored[n - 1] if n <= len(stored) else '', 'uid': str(n)}   # noqa: E731
        for before in (stored, [t for t in stored if t != 'fy_genres']):               # V1 install, older install
            stored = before
            with mock.patch.object(slots, 'current', side_effect=current), \
                    mock.patch.object(slots, '_write_section', return_value=True) as write, \
                    mock.patch.object(slots, 'reload_skin') as reload_:
                slots.add_genres_row()
            sec, widgets = write.call_args.args[:2]
            self.assertEqual(sec, 'foryou')
            self.assertEqual([w['type'] for w in widgets], ['fy_continue', 'fy_for_you', 'fy_genres', 'fy_top10',
                                                            'fy_because_1', 'fy_tonight', 'fy_new'])
            self.assertEqual([w['uid'] for w in widgets if w['type'] == 'fy_top10'], ['3'])  # settings move along
            self.assertTrue(reload_.called)
        from wcs.skin import defaults
        self.assertEqual(defaults.section('foryou')['widgets'][2]['type'], 'fy_genres')
        self.assertEqual(slots.SECTIONS['foryou'][2][2][0], 'fy_genres')


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