"""
Integration tests for the CoverageEngine orchestrator.

Tests model selection, available models API, and the
engine's coordination logic (without running actual
coverage calculations, which require terrain data).
"""

import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))

from app.core.engine import CoverageEngine, BandType, PresetType, CoverageSettings


class TestEngineModelSelection:
    def test_lte_urban_uses_cost231(self):
        engine = CoverageEngine()
        model = engine.select_model(BandType.LTE, "urban")
        assert model.name == "COST-231-Hata"

    def test_lte_suburban_uses_okumura(self):
        engine = CoverageEngine()
        model = engine.select_model(BandType.LTE, "suburban")
        assert model.name == "Okumura-Hata"

    def test_lte_open_uses_fspl(self):
        engine = CoverageEngine()
        model = engine.select_model(BandType.LTE, "open")
        assert model.name == "Free-Space"

    def test_uhf_urban_uses_okumura(self):
        engine = CoverageEngine()
        model = engine.select_model(BandType.UHF, "urban")
        assert model.name == "Okumura-Hata"

    def test_uhf_rural_uses_longley_rice(self):
        engine = CoverageEngine()
        model = engine.select_model(BandType.UHF, "rural")
        assert model.name == "Longley-Rice"

    def test_vhf_urban_uses_p1546(self):
        engine = CoverageEngine()
        model = engine.select_model(BandType.VHF, "urban")
        assert model.name == "ITU-R-P.1546"

    def test_vhf_rural_uses_longley_rice(self):
        engine = CoverageEngine()
        model = engine.select_model(BandType.VHF, "rural")
        assert model.name == "Longley-Rice"

    def test_unknown_band_falls_back(self):
        engine = CoverageEngine()
        model = engine.select_model(BandType.CUSTOM, "desert")
        assert model is not None  # Should not crash


class TestEngineModelsAPI:
    def test_returns_dict(self):
        engine = CoverageEngine()
        models = engine.get_available_models()
        assert isinstance(models, dict)
        assert len(models) >= 5

    def test_model_info_structure(self):
        engine = CoverageEngine()
        models = engine.get_available_models()
        for name, info in models.items():
            assert "frequency_range" in info
            assert "distance_range" in info
            assert "bands" in info
            assert len(info["bands"]) > 0

    def test_all_expected_models_present(self):
        engine = CoverageEngine()
        models = engine.get_available_models()
        expected = {"COST-231-Hata", "Okumura-Hata", "Free-Space", "Longley-Rice", "ITU-R-P.1546"}
        assert expected.issubset(set(models.keys()))


class TestCoverageSettings:
    def test_default_settings(self):
        s = CoverageSettings()
        assert s.radius == 10000
        assert s.resolution == 200
        assert s.preset == PresetType.STANDARD
        assert s.band_type == BandType.LTE

    def test_preset_values(self):
        assert PresetType.FAST.value == "fast"
        assert PresetType.STANDARD.value == "standard"
        assert PresetType.DETAILED.value == "detailed"
        assert PresetType.FULL.value == "full"

    def test_band_type_values(self):
        assert BandType.LTE.value == "lte"
        assert BandType.UHF.value == "uhf"
        assert BandType.VHF.value == "vhf"


if __name__ == "__main__":
    for cls_name, cls in [
        ("ModelSelection", TestEngineModelSelection),
        ("ModelsAPI", TestEngineModelsAPI),
        ("CoverageSettings", TestCoverageSettings),
    ]:
        instance = cls()
        for method_name in [m for m in dir(instance) if m.startswith("test_")]:
            try:
                getattr(instance, method_name)()
                print(f"  PASS  {cls_name}.{method_name}")
            except Exception as e:
                print(f"  FAIL  {cls_name}.{method_name}: {e}")
    print("\nAll tests completed.")