"""Offline checks of Všechny moje seriály / filmy (Standa 2026-11-09): the row joins Moje seriály / Moje filmy once
before the section's actions, and grows by ten cards when the cursor nears its end (wcs/skin/paging.py)."""
from pathlib import Path
import sys
import unittest
from unittest.mock import patch

HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
import stubs
stubs.install()
import xbmc
import xbmcgui
from wcs.skin import journal, paging, slots
from wcs.library2 import rows


class SeriesAllRow(unittest.TestCase):
    def run_insert(self, shown):
        widgets = {n: {'type': row, 'limit': '20', 'sort': '', 'style': '', 'uid': row} for n, row in enumerate(shown, 1)}
        blank = {'type': '', 'limit': '', 'sort': '', 'style': ''}

        def write(sec, rows_, hw, up):
            widgets.clear()
            widgets.update({n: dict(w) for n, w in enumerate(rows_, 1)})
            return True

        with patch.object(slots, 'current', side_effect=lambda sec, n: dict(widgets.get(n, blank))), \
                patch.object(slots, '_write_section', side_effect=write), \
                patch.object(slots, 'reload_skin') as reload, patch('xbmc.executebuiltin') as execute:
            slots.add_series_all_row()
            first = [dict(widgets[n]) for n in sorted(widgets)]
            slots.add_series_all_row()
        self.assertEqual([w['type'] for w in first], [widgets[n]['type'] for n in sorted(widgets)], 'a second run moves nothing')
        execute.assert_any_call('Skin.SetBool(MilionarSeriesAllV1)', True)
        return first, reload.call_count

    def test_the_row_goes_before_the_actions_once(self):
        first, reloads = self.run_insert(['my_series_next', 'my_series_added', 'home_series_actions'])
        self.assertEqual([w['type'] for w in first], ['my_series_next', 'my_series_added', 'my_series_all', 'home_series_actions'])
        added = first[2]
        self.assertEqual((added['limit'], added['sort'], added['style'], added['click']), ('10', 'activity', 'poster', 'hero'))
        self.assertEqual(reloads, 1, 'only the run that moved rows reloads the skin')

    def test_a_section_without_actions_gets_it_at_the_end_and_one_that_has_it_keeps_it(self):
        first, _ = self.run_insert(['my_series_added'])
        self.assertEqual([w['type'] for w in first], ['my_series_added', 'my_series_all'])
        first, reloads = self.run_insert(['my_series_all', 'my_series_next', 'home_series_actions'])
        self.assertEqual([w['type'] for w in first], ['my_series_all', 'my_series_next', 'home_series_actions'])
        self.assertEqual(reloads, 0)

    def test_new_installs_have_it_in_their_defaults(self):
        self.assertEqual(slots.default_for('my_series_all', 'my_series'), ('my_series_all', '10', 'activity', 'poster'))
        types = [w[0] for w in slots.SECTIONS['my_series'][2]]
        self.assertEqual(types.index('my_series_all') + 1, types.index('home_series_actions'))


class MoviesAllRow(unittest.TestCase):
    def test_the_films_row_goes_before_the_actions_once(self):
        widgets = {n: {'type': row, 'limit': '20', 'sort': '', 'style': '', 'uid': row}
                   for n, row in enumerate(['my_movies_progress', 'my_movies_added', 'home_movies_actions'], 1)}
        blank = {'type': '', 'limit': '', 'sort': '', 'style': ''}

        def write(sec, rows_, hw, up):
            self.assertEqual(sec, 'my_movies')
            widgets.clear()
            widgets.update({n: dict(w) for n, w in enumerate(rows_, 1)})
            return True

        with patch.object(slots, 'current', side_effect=lambda sec, n: dict(widgets.get(n, blank))), \
                patch.object(slots, '_write_section', side_effect=write), \
                patch.object(slots, 'reload_skin') as reload, patch('xbmc.executebuiltin') as execute:
            slots.add_movies_all_row()
            slots.add_movies_all_row()
        self.assertEqual([widgets[n]['type'] for n in sorted(widgets)],
                         ['my_movies_progress', 'my_movies_added', 'my_movies_all', 'home_movies_actions'])
        self.assertEqual((widgets[3]['limit'], widgets[3]['sort'], widgets[3]['click']), ('10', 'activity', 'hero'))
        execute.assert_any_call('Skin.SetBool(MilionarMoviesAllV1)', True)
        self.assertEqual(reload.call_count, 1)
        self.assertEqual(slots.default_for('my_movies_all', 'my_movies'), ('my_movies_all', '10', 'activity', 'poster'))
        self.assertIn('my_movies_all', paging.PAGED)


class Paging(unittest.TestCase):
    LID = '30300'                                      # Moje seriály, slot 3

    def setUp(self):
        xbmcgui.Window.props.clear()
        paging._slots.clear()
        paging._asked.clear()
        self.labels = {'Skin.String(mil.my_series.3.type)': 'my_series_all', 'Skin.String(mil.my_series.3.limit)': '10',
                       'Container(30300).NumItems': '10', 'Container(30300).CurrentItem': '1'}
        xbmcgui.Window(10000).setProperty('milionar.row.my_series', self.LID)
        self.addCleanup(patch.stopall)
        patch('xbmc.getInfoLabel', side_effect=lambda label: self.labels.get(label, '')).start()
        patch('xbmc.getCondVisibility', return_value=False).start()
        self.request = patch.object(journal, 'request').start()

    def tick(self, position=None, count=None):
        if position is not None:
            self.labels['Container(30300).CurrentItem'] = str(position)
        if count is not None:
            self.labels['Container(30300).NumItems'] = str(count)
        paging.tick('my_series')

    def test_the_row_grows_by_ten_near_its_end_and_only_once_per_size(self):
        self.tick(5)
        self.request.assert_not_called()
        self.tick(7)                                   # three cards before the end
        self.request.assert_called_once_with([('my_series', 3)])
        self.assertEqual(paging.more('my_series', 3), 10)
        self.tick(8)
        self.assertEqual(self.request.call_count, 1, 'the same size is asked for once')
        self.tick(17, 20)                              # the rebuilt row holds 20 cards
        self.assertEqual(paging.more('my_series', 3), 20)
        self.assertEqual(self.request.call_count, 2)

    def test_a_row_that_holds_every_card_never_grows(self):
        xbmcgui.Window(10000).setProperty('milionar.rowmore.my_series.3', '10')
        self.tick(17, 18)                              # limit 10 + 10 more asked, 18 came: there are no more
        self.request.assert_not_called()

    def test_other_rows_and_a_full_skin_list_are_left_alone(self):
        self.labels['Skin.String(mil.my_series.3.type)'] = 'my_series_added'
        self.tick(9)
        self.request.assert_not_called()
        paging._slots.clear()
        self.labels['Skin.String(mil.my_series.3.type)'] = 'my_series_all'
        self.tick(98, 99)                              # the skin's lists show 99 cards at most
        self.request.assert_not_called()

    def test_the_extra_cards_reach_the_build(self):
        xbmcgui.Window(10000).setProperty('milionar.rowmore.my_series.3', '20')
        params = journal.request_params('my_series', 3)
        self.assertEqual(params['more'], '20')
        self.assertEqual(params['limit'], '10')
        self.assertEqual(rows._more(params), 20)
        xbmcgui.Window(10000).clearProperty('milionar.rowmore.my_series.3')
        self.assertNotIn('more', journal.request_params('my_series', 3))


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