import asyncio
import signal
from core.encryption import decrypt_string
from core.logging import get_logger, setup_logging
from core.config import get_settings
from infrastructure.database.session import get_db_session
from infrastructure.telegram.service import TelegramApiService
from infrastructure.telegram.webhook import get_bot_webhook_url, generate_webhook_secret, hash_webhook_secret
from modules.bots.repository import BotRepository

logger = get_logger(__name__)


class TelegramEngineSupervisor:
    """
    Supervises and recovers Telegram multi-bot webhooks across all active tenants.
    Verifies that registered webhooks remain active and healthy on Telegram servers.
    """

    def __init__(self):
        self._running = False

    async def synchronize_active_bots(self) -> dict[str, int]:
        """
        Reconciles active bots in the database with Telegram servers.
        Repairs missing or broken webhooks automatically.
        """
        stats = {"verified": 0, "repaired": 0, "failed": 0}

        async with get_db_session() as db:
            repo = BotRepository(db)
            active_bots = await repo.list_all(limit=1000)

            for bot in active_bots:
                if bot.status != "active":
                    continue

                creds = await repo.get_credentials(bot.id)
                if not creds:
                    continue

                try:
                    raw_token = decrypt_string(creds.encrypted_token, creds.key_version)
                    webhook_info = await TelegramApiService.get_webhook_info(raw_token)
                    expected_url = get_bot_webhook_url(bot.id)

                    current_url = webhook_info.get("url", "")
                    if current_url != expected_url:
                        logger.info("re-registering_bot_webhook", bot_id=str(bot.id), username=bot.username)
                        secret_token = generate_webhook_secret()
                        secret_hash = hash_webhook_secret(secret_token)

                        success = await TelegramApiService.set_webhook(
                            raw_token=raw_token,
                            webhook_url=expected_url,
                            secret_token=secret_token,
                        )
                        if success:
                            await repo.update_webhook_status(bot.id, is_active=True, secret_hash=secret_hash)
                            stats["repaired"] += 1
                        else:
                            stats["failed"] += 1
                    else:
                        stats["verified"] += 1
                except Exception as exc:
                    logger.warning("webhook_sync_failed_for_bot", bot_id=str(bot.id), error=str(exc))
                    stats["failed"] += 1

            await db.commit()

        logger.info("telegram_webhooks_synchronized", **stats)
        return stats

    async def start(self):
        self._running = True
        settings = get_settings()
        setup_logging(settings.APP_DEBUG)
        logger.info("telegram_engine_supervisor_started", env=settings.APP_ENV)

        # Initial restart recovery sync
        try:
            await self.synchronize_active_bots()
        except Exception as exc:
            logger.error("initial_bot_sync_error", error=str(exc))

        # Periodic health check loop (every 10 minutes)
        while self._running:
            try:
                await asyncio.sleep(600)
                if self._running:
                    await self.synchronize_active_bots()
            except asyncio.CancelledError:
                break
            except Exception as exc:
                logger.error("periodic_sync_error", error=str(exc))

        logger.info("telegram_engine_supervisor_stopped")

    def stop(self):
        self._running = False


supervisor = TelegramEngineSupervisor()


def _handle_exit(sig, frame):
    logger.info("shutdown_signal_received", signal=sig)
    supervisor.stop()


async def main():
    loop = asyncio.get_running_loop()
    for sig in (signal.SIGINT, signal.SIGTERM):
        try:
            loop.add_signal_handler(sig, supervisor.stop)
        except NotImplementedError:
            pass

    await supervisor.start()


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