import os
import shutil
import sys
import tempfile
import unittest

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'payload', 'user', 'remote_access', 'pager-webui'))
import server


def setUpModule():
    __import__('importlib').reload(server)


def ctx(body=None):
    return type('C', (), {'body': body, 'args': (), 'query': {}})()


class PineapModeTest(unittest.TestCase):
    def setUp(self):
        self.tmp = tempfile.mkdtemp(prefix='pager-mode-')
        self.old_state_file = server.PINEAP_STATE_FILE
        self.old_proxy = server._daemon_proxy
        self.old_sock = server.daemon_sock_call
        server.PINEAP_STATE_FILE = os.path.join(self.tmp, 'state.json')

    def tearDown(self):
        server.PINEAP_STATE_FILE = self.old_state_file
        server._daemon_proxy = self.old_proxy
        server.daemon_sock_call = self.old_sock
        shutil.rmtree(self.tmp)

    def test_passive_applies_mark_vii_supported_preset(self):
        calls = []
        server._daemon_proxy = lambda method, path, body=None, timeout=15: (
            calls.append((method, path, body)) or (200, {'success': True}))
        status, payload = server.h_pineap_mode_post(ctx({'mode': 'passive'}))
        self.assertEqual(status, 200)
        self.assertEqual([c[1] for c in calls], [
            'hostapd/enable_pineap', 'ssidpool/enable_collect',
            'ssidpool/disable'])
        self.assertEqual(calls[0][2], {'enable': False})
        self.assertEqual(payload['mode'], 'passive')
        self.assertTrue(payload['collect'])
        self.assertFalse(payload['advertise'])
        self.assertFalse(payload['karma'])
        self.assertFalse(payload['enabled'])

    def test_active_enables_response_engine_and_pool_broadcasting(self):
        calls = []
        server._daemon_proxy = lambda method, path, body=None, timeout=15: (
            calls.append((method, path, body)) or (200, {'success': True}))
        status, payload = server.h_pineap_mode_post(ctx({'mode': 'active'}))
        self.assertEqual(status, 200)
        self.assertEqual(calls[0], ('PUT', 'hostapd/enable_pineap', {'enable': True}))
        self.assertNotIn('mimic/disable', [c[1] for c in calls])
        self.assertEqual(calls[-1], ('POST', 'ssidpool/enable', {'enable': True}))
        self.assertEqual(payload['mode'], 'active')
        self.assertTrue(payload['advertise'])
        self.assertTrue(payload['karma'])
        self.assertTrue(payload['enabled'])

    def test_advanced_preserves_device_settings(self):
        calls = []
        server._daemon_proxy = lambda *args, **kwargs: (calls.append(args) or (200, {}))
        status, payload = server.h_pineap_mode_post(ctx({'mode': 'advanced'}))
        self.assertEqual(status, 200)
        self.assertEqual(calls, [])
        self.assertEqual(payload['mode'], 'advanced')

    def test_get_invalidates_preset_when_device_state_disagrees(self):
        server.update_pineap_state(mode='passive', collect=True, advertise=False)

        def fake(method, path, body=None, timeout=10):
            if path.endswith('/get_config') and 'hostapd' not in path:
                return 200, {'autossidpool': False}
            return 200, {'pineap_disabled': False}

        server.daemon_sock_call = fake
        status, payload = server.h_pineap_mode_get(ctx())
        self.assertEqual(status, 200)
        self.assertEqual(payload['mode'], 'advanced')
        self.assertFalse(payload['collect'])

    def test_get_keeps_passive_when_response_engine_is_disabled(self):
        server.update_pineap_state(mode='passive', enabled=False,
                                   collect=True, advertise=False)

        def fake(method, path, body=None, timeout=10):
            if 'hostapd' in path:
                return 200, {'pineap_disabled': True}
            return 200, {'autossidpool': True}

        server.daemon_sock_call = fake
        status, payload = server.h_pineap_mode_get(ctx())
        self.assertEqual(status, 200)
        self.assertEqual(payload['mode'], 'passive')
        self.assertFalse(payload['enabled'])

    def test_get_invalidates_active_when_response_engine_stops(self):
        server.update_pineap_state(mode='active', enabled=True,
                                   collect=True, advertise=True)

        def fake(method, path, body=None, timeout=10):
            if 'hostapd' in path:
                return 200, {'pineap_disabled': True}
            return 200, {'autossidpool': True}

        server.daemon_sock_call = fake
        status, payload = server.h_pineap_mode_get(ctx())
        self.assertEqual(status, 200)
        self.assertEqual(payload['mode'], 'advanced')
        self.assertFalse(payload['enabled'])

    def test_manual_mimic_change_marks_advanced(self):
        server.update_pineap_state(mode='passive', karma=False)
        server._daemon_proxy = lambda *args, **kwargs: (200, {'success': True})
        status, _ = server.h_pineap_mimic(ctx({'enable': True}))
        self.assertEqual(status, 200)
        state = server.load_pineap_state()
        self.assertEqual(state['mode'], 'advanced')
        self.assertTrue(state['karma'])


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