#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Run the downloadable toolkit's offline checks: python3 verify.py.

Uses temporary synthetic decoder snapshots. No account, radio, installation,
network connection or third-party Python packages are required.
"""
import importlib.util
import json
from pathlib import Path
import subprocess
import sys
import tempfile
import time
import unittest

CLIENT = Path(__file__).with_name('skylark_feed.py')
spec = importlib.util.spec_from_file_location('skylark_feed', CLIENT)
feed = importlib.util.module_from_spec(spec)
spec.loader.exec_module(feed)


class ToolkitChecks(unittest.TestCase):
    def row(self, **changes):
        return dict({'hex': '4ca123', 'type': 'adsb_icao', 'lat': 53.4,
                     'lon': -6.2, 'seen_pos': 1, 'alt_baro': 3000}, **changes)

    def test_direct_positions_and_enrichment_boundary(self):
        rows = [self.row(r='EI-TEST', desc='local enrichment'),
                self.row(type='mlat'), self.row(mlat=['lat']),
                self.row(type='tisb_icao'), self.row(tisb=['lon']),
                self.row(seen_pos=46)]
        batch = feed.make_batch({'now': 1000, 'aircraft': rows}, now=1000)
        self.assertEqual(len(batch['aircraft']), 1)
        self.assertNotIn('r', batch['aircraft'][0])
        self.assertNotIn('desc', batch['aircraft'][0])

    def test_stale_snapshot_stays_stale(self):
        with self.assertRaises(feed.FeedError):
            feed.make_batch({'now': 900, 'aircraft': [self.row()]}, now=1000)

    def test_redirects_are_refused(self):
        with self.assertRaises(feed.FeedError):
            feed.NoRedirect().redirect_request(None, None, 302, 'redirect', {},
                                                'https://example.org')

    def test_remote_decoder_is_refused(self):
        with self.assertRaises(feed.FeedError):
            feed.source_setting({'aircraftUrl': 'http://example.org/aircraft.json'})

    def test_lab_range_and_direct_only_snapshot(self):
        import receiver_lab
        distance, bearing = receiver_lab.geography(0, 0, 1, 0)
        self.assertAlmostEqual(distance, 60.04, places=1)
        self.assertEqual(bearing, 0)
        with tempfile.TemporaryDirectory() as directory:
            source = Path(directory) / 'aircraft.json'
            source.write_text(json.dumps({'now': 1000, 'aircraft': [self.row(), self.row(type='mlat')]}))
            lab = receiver_lab.LabState(str(source), 53.4, -6.2, lambda: 1000)
            lab.sample()
            answer = lab.snapshot()
            self.assertEqual(answer['decoder']['state'], 'ready')
            self.assertEqual(len(answer['contacts']), 1)
            self.assertEqual(answer['summary']['localMlatAircraft'], 1)

    def test_local_check_needs_no_credentials_and_sends_nothing(self):
        with tempfile.TemporaryDirectory() as directory:
            snapshot = Path(directory) / 'aircraft.json'
            snapshot.write_text(json.dumps({'now': time.time(), 'aircraft': [self.row()]}))
            result = subprocess.run([sys.executable, str(CLIENT), '--check', '--source',
                                     str(snapshot), '--config', str(Path(directory) / 'absent.json')],
                                    capture_output=True, text=True, timeout=10, check=False)
            self.assertEqual(result.returncode, 0, result.stderr)
            answer = json.loads(result.stdout)
            self.assertEqual(answer['directPositions'], 1)
            self.assertIs(answer['transmitted'], False)


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