# -*- coding: utf-8 -*-
"""Kvalita návrhů: the one quality judgement of TMDb titles across the addon (docs/plan/genre-browser/900 kolo 7).

Run: python3 -m unittest scripts/library_harness/test_quality.py -v   (from the addon folder)
"""
import os
import re
import sys
import tempfile
import unittest

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

stubs.install()

from wcs.genres import options  # noqa: E402
from wcs.library2 import store as library  # noqa: E402
from wcs.quality import lists, rules, settings  # noqa: E402
from wcs.services import catalog, store  # noqa: E402

VALUES = settings.defaults()


def read(*parts):
    with open(os.path.join(ROOT, *parts), encoding='utf-8') as handle:
        return handle.read()


def title(**kw):
    data = {'id': 1, 'poster_path': '/p.jpg', 'overview': 'x', 'original_language': 'en', 'vote_count': 500,
            'vote_average': 7.0, 'genre_ids': [878]}
    data.update(kw)
    return data


class JudgeTest(unittest.TestCase):
    def test_western_default(self):
        judge = lambda item, service=catalog.NONE: rules.judge(item, VALUES, service)   # noqa: E731
        self.assertTrue(judge(title()))
        self.assertFalse(judge(title(poster_path=None)))                                # never without a poster
        self.assertFalse(judge(title(vote_count=1, vote_average=10.0)))                 # one fan is no audience
        self.assertTrue(judge(title(vote_count=0, vote_average=0), catalog.BIG_CLASS))  # Netflix vouches for it
        self.assertFalse(judge(title(vote_count=3), catalog.RENT_CLASS))                # a rental store needs votes
        self.assertTrue(judge(title(vote_count=12, vote_average=5.0), catalog.RENT_CLASS))
        self.assertTrue(judge(title(vote_count=5000, vote_average=5.4)))                # a known blockbuster stays
        self.assertTrue(judge(title(original_language='cs', vote_count=0)))             # Czech titles have no votes
        self.assertFalse(judge(title(original_language='hi', vote_count=60)))           # non-western needs more
        self.assertTrue(judge(title(original_language='ko', vote_count=60), catalog.BIG_CLASS))
        self.assertTrue(judge(title(original_language='ko', vote_count=900, vote_average=7.3)))
        self.assertFalse(judge(title(original_language='ja', genre_ids=[16], vote_count=5000)))   # anime: own filter
        # a Pro tebe card (wcs/foryou/features.card) is judged the same
        card = {'poster': '/p.jpg', 'language': 'en', 'votes': 1, 'rating': 10.0, 'genres': [878]}
        self.assertFalse(rules.judge(card, VALUES))

    def test_other_origins(self):
        anime = title(original_language='ja', genre_ids=[16], vote_count=40)
        self.assertTrue(rules.judge(anime, VALUES, origin='anime'))
        self.assertTrue(rules.judge(anime, VALUES, origin='world'))
        self.assertFalse(rules.judge(title(), VALUES, origin='anime'))
        self.assertFalse(rules.judge(anime, VALUES, origin='asia'))                     # Asie is live action
        self.assertTrue(rules.judge(title(original_language='ko', vote_count=40), VALUES, origin='asia'))
        self.assertTrue(rules.judge(title(original_language='hi', vote_count=60), VALUES, origin='world'))
        self.assertTrue(rules.judge(title(vote_count=0), dict(VALUES, origin='world'), catalog.BIG_CLASS))
        # the global origin decides when none is given
        self.assertTrue(rules.judge(anime, dict(VALUES, origin='anime')))

    def test_thresholds_are_the_settings(self):
        self.assertFalse(rules.judge(title(vote_count=12, vote_average=6.0), dict(VALUES, rating=7.0)))
        self.assertTrue(rules.judge(title(vote_count=6), dict(VALUES, west_votes=5)))


class SettingsTest(unittest.TestCase):
    def test_parse_and_defaults(self):
        self.assertEqual(settings.parse({}), settings.defaults())
        raw = {'quality_origin': '2', 'quality_west_votes': '20', 'quality_rating': '6.5',
               'quality_nw_svc_votes': 'broken', 'quality_nw_votes': '999'}
        values = settings.parse(raw)
        self.assertEqual(values['origin'], 'anime')
        self.assertEqual((values['west_votes'], values['rating']), (20, 6.5))
        self.assertEqual((values['nw_svc_votes'], values['nw_votes']), (50, 150))      # broken / unknown: default

    def test_settings_xml_offers_the_same_choices(self):
        xml = read('resources', 'settings.xml')
        for key, (setting, label, choices, default) in settings.SETTINGS.items():
            line = re.search(r'<setting [^>]*id="{}"[^>]*/>'.format(setting), xml)
            self.assertTrue(line, setting)
            line = line.group(0)
            self.assertIn('label="{}"'.format(label), line)
            if key == 'origin':
                self.assertIn('default="{}"'.format(choices.index(default)), line)
                continue
            listed = re.search(r'values="([^"]*)"', line).group(1).split('|')
            self.assertEqual([type(default)(float(v)) for v in listed], list(choices), setting)
            self.assertEqual(type(default)(float(re.search(r'default="([^"]*)"', line).group(1))), default)
        for lang in ('cs_cz', 'sk_sk', 'en_gb'):
            po = read('resources', 'language', 'resource.language.' + lang, 'strings.po')
            for number in (35635, 35636, 35637, 35638, 35639, 35621, 35625):
                self.assertIn('msgctxt "#{}"'.format(number), po, (lang, number))


class GenreOverrideTest(unittest.TestCase):
    """The genre page starts from the global setting; a change there is its own and never the global one."""

    def test_base_and_own_values(self):
        base = dict(VALUES, west_votes=20)
        values = options.values('gn_list', '', base)
        self.assertEqual(values['west_votes'], 20)                                     # follows the global setting
        self.assertEqual(options.encode('gn_list', values, base), '')                  # nothing of its own stored
        own = options.encode('gn_list', dict(values, west_votes=50), base)
        self.assertEqual(own, 'west_votes=50')
        self.assertEqual(options.values('gn_list', own, base)['west_votes'], 50)
        self.assertEqual(options.changed('gn_list', own), {'west_votes'})
        # choosing the global value again drops the page's own one
        self.assertEqual(options.encode('gn_list', dict(values, west_votes=20), base), '')
        self.assertEqual(options.values('gn_list', own, dict(base, west_votes=5))['west_votes'], 50)


class ListsTest(unittest.TestCase):
    def setUp(self):
        library.set_path(os.path.join(tempfile.mkdtemp(prefix='milionar-q-'), 'library.db'))

    def test_keep_uses_cached_services(self):
        nobody = title(id=7, vote_count=0, vote_average=0)
        store.store('movie', 7, {'flatrate': [{'provider_id': 8, 'provider_name': 'Netflix', 'logo_path': '/n.png'}]})
        rows = [title(id=1), nobody, title(id=9, vote_count=1, vote_average=10.0)]
        self.assertEqual([r['id'] for r in lists.keep(rows, 'movie', VALUES)], [1, 7])

    def test_search_shows_everything_the_good_first(self):
        rows = [dict(title(id=1, vote_count=0), media_type='movie'), {'id': 2, 'media_type': 'person', 'name': 'X'},
                dict(title(id=3), media_type='tv'), dict(title(id=4, poster_path=None), media_type='movie')]
        self.assertEqual([r['id'] for r in lists.search_order(rows, values=VALUES)], [2, 3, 1, 4])


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