main.py

from __future__ import annotations

import asyncio
import logging

from aprs import AGWPEAdapter, AGWPEServerAdapter, APRSISServerAdapter
from config import (
    DemoConfig,
    load_config,
    persist_agwpe_config,
    persist_agwpe_server_config,
    persist_aprs_is_server_config,
    persist_cot_config,
    persist_mesh_adapter_config,
    persist_sartrack_aprs_config,
    persist_sartrack_config,
)
from core.dedup import DedupCache
from core.model import MessageEvent, PositionEvent, Source
from core.router import EventRouter
from core.state import StateStore
from cot import CoTAdapter
from gui import ConnectionControl, GuiServer
from mesh import MeshtasticAdapter
from sartrack import SARTrackAPRSServerClient, SARTrackTCPServer
from utils.logger import setup_logging


async def send_test_event(router: EventRouter, event: PositionEvent | MessageEvent) -> None:
    await router.publish(event)


async def demo_inject(router: EventRouter, aprs: AGWPEAdapter, config: DemoConfig) -> None:
    """Prosty test lokalny dla routingu do Meshtastic."""
    if not config.demo_enabled:
        logging.getLogger("main").debug("Demo inject disabled")
        return

    await asyncio.sleep(config.demo_delay_seconds)

    if not aprs.is_connected():
        logging.getLogger("main").warning(
            "Skipping demo inject because AGWPE is not connected after %.1f seconds",
            config.demo_delay_seconds,
        )
        return

    position = PositionEvent(
        id=config.demo_callsign,
        lat=config.demo_lat,
        lon=config.demo_lon,
        message=config.demo_position_message,
        source=Source.SARTRACK,
    )
    await router.publish(position)

    message = MessageEvent(
        id=config.demo_callsign,
        message=config.demo_text_message,
        target=config.demo_message_target,
        source=Source.SARTRACK,
    )
    await router.publish(message)

    logging.getLogger("main").info("Demo inject sent once")


async def main() -> None:
    app_config = load_config()
    state_store = StateStore()
    setup_logging(
        level=app_config.log_level,
        state_store=state_store,
        disabled_logger_prefixes=app_config.disabled_logger_prefixes,
        disabled_logger_names=app_config.disabled_logger_names,
    )
    log = logging.getLogger("main")
    aprs = AGWPEAdapter(app_config.agwpe)
    agwpe_server = AGWPEServerAdapter(app_config.agwpe_server)
    aprs_is_server = APRSISServerAdapter(app_config.aprs_is_server)
    mesh_adapters = []
    for mesh_config in app_config.mesh_adapters:
        mesh_config.callsign_aliases = dict(app_config.mesh_callsign_aliases)
        mesh_adapters.append(MeshtasticAdapter(mesh_config))
    cot = CoTAdapter(app_config.cot)
    sartrack = SARTrackTCPServer(app_config.sartrack)
    sartrack_aprs = SARTrackAPRSServerClient(app_config.sartrack_aprs)

    async def update_agwpe(payload: dict[str, object]) -> dict[str, object]:
        updated = await aprs.apply_runtime_config(payload)
        persist_agwpe_config(aprs.config)
        log.info("Persisted AGWPE config to config.py")
        return updated

    async def update_sartrack(payload: dict[str, object]) -> dict[str, object]:
        updated = await sartrack.apply_runtime_config(payload)
        persist_sartrack_config(sartrack.config)
        log.info("Persisted SARTrack TCP config to config.py")
        return updated

    async def update_sartrack_aprs(payload: dict[str, object]) -> dict[str, object]:
        updated = await sartrack_aprs.apply_runtime_config(payload)
        persist_sartrack_aprs_config(sartrack_aprs.config)
        log.info("Persisted SARTrack APRS config to config.py")
        return updated

    async def update_agwpe_server(payload: dict[str, object]) -> dict[str, object]:
        updated = await agwpe_server.apply_runtime_config(payload)
        persist_agwpe_server_config(agwpe_server.config)
        log.info("Persisted AGWPE server config to config.py")
        return updated

    async def update_aprs_is_server(payload: dict[str, object]) -> dict[str, object]:
        updated = await aprs_is_server.apply_runtime_config(payload)
        persist_aprs_is_server_config(aprs_is_server.config)
        log.info("Persisted APRS-IS server config to config.py")
        return updated

    async def update_cot(payload: dict[str, object]) -> dict[str, object]:
        updated = await cot.apply_runtime_config(payload)
        persist_cot_config(cot.config)
        log.info("Persisted CoT config to config.py")
        return updated

    connection_controls = {
        "agwpe": ConnectionControl(
            name="agwpe",
            get_config=aprs.get_runtime_config,
            update_config=update_agwpe,
            reconnect=aprs.reconnect_now,
            editable_fields=(
                "enabled",
                "host",
                "port",
                "channel",
                "rx_monitor_enabled",
                "tx_callsign",
                "tx_destination",
                "tx_path",
            ),
        ),
        "sartrack_tcp": ConnectionControl(
            name="sartrack_tcp",
            get_config=sartrack.get_runtime_config,
            update_config=update_sartrack,
            reconnect=sartrack.reconnect_now,
            editable_fields=("enabled", "host", "port"),
        ),
        "sartrack_aprs": ConnectionControl(
            name="sartrack_aprs",
            get_config=sartrack_aprs.get_runtime_config,
            update_config=update_sartrack_aprs,
            reconnect=sartrack_aprs.reconnect_now,
            editable_fields=("enabled", "host", "port", "reconnect_delay"),
        ),
        "agwpe_server": ConnectionControl(
            name="agwpe_server",
            get_config=agwpe_server.get_runtime_config,
            update_config=update_agwpe_server,
            reconnect=agwpe_server.reconnect_now,
            editable_fields=(
                "enabled",
                "host",
                "port",
                "channel",
                "rx_monitor_enabled",
                "tx_callsign",
                "tx_destination",
                "tx_path",
            ),
        ),
        "aprs_is_server": ConnectionControl(
            name="aprs_is_server",
            get_config=aprs_is_server.get_runtime_config,
            update_config=update_aprs_is_server,
            reconnect=aprs_is_server.reconnect_now,
            editable_fields=("enabled", "host", "port", "server_name"),
        ),
        "cot": ConnectionControl(
            name="cot",
            get_config=cot.get_runtime_config,
            update_config=update_cot,
            reconnect=cot.reconnect_now,
            editable_fields=("enabled", "cot_url", "rx_enabled", "listen_url", "chat_listen_url", "pytak_no_hello", "tak_proto", "stale_seconds"),
        ),
    }
    for mesh_adapter in mesh_adapters:
        async def update_mesh(payload: dict[str, object], adapter: MeshtasticAdapter = mesh_adapter) -> dict[str, object]:
            updated = await adapter.apply_runtime_config(payload)
            persist_mesh_adapter_config(adapter.config)
            log.info("Persisted Meshtastic config to config.py for %s", adapter.config.name)
            return updated

        connection_controls[mesh_adapter.config.name] = ConnectionControl(
            name=mesh_adapter.config.name,
            get_config=mesh_adapter.get_runtime_config,
            update_config=update_mesh,
            reconnect=mesh_adapter.reconnect_now,
            editable_fields=(
                "enabled",
                "host",
                "port",
                "destination_id",
                "aprs_channel_index",
                "transport_mode",
                "position_transport_mode",
                "tak_rx_enabled",
                "tak_tx_enabled",
                "tak_detail_enabled",
                "tak_detail_compress",
                "tak_detail_compress_threshold",
            ),
        )
    gui = GuiServer(
        app_config.gui,
        state_store=state_store,
        send_event=lambda event: send_test_event(router, event),
        connection_controls=connection_controls,
    )
    demo = app_config.demo

    router = EventRouter(
        adapters=[aprs, agwpe_server, aprs_is_server, *mesh_adapters, cot],
        dedup=DedupCache(),
        state_store=state_store,
    )
    aprs.attach_state_store(state_store)
    agwpe_server.attach_state_store(state_store)
    aprs_is_server.attach_state_store(state_store)
    cot.attach_state_store(state_store)
    cot.attach_router(router)
    sartrack.attach_state_store(state_store)
    sartrack_aprs.attach_state_store(state_store)
    for mesh in mesh_adapters:
        mesh.attach_router(router)
        mesh.attach_state_store(state_store)

    await asyncio.gather(*(mesh.connect() for mesh in mesh_adapters))
    await cot.connect()
    await agwpe_server.start(router)
    await aprs_is_server.start(router)
    await sartrack.start(router)
    await gui.start()

    agwpe_task = asyncio.create_task(aprs.run(router))
    sartrack_aprs_task = asyncio.create_task(sartrack_aprs.run(router))
    demo_task = asyncio.create_task(demo_inject(router, aprs, demo))

    log.info(
        "Gateway started: SARTrack TCP + AGWPE client + AGWPE server + APRS-IS server + %s Meshtastic adapters + GUI=%s demo_enabled=%s delay=%ss",
        len(mesh_adapters),
        gui.config.enabled,
        demo.demo_enabled,
        demo.demo_delay_seconds,
    )

    await asyncio.gather(demo_task, agwpe_task, sartrack_aprs_task)


if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print("Stopped by user")