# Main script
import importlib
import logging
import signal
import sys

from diskcache import Cache

from core.cleanup import CleanupTimer
from core.config import config, WEB_SERVER_PORT
from core.status_reporter import StatusReporter
from core.utils import QRZ_CALLSIGN_DATA_CACHE
from server.webserver import WebServer

# Globals
spots = Cache('.spots_cache')
alerts = Cache('.alerts_cache')
status_data = {}
spot_providers = []
alert_providers = []
cleanup_timer = None


# Shutdown function
def shutdown(sig, frame):
    logging.info("Stopping program, this may take a few seconds...")
    for p in spot_providers:
        if p.enabled:
            p.stop()
    for p in alert_providers:
        if p.enabled:
            p.stop()
    cleanup_timer.stop()
    QRZ_CALLSIGN_DATA_CACHE.close()
    spots.close()


# Utility method to get a spot provider based on the class specified in its config entry.
def get_spot_provider_from_config(config_providers_entry):
    module = importlib.import_module('spotproviders.' + config_providers_entry["class"].lower())
    provider_class = getattr(module, config_providers_entry["class"])
    return provider_class(config_providers_entry)


# Utility method to get an alert provider based on the class specified in its config entry.
def get_alert_provider_from_config(config_providers_entry):
    module = importlib.import_module('alertproviders.' + config_providers_entry["class"].lower())
    provider_class = getattr(module, config_providers_entry["class"])
    return provider_class(config_providers_entry)


# Main function
if __name__ == '__main__':
    # Set up logging
    root = logging.getLogger()
    root.setLevel(logging.INFO)
    handler = logging.StreamHandler(sys.stdout)
    handler.setLevel(logging.INFO)
    formatter = logging.Formatter("%(message)s")
    handler.setFormatter(formatter)
    root.addHandler(handler)

    logging.info("Starting...")

    # Shut down gracefully on SIGINT
    signal.signal(signal.SIGINT, shutdown)

    # Fetch, set up and start spot providers
    for entry in config["spot-providers"]:
        spot_providers.append(get_spot_provider_from_config(entry))
    for p in spot_providers:
        p.setup(spots=spots)
        if p.enabled:
            p.start()

    # Fetch, set up and start alert providers
    for entry in config["alert-providers"]:
        alert_providers.append(get_alert_provider_from_config(entry))
    for p in alert_providers:
        p.setup(alerts=alerts)
        if p.enabled:
            p.start()

    # Set up timer to clear spot list of old data
    cleanup_timer = CleanupTimer(spots=spots, cleanup_interval=60)
    cleanup_timer.start()

    # Set up web server
    web_server = WebServer(spots=spots, status_data=status_data, port=WEB_SERVER_PORT)
    web_server.start()

    # Set up status reporter
    status_reporter = StatusReporter(status_data=status_data, spots=spots, alerts=alerts, web_server=web_server,
                                     cleanup_timer=cleanup_timer, spot_providers=spot_providers,
                                     alert_providers=alert_providers, run_interval=5)
    status_reporter.start()

    logging.info("Startup complete.")