import asyncio
import logging
import socket
from datetime import datetime
from app import bot, dp, cfg, ADMIN_ID, ADMIN_IDS
from keyboards import menu_kb
from services.docker import discover_containers, docker_watchdog
from services.alerts import monitor_resources, monitor_smart
from services.metrics import MetricsStore, start_sampler
from services.queue import worker as queue_worker
from services.notify import notify
from services.audit import AuditMiddleware, audit_start
from services.ssl_alerts import monitor_ssl
from services.external_checks import monitor_external
from services.incidents import log_incident
from services.logging_setup import setup_logging
from services.selftest import schedule_selftest
import state
import handlers.menu
import handlers.status
import handlers.docker
import handlers.backup
import handlers.artifacts
import handlers.system
import handlers.help
import handlers.callbacks
import handlers.arcane
import handlers.processes
from services.weekly_report import weekly_reporter
import handlers.alerts_admin
import handlers.config_check


def _handle_async_exception(_loop, context):
    msg = context.get("message") or "Unhandled exception"
    exc = context.get("exception")
    if exc:
        text = f"❌ {msg}: {type(exc).__name__}: {exc}"
    else:
        text = f"❌ {msg}"
    try:
        log_incident(cfg, text, category="system")
    except Exception:
        pass
    logging.getLogger("asyncio").error(text)


async def notify_start():
    await bot.send_message(
        ADMIN_ID,
        f"🤖 Bot started\n🖥 {socket.gethostname()}\n🕒 {datetime.now():%Y-%m-%d %H:%M}",
        reply_markup=menu_kb,
    )


async def main():
    setup_logging(cfg)
    dp.message.middleware(AuditMiddleware(cfg))
    dp.callback_query.middleware(AuditMiddleware(cfg))
    audit_start(cfg)
    state.DOCKER_MAP.clear()
    state.DOCKER_MAP.update(await discover_containers(cfg))
    if cfg.get("docker", {}).get("watchdog", True):
        asyncio.create_task(docker_watchdog(state.DOCKER_MAP, notify, bot, ADMIN_ID))
    if cfg.get("alerts", {}).get("enabled", True):
        asyncio.create_task(monitor_resources(cfg, notify, bot, ADMIN_ID))
    if cfg.get("alerts", {}).get("smart_enabled", True):
        asyncio.create_task(monitor_smart(cfg, notify, bot, ADMIN_ID))
    if cfg.get("npmplus", {}).get("alerts", {}).get("enabled", True):
        asyncio.create_task(monitor_ssl(cfg, notify, bot, ADMIN_ID))
    if cfg.get("external_checks", {}).get("enabled", True):
        asyncio.create_task(monitor_external(cfg))
    state.METRICS_STORE = MetricsStore()
    asyncio.create_task(start_sampler(state.METRICS_STORE, interval=5))
    asyncio.create_task(queue_worker())
    asyncio.create_task(weekly_reporter(cfg, bot, ADMIN_IDS, state.DOCKER_MAP))
    asyncio.create_task(schedule_selftest(cfg, bot, ADMIN_IDS, state.DOCKER_MAP))
    loop = asyncio.get_running_loop()
    loop.set_exception_handler(_handle_async_exception)
    await notify_start()
    await dp.start_polling(bot)


if __name__ == "__main__":
    asyncio.run(main())