# -*- coding: utf-8 -*-
"""Paging of the genre listing (docs/plan/genre-browser/010 §Výpis). Pure: no Kodi, no network.

TMDb discover stops at page 500 (10 000 titles), Drama has far more. Sorted by date the listing therefore walks a
cursor: a page asks for titles released on or before the date of the last title it looked at, and skips the titles of
that date it has already seen. Only when a whole TMDb page lies on that one date does it ask for the next TMDb page of
the same date. So it goes from today back to the oldest title without holes or duplicates.

Sorted by rating or popularity the 500-page limit stays (10 000 titles is more than anyone pages through): the cursor is
the TMDb page and the position on it.

Films and series together ("Oboje") and the rules of the filter Původ (wcs/quality/rules.py: one discover query per
rule) are several cursors merged by the sort key; a query is named '<media>' or '<media>/<rule>'. A title two rules
found shows once (the page remembers the titles of the last SEEN looked at). A cursor only moves over titles that were
looked at, so a filter that drops titles never loses one, and a page cut short by the request limit goes on where it
stopped. Every cursor is plain JSON (it lives in a window property and in the stack of previous pages).
"""
import copy

LAST_PAGE = 500
DATE_FIELD = {'movie': 'primary_release_date', 'tv': 'first_air_date'}
ITEM_DATE = {'movie': 'release_date', 'tv': 'first_air_date'}
SORTS = ('date', 'rating', 'popularity')
SORT_BY = {'rating': 'vote_average.desc', 'popularity': 'popularity.desc'}
SEEN = 300                       # titles remembered across pages against a second rule finding the same title
SEEN_KEY = '_seen'


def media_of(name):
    """'movie' of a query name 'movie' or 'movie/svc'."""
    return name.split('/', 1)[0]


def date_of(media, item):
    return item.get(ITEM_DATE[media]) or item.get('release_date') or item.get('first_air_date') or ''


def start(medias, sort):
    """A cursor at the first page."""
    if sort == 'date':
        return {m: {'lte': '', 'page': 1, 'skip': [], 'done': False} for m in medias}
    return {m: {'page': 1, 'skip': 0, 'done': False} for m in medias}


def params_for(media, base, sort, state):
    """The discover parameters of the next TMDb page of `media`."""
    params = dict(base)
    if sort == 'date':
        field = DATE_FIELD[media]
        params['sort_by'] = field + '.desc'
        limit = params.get(field + '.lte') or ''
        if state['lte'] and (not limit or state['lte'] < limit):
            params[field + '.lte'] = state['lte']
    else:
        params['sort_by'] = SORT_BY[sort]
    params['page'] = state['page']
    return params


def _key(media, item, sort):
    """The merge key: the larger comes first (film before series on a tie)."""
    if sort == 'date':
        value = date_of(media, item)
    elif sort == 'rating':
        value = float(item.get('vote_average') or 0)
    else:
        value = float(item.get('popularity') or 0)
    return (value, 1 if media == 'movie' else 0)


class _Walker(object):
    """One media's cursor while a page is put together."""

    def __init__(self, name, base, sort, state, fetch):
        self.name, self.media = name, media_of(name)
        self.base, self.sort, self.state, self.fetch = base, sort, state, fetch
        self.buffer, self.page_size, self.lte_at_fetch = [], 0, None

    def active(self):
        return not self.state['done']

    def load(self):
        """Fetch the TMDb page the cursor points at; False when TMDb did not answer."""
        results = self.fetch(self.media, params_for(self.media, self.base, self.sort, self.state))
        if results is None:
            return False
        self.page_size = len(results)
        if self.sort == 'date':
            self.lte_at_fetch = self.state['lte']
            seen = set(self.state['skip'])
            lte = self.state['lte']
            self.buffer = [r for r in results if not (lte and (date_of(self.media, r) or lte) == lte and r['id'] in seen)]
        else:
            self.buffer = list(results[self.state['skip']:])
        if not self.buffer:
            self._page_done()
        return True

    def head(self):
        return self.buffer[0]

    def take(self):
        """Look at the next title: the cursor moves past it."""
        item = self.buffer.pop(0)
        if self.sort == 'date':
            when = date_of(self.media, item) or self.state['lte']
            if self.state['lte'] and when == self.state['lte']:
                self.state['skip'].append(item['id'])
            else:
                self.state.update(lte=when, page=1, skip=[item['id']])
        else:
            self.state['skip'] += 1
        if not self.buffer:
            self._page_done()
        return item

    def _page_done(self):
        """Every title of the fetched TMDb page was looked at. Only an empty page ends a cursor: TMDb answers a full
        page with 19 titles now and then (measured on Drama, 2026-10-27)."""
        if not self.page_size:
            self.state['done'] = True
        elif self.sort == 'date':
            if self.state['lte'] == self.lte_at_fetch:        # the whole page lay on one date: its next TMDb page
                self.state['page'] += 1
                if self.state['page'] > LAST_PAGE:
                    self.state['done'] = True
        else:
            self.state.update(page=self.state['page'] + 1, skip=0)
            if self.state['page'] > LAST_PAGE:
                self.state['done'] = True


def page(fetch, queries, sort, cursor=None, size=20, max_requests=5, accept=None, parallel=None):
    """One page of the listing.

    fetch(media, params) -> TMDb results (list) or None; queries: {query name: base discover params};
    accept(query name, item) -> bool (the Původ filter; None keeps everything); parallel(callables) -> results runs
    the first fetches of several cursors at once (None: one after another).
    Returns (items [(media, item)], next cursor, info {'requests', 'looked', 'complete', 'end', 'failed'}):
    `complete` = the page is full or the listing ended; `end` = nothing comes after this page.
    """
    state = copy.deepcopy(cursor) if cursor else start(tuple(queries), sort)
    walkers = [_Walker(n, queries[n], sort, state[n], fetch) for n in queries if n in state]
    seen = state.setdefault(SEEN_KEY, [])
    info = {'requests': 0, 'looked': 0, 'complete': False, 'end': False, 'failed': False}
    # every cursor may fetch once, or merging two of them could never move on
    max_requests = max(max_requests, sum(1 for w in walkers if w.active()))
    items = []
    while len(items) < size:
        hungry = [w for w in walkers if w.active() and not w.buffer]
        stuck = False
        batch = hungry[:max(0, max_requests - info['requests'])]
        if parallel and len(batch) > 1:                 # every hungry cursor at once, then one by one below
            info['requests'] += len(batch)
            if not all(parallel([w.load for w in batch])):
                info['failed'] = True
                break
        for walker in hungry:
            while walker.active() and not walker.buffer:
                if info['requests'] >= max_requests:
                    stuck = True
                    break
                info['requests'] += 1
                if not walker.load():
                    info['failed'] = stuck = True
                    break
            if stuck:
                break
        if stuck:
            break
        ready = [w for w in walkers if w.buffer]
        if not ready:
            break                                     # every cursor reached its end
        walker = max(ready, key=lambda w: _key(w.media, w.head(), sort))
        item = walker.take()
        info['looked'] += 1
        identity = '{}:{}'.format(walker.media, item['id'])
        if identity in seen:
            continue
        if accept is None or accept(walker.name, item):
            seen.append(identity)
            del seen[:-SEEN]
            items.append((walker.media, item))
    info['end'] = all(not w.active() and not w.buffer for w in walkers)
    info['complete'] = len(items) >= size or info['end']
    return items, state, info
