"""
Sync Worker Microservice - Main Entry Point

Dedicated service for processing MongoDB → PostgreSQL sync operations.
No HTTP server, just pure queue processing workers.
"""
import asyncio
import signal
from app.core.config import settings
from app.core.logging import setup_logging, get_logger, log_service_lifecycle
from app.sync.worker_manager import WorkerManager

# Setup logging
setup_logging(settings.LOG_LEVEL)
logger = get_logger(__name__)


class SyncWorkerService:
    """Main sync worker service."""

    def __init__(self):
        self.worker_manager = None
        self.running = False

    async def start(self):
        """Start the sync worker service."""
        log_service_lifecycle(logger, "service_starting", service="sync-worker-ms")

        try:
            self.worker_manager = WorkerManager()
            await self.worker_manager.initialize()
            await self.worker_manager.start_all_workers()

            self.running = True
            log_service_lifecycle(logger, "service_ready", service="sync-worker-ms")

            while self.running:
                await asyncio.sleep(1)

        except Exception as e:
            logger.critical(
                "Service failed to start",
                exc_info=True,
                extra={"event": "service_start_error", "error": str(e)},
            )
            raise

    async def stop(self):
        """Stop the sync worker service."""
        log_service_lifecycle(logger, "service_stopping", service="sync-worker-ms")
        self.running = False

        if self.worker_manager:
            await self.worker_manager.stop_all_workers()

        log_service_lifecycle(logger, "service_stopped", service="sync-worker-ms")


async def main():
    """Main entry point."""
    service = SyncWorkerService()

    loop = asyncio.get_running_loop()

    def signal_handler():
        logger.info("Received shutdown signal", extra={"event": "signal_received"})
        asyncio.create_task(service.stop())

    for sig in (signal.SIGTERM, signal.SIGINT):
        loop.add_signal_handler(sig, signal_handler)

    try:
        await service.start()
    except KeyboardInterrupt:
        logger.info("Keyboard interrupt received", extra={"event": "keyboard_interrupt"})
    finally:
        await service.stop()


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