from __future__ import annotations

import asyncio
import logging

from app.core.postgres.erp_client import ErpDatabaseClient
from app.core.settings import get_settings
from app.modules.agents.application.llm_client import LLMClient

from .heal_documents import HealDocumentsMixin
from .heal_equipment import HealEquipmentMixin
from .heal_invoices import HealInvoicesMixin
from .heal_projects import HealProjectsMixin
from .sweep_scheduler import SweepSchedulerMixin

logger = logging.getLogger("dscons.autonomous_engine")


class AutonomousEngineService(
    HealDocumentsMixin,
    HealInvoicesMixin,
    HealProjectsMixin,
    HealEquipmentMixin,
    SweepSchedulerMixin,
):
    """Master Autonomous Engine for continuous self-healing across ERP modules."""

    def __init__(
        self,
        erp_client: ErpDatabaseClient | None = None,
        llm_client: LLMClient | None = None,
    ) -> None:
        self._erp_client = erp_client or ErpDatabaseClient()
        self._settings = get_settings()
        self._llm_client = llm_client or LLMClient(self._settings)


_autonomous_service_instance: AutonomousEngineService | None = None


def get_autonomous_service() -> AutonomousEngineService:
    """Singleton factory for AutonomousEngineService."""
    global _autonomous_service_instance
    if _autonomous_service_instance is None:
        _autonomous_service_instance = AutonomousEngineService()
    return _autonomous_service_instance


async def start_autonomous_scheduler_loop(interval_seconds: int = 1800) -> None:
    """Background infinite loop to execute autonomous sweep at configured intervals."""
    service = get_autonomous_service()
    logger.info(
        "Starting Autonomous Engine background sweep loop (interval: %ss)",
        interval_seconds,
    )
    while True:
        try:
            logger.info("Executing periodic autonomous sweep...")
            sweep_results = await service.run_full_autonomous_sweep()
            logger.info("Periodic autonomous sweep completed: %s", sweep_results)
        except Exception as e:
            logger.error("Error in autonomous engine background sweep loop: %s", e)
        await asyncio.sleep(interval_seconds)