# -*- coding: utf-8 -*-
"""The chosen genres drive the suggestions (docs/plan/onboarding/000-plan.md D34-D36)."""
import os
import sys
import unittest

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

kodi_stubs.install()

from wcs.foryou import score as S, signals  # noqa: E402
from wcs.genres import catalog  # noqa: E402
from wcs.onboarding import picks  # noqa: E402


def item(identifier, genre, votes):
    return {'id': identifier, 'title': 'T{}'.format(identifier), 'name': 'T{}'.format(identifier),
            'release_date': '2010-01-01', 'first_air_date': '2010-01-01', 'poster_path': '/p.jpg',
            'backdrop_path': '/b.jpg', 'overview': '', 'vote_average': 8.0, 'vote_count': votes, 'popularity': 50.0,
            'original_language': 'en', 'genre_ids': [genre], 'adult': False}


class FakeTmdb(object):
    """discover/<media> by genre: a big genre (28, thousands of votes) and a small one (99)."""

    def __init__(self):
        self.calls = []

    def __call__(self, path, params):
        self.calls.append((path, dict(params)))
        page = int(params['page'])
        if page > 2:
            return []
        out = []
        for genre in [int(g) for g in str(params['with_genres']).split('|')]:
            base = genre * 1000 + (page - 1) * 20
            out += [item(base + i, genre, 20000 - i if genre == 28 else 900 - i) for i in range(20)]
        out.sort(key=lambda x: -x['vote_count'])
        return out[:20]


class Picks(unittest.TestCase):

    def setUp(self):
        self.fake = FakeTmdb()
        self.original = picks.api.results
        picks.api.results = self.fake
        self.keep = picks.quality_lists.keep
        picks.quality_lists.keep = lambda items, media: list(items)

    def tearDown(self):
        picks.api.results = self.original
        picks.quality_lists.keep = self.keep

    def test_every_genre_takes_its_turn(self):                                # D34
        cards = picks.Pool('movie', ['documentary', 'action']).fill(10)
        genres = [c['genres'][0] for c in cards]
        self.assertEqual(genres, [28, 99] * 5)                                  # action is the more popular genre: first
        self.assertEqual({c[1]['with_genres'] for c in self.fake.calls}, {'28', '99'})

    def test_more_continues_the_turns(self):
        pool = picks.Pool('movie', ['documentary', 'action'])
        pool.fill(3)
        cards = pool.fill(6)
        self.assertEqual([c['genres'][0] for c in cards], [28, 99, 28, 99, 28, 99])

    def test_a_genre_running_dry_leaves_the_others(self):
        pool = picks.Pool('movie', ['documentary', 'action'])
        cards = pool.fill(100)
        self.assertEqual(len(cards), 80)                                        # 2 pages x 20 per genre
        self.assertTrue(pool.done)

    def test_series_of_a_film_only_genre(self):                               # D35
        self.assertEqual(picks.genre_ids('horror', 'tv'), (80, 9648))
        self.assertEqual(picks.genre_ids('romance', 'tv'), (18,))
        self.assertEqual(picks.genre_ids('horror', 'movie'), (27,))
        self.assertEqual(picks.genre_ids('drama', 'tv'), (18,))
        for key in catalog.listed(''):
            self.assertTrue(picks.genre_ids(key, 'tv'), key)                     # every listed genre has series
        # Romantický and Drama ask for the same series genre once
        self.assertEqual(picks.streams_of('tv', ['romance', 'drama']), [(18,)])

    def test_no_genre(self):
        pool = picks.Pool('movie', [])
        self.assertEqual(pool.fill(20), [])
        self.assertTrue(pool.done)


class Taste(unittest.TestCase):

    def test_genres_join_the_profile_weakly(self):                            # D36
        pos = S.with_genres({}, [(27,), (35,)], signals.W_GENRE)
        self.assertEqual(sorted(pos), ['g:27', 'g:35'])
        self.assertAlmostEqual(pos['g:27'], signals.W_GENRE)
        liked = S.with_genres({'g:35': 2.0}, [(27,)], signals.W_GENRE)
        self.assertEqual(liked, {'g:35': 2.0, 'g:27': signals.W_GENRE})
        self.assertLess(signals.W_GENRE, signals.W_MOVIE_WATCHED)
        self.assertGreater(signals.W_GENRE, signals.W_LIST)

    def test_genres_order_the_genre_section(self):                            # D36 (D12)
        sources = catalog.genre_sources([('genre', signals.W_GENRE, [27]), ('genre', signals.W_GENRE, [99])])
        keys = catalog.listed('')
        order, mine = catalog.ordered(keys, sources, {'library': 1, 'watched': 1, 'like': 1, 'dislike': 1}, 0.5)
        self.assertEqual(set(mine), {'horror', 'documentary'})
        self.assertEqual(set(order[:2]), {'horror', 'documentary'})

    def test_chosen_genres_lead_the_genre_section(self):                      # D36: titles' genres do not push them back
        sources = catalog.genre_sources([('like', 2.0, [10752, 18]), ('like', 2.0, [16, 18]), ('genre', signals.W_GENRE, [36])])
        keys = catalog.listed('')
        weights = {'library': 1, 'watched': 1, 'like': 1, 'dislike': 1}
        order, mine = catalog.ordered(keys, sources, weights, 0.2, ['history'])
        self.assertEqual(order[0], 'history')
        self.assertEqual(mine[:2], ['history', 'drama'])
        self.assertEqual(catalog.ordered(keys, sources, weights, 0.2)[0][0], 'drama')     # without the guide: by taste


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