"""MCP account playback: real adapter methods, stubbed Kodi APIs; no account or live media writes."""
import json
import os
import sys
import unittest
from unittest import mock
from types import SimpleNamespace
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import kodi_stubs
kodi_stubs.install()
import xbmc
import xbmcgui
xbmc.Player = mock.Mock
from wcs.playback.remote import kodi, launch, tracker_bridge


class RemotePlaybackTests(unittest.TestCase):
    def setUp(self):
        self.calls = []
        self.player = SimpleNamespace(getTime=lambda: 120, getTotalTime=lambda: 600, seekTime=mock.Mock())
        self.home = kodi_stubs.Window(10000)
        self.patches = [mock.patch.object(xbmcgui, 'Window', return_value=self.home), mock.patch.object(xbmc, 'executeJSONRPC', side_effect=self.rpc),
                        mock.patch.object(xbmc, 'Player', return_value=self.player)]
        for patch in self.patches:
            patch.start()
        self.addCleanup(mock.patch.stopall)
        self.np = {'token': 'private-canonical-token', 'type': 'episode', 'tmdb': 1396, 's': 2, 'e': 3,
                   'title': 'Episode', 'show_title': 'Series', 'stream_url': 'private-link', 'remote_id': 'operation'}
        tracker_bridge.publish(self.np)

    def rpc(self, raw):
        request = json.loads(raw)
        self.calls.append(request)
        method = request['method']
        if method == 'Player.GetActivePlayers':
            value = [{'playerid': 1, 'type': 'video'}]
        elif method == 'Application.GetProperties':
            value = {'volume': 75, 'muted': False}
        elif method == 'Player.GetProperties':
            value = {'speed': 1, 'audiostreams': [{'index': 0, 'language': 'eng'}, {'index': 1, 'language': 'cze'}],
                     'currentaudiostream': {'index': 0}, 'subtitles': [{'index': 2, 'language': 'cze'}],
                     'currentsubtitle': {'index': 2}, 'subtitleenabled': False}
        else:
            value = 'OK'
        return json.dumps({'result': value})

    def test_snapshot_is_actual_and_contains_no_source(self):
        state = kodi.snapshot()
        self.assertEqual((state['position'], state['duration'], state['state']), (120, 600, 'playing'))
        self.assertEqual(state['media']['tmdbId'], 1396)
        self.assertEqual(state['subtitle'], None)
        self.assertNotIn('private', json.dumps(state))
        self.assertNotIn('remoteId', state)

    def test_pause_resume_are_desired_state_never_toggle(self):
        kodi.control({'action': 'pause'})
        kodi.control({'action': 'pause'})
        kodi.control({'action': 'resume'})
        calls = [c['params']['play'] for c in self.calls if c['method'] == 'Player.PlayPause']
        self.assertEqual(calls, [False, False, True])

    def test_percent_absolute_relative_seeks_use_actual_duration(self):
        for position, expected in [({'percent': 50}, 300), ({'offset': -60}, 60), ({'seconds': 90}, 90)]:
            kodi.control({'action': 'seek', 'position': position})
            self.player.seekTime.assert_called_with(expected)

    def test_volume_mute_audio_and_subtitle_commands(self):
        for command in [{'action': 'volume', 'level': 35}, {'action': 'mute', 'muted': True},
                        {'action': 'audio', 'track': {'language': 'cs'}},
                        {'action': 'subtitles', 'track': {'enabled': False}},
                        {'action': 'subtitles', 'track': {'language': 'cs'}}]:
            kodi.control(command)
        calls = {c['method']: c['params'] for c in self.calls}
        self.assertEqual(calls['Player.SetAudioStream']['stream'], 1)
        self.assertEqual(calls['Player.SetSubtitle']['subtitle'], 2)
        self.assertTrue(calls['Application.SetMute']['mute'])
        with self.assertRaisesRegex(RuntimeError, 'track_unavailable'):
            kodi.control({'action': 'audio', 'track': {'index': 55}})

    def test_initial_percentage_seek_disables_resume_safety_and_is_once(self):
        np = dict(self.np, remote_position={'percent': 50})
        tracker_bridge.publish(np)
        session = SimpleNamespace(np=np, safety_checked=False)
        tracker_bridge.position(session, self.player)
        tracker_bridge.position(session, self.player)
        self.player.seekTime.assert_called_once_with(300)
        self.assertTrue(session.safety_checked)
        self.assertTrue(tracker_bridge.read()['positionReady'])
        tracker_bridge.finish(np)
        self.assertEqual(tracker_bridge.read(), {})
        self.assertTrue(tracker_bridge.read(tracker_bridge.FINISHED)['sessionId'])

    def test_launch_is_fixed_plugin_action_and_cancelled_payload_cannot_run(self):
        token = launch.ask({'action': 'play', 'mediaType': 'movie', 'tmdbId': 603}, 'request', 9999999999999)
        self.assertIn('action=remote_playback&token=' + token, kodi_stubs.BUILTINS[-1])
        self.assertNotIn('PlayMedia', kodi_stubs.BUILTINS[-1])
        launch.cancel(token)
        with mock.patch.object(launch, '_prepare') as prepare:
            launch.run(token)
            prepare.assert_not_called()


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