# -*- coding: utf-8 -*-
"""When the first-run guide is due and which steps it walks (docs/plan/onboarding/000-plan.md D27-D33)."""
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()
import xbmcaddon  # noqa: E402

from wcs.onboarding import plan, state  # noqa: E402

SETTINGS = {}


class Addon(xbmcaddon.Addon):
    def getSetting(self, key):
        return SETTINGS.get(key, '')

    def setSetting(self, key, value):
        SETTINGS[key] = value


xbmcaddon.Addon = Addon


def settings(**values):
    SETTINGS.clear()
    SETTINGS.update(values)
    from wcs.account import state as account_state
    account_state.invalidate()


class Due(unittest.TestCase):

    def test_new_install(self):
        settings()
        self.assertTrue(state.pending())
        self.assertEqual(state.step(), 'welcome')

    def test_existing_install_with_a_key_never_guided_gets_it(self):          # D27
        settings(tmdb_api_key='k')
        self.assertTrue(state.pending())
        self.assertEqual(state.step(), 'welcome')

    def test_finished_device(self):
        settings(tmdb_api_key='k', onboarding_step='done')
        self.assertFalse(state.pending())

    def test_finished_but_the_key_is_gone(self):                              # D4, D33
        settings(onboarding_step='done')
        self.assertTrue(state.pending())
        self.assertTrue(state.finished())

    def test_guide_under_way_resumes(self):                                   # D16
        settings(tmdb_api_key='k', onboarding_step='movies')
        self.assertTrue(state.pending())
        self.assertEqual(state.step(), 'movies')

    def test_account_without_a_guide_counts_as_finished(self):                # D28
        settings(tmdb_api_key='k', account_token='t')
        self.assertTrue(state.finished())
        self.assertFalse(state.pending())

    def test_account_whose_guide_is_open(self):                               # D28
        settings(tmdb_api_key='k', account_token='t', onboarding_step='genres')
        self.assertTrue(state.pending())
        self.assertEqual(state.step(), 'genres')

    def test_signed_out_device_without_own_guide(self):                       # D32: after a sign-out
        settings(onboarding_step='welcome')
        self.assertTrue(state.pending())

    def test_account_step_is_never_stored(self):
        settings()
        state.remember(Addon(), 'account')
        self.assertEqual(SETTINGS.get('onboarding_step', ''), '')
        state.remember(Addon(), 'tmdb')
        self.assertEqual(SETTINGS['onboarding_step'], 'tmdb')


class Path(unittest.TestCase):

    def test_new_install_without_account(self):
        steps = plan.path(False, set(), False)
        self.assertEqual(steps, ['welcome', 'tmdb', 'webshare', 'chatgpt', 'genres', 'movies', 'series'])   # D39
        self.assertEqual(plan.progress(steps, 'tmdb'), (2, 7))
        self.assertEqual(plan.following(steps, 'welcome'), 'tmdb')

    def test_account_chosen(self):                                            # D29
        steps = plan.path(True, set(), False)
        self.assertEqual(plan.progress(steps, 'account'), (2, 8))
        self.assertEqual(plan.following(steps, 'account'), 'tmdb')

    def test_back_never_returns_to_the_account_step(self):                    # D31
        steps = plan.path(True, set(), False)
        self.assertEqual(plan.previous(steps, 'account'), 'welcome')
        self.assertEqual(plan.previous(steps, 'tmdb'), 'welcome')
        self.assertIsNone(plan.previous(steps, 'welcome'))

    def test_signed_in_with_the_account_keys(self):                           # S12, D30
        steps = plan.path(False, {'tmdb', 'webshare'}, False)        # signed in: the account step is behind
        self.assertEqual(steps, ['welcome', 'chatgpt', 'genres', 'movies', 'series'])
        self.assertEqual(plan.following(steps, 'account'), 'chatgpt')
        self.assertEqual(plan.progress(steps, 'genres'), (3, 5))
        self.assertEqual(plan.previous(steps, 'genres'), 'chatgpt')
        self.assertEqual(plan.previous(steps, 'chatgpt'), 'welcome')
        self.assertEqual(plan.following(steps, 'welcome'), 'chatgpt')

    def test_existing_user_skips_what_is_set(self):                           # D30
        steps = plan.path(False, {'tmdb'}, False)
        self.assertEqual(steps, ['welcome', 'webshare', 'chatgpt', 'genres', 'movies', 'series'])
        self.assertEqual(plan.following(steps, 'welcome'), 'webshare')
        self.assertEqual(plan.following(steps, 'webshare'), 'chatgpt')
        self.assertEqual(plan.previous(steps, 'chatgpt'), 'webshare')

    def test_only_the_key_missing(self):                                      # D33
        steps = plan.path(False, set(), True)
        self.assertEqual(steps, ['welcome', 'tmdb'])
        self.assertIsNone(plan.following(steps, 'tmdb'))

    def test_a_step_that_dropped_out(self):
        steps = plan.path(False, {'webshare'}, False)              # Webshare got signed in meanwhile
        self.assertEqual(plan.following(steps, 'webshare'), 'chatgpt')
        self.assertEqual(plan.previous(steps, 'webshare'), 'tmdb')
        self.assertEqual(plan.progress(steps, 'webshare'), (3, 6))

    def test_a_stored_ai_step_moves_on(self):                                # D39: an older guide stopped on AI
        steps = plan.path(False, set(), False)
        self.assertEqual(plan.following(steps, 'ai'), 'chatgpt')
        self.assertEqual(plan.previous(steps, 'chatgpt'), 'webshare')
        self.assertEqual(plan.previous(steps, 'genres'), 'chatgpt')


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