"""Persistent PSB job runner and read-only status monitor."""
import asyncio
import logging
from datetime import datetime, timezone

from sqlalchemy import select, update

from app.core.database import AsyncSessionLocal
from app.core.onboarding import run_onboarding, refresh_customer_online_status, sync_acs_enrollment, psb_wan_sync_supported, sync_psb_customer_wan
from app.models.models import Customer, ProvisioningEvent, ProvisioningJob

logger = logging.getLogger("bestweb.provisioning_monitor")


def _utcnow():
    return datetime.now(timezone.utc)


def _internet_confirmed(customer: Customer) -> bool:
    # This confirms provisioning and router upstream only. It does not prove
    # that client devices can browse through the ONT Wi-Fi.
    automatically_verified = (
        customer.status == "active"
        and customer.provisioning_status == "provisioned"
        and customer.olt_provisioning_status == "provisioned"
        and customer.mikrotik_provisioning_status == "provisioned"
    )
    manually_confirmed = (
        customer.internet_check_status == "verified"
        and customer.internet_checked_by == "user_confirmation"
    )
    return automatically_verified or manually_confirmed


async def _provisioning_complete(customer: Customer, db, wan_sync: dict | None = None) -> bool:
    """Complete only when provisioning evidence and the supported ONT WAN agree."""
    if not _internet_confirmed(customer):
        return False
    if psb_wan_sync_supported(customer):
        return bool(wan_sync and wan_sync.get("ready"))
    return True


async def _write_stage(db, job_id: int, name: str, percent: int, state: str, message: str) -> None:
    job = await db.get(ProvisioningJob, job_id)
    if not job:
        return
    job.current_activity = name
    prior = await db.scalar(select(ProvisioningEvent).where(
        ProvisioningEvent.job_id == job_id,
        ProvisioningEvent.activity_name == name,
        ProvisioningEvent.status.in_(["pending", "processing", "waiting", "failed"]),
    ).order_by(ProvisioningEvent.id.desc()).limit(1))
    if prior:
        prior.status = state
        prior.progress_percent = percent
        prior.message = message
    else:
        db.add(ProvisioningEvent(
            customer_id=job.customer_id, job_id=job.id, target="onboarding_activity",
            status=state, activity_name=name, progress_percent=percent,
            vendor=job.vendor, olt_device_id=job.olt_device_id,
            mikrotik_device_id=job.mikrotik_device_id, message=message,
        ))
    # A waiting stage has made progress but is not complete. Reserve 100%
    # for the atomic terminal-job commit in _finish_job.
    job.progress_percent = max(job.progress_percent or 0, min(percent, 99))
    await db.commit()


async def _finish_job(db, job: ProvisioningJob, status: str, message: str, *, progress: int | None = None):
    job.status = status
    job.result_message = message[:1000]
    job.current_activity = (
        "Provisioning Berhasil" if status == "completed" else
        "Provisioning Gagal" if status == "failed" else
        "Perlu pemeriksaan sesi PPPoE" if status == "requires_action" else
        job.current_activity
    )
    job.finished_at = _utcnow() if status in {"completed", "failed", "requires_action"} else None
    if progress is not None:
        job.progress_percent = max(job.progress_percent or 0, progress)
    if status in {"completed", "failed", "requires_action"}:
        open_events = (await db.execute(select(ProvisioningEvent).where(
            ProvisioningEvent.job_id == job.id,
            ProvisioningEvent.status.in_(["pending", "processing", "waiting"]),
        ))).scalars().all()
        for event in open_events:
            if status == "completed":
                event.status = "success"
                event.progress_percent = job.progress_percent
                event.message = "Tahap selesai dan terverifikasi."
            elif event.status in {"processing", "waiting"}:
                event.status = "failed" if status == "failed" else "requires_action"
                event.message = message[:1000]
            else:
                event.status = "skipped"
                event.message = "Tahap dilewati karena proses sebelumnya berhenti."
        name = "Provisioning Berhasil" if status == "completed" else ("Provisioning Gagal" if status == "failed" else "Memerlukan tindakan admin")
        db.add(ProvisioningEvent(
            customer_id=job.customer_id, job_id=job.id, target="onboarding_result",
            status="success" if status == "completed" else status,
            activity_name=name, progress_percent=job.progress_percent,
            vendor=job.vendor, olt_device_id=job.olt_device_id,
            mikrotik_device_id=job.mikrotik_device_id, message=message[:1000],
        ))
    await db.commit()


async def _process_queued(job_id: int) -> None:
    async with AsyncSessionLocal() as db:
        result = await db.execute(update(ProvisioningJob).where(
            ProvisioningJob.id == job_id,
            ProvisioningJob.target == "onboarding",
            ProvisioningJob.status == "queued",
        ).values(status="running", started_at=_utcnow(), current_activity="Memulai provisioning", attempts=ProvisioningJob.attempts + 1, updated_at=_utcnow()))
        await db.commit()
        if result.rowcount != 1:
            return
        job = await db.get(ProvisioningJob, job_id)
        customer = await db.get(Customer, job.customer_id) if job else None
        if not job or not customer:
            if job:
                await _finish_job(db, job, "failed", "Data pelanggan untuk pekerjaan ini tidak ditemukan.")
            return
        try:
            async def on_stage(name, percent, state, message):
                await _write_stage(db, job_id, name, percent, state, message)

            await run_onboarding(customer, db, on_stage=on_stage)
            await db.refresh(job)
            await db.refresh(customer)
            wan_sync = None
            if (psb_wan_sync_supported(customer)
                    and customer.olt_provisioning_status in {"provisioned", "waiting_session"}
                    and customer.mikrotik_provisioning_status in {"provisioned", "waiting_session", "waiting_internet"}):
                wan_sync = await sync_psb_customer_wan(customer, db)
                await _write_stage(db, job_id, "Menyelaraskan WAN Internet ONT", 85,
                                   "success" if wan_sync.get("ready") else ("failed" if wan_sync.get("state") == "failed" else "waiting"),
                                   wan_sync.get("message", "Memeriksa WAN Internet ONT."))
                await db.refresh(job)
                if not wan_sync.get("ready"):
                    customer.status = "waiting_session"
                    customer.provisioning_status = "waiting_session"
                    customer.provisioning_message = wan_sync.get("message", "Menunggu WAN Internet ONT.")
                    await db.commit()
            if customer.provisioning_status == "provisioned" and await _provisioning_complete(customer, db, wan_sync):
                await _finish_job(db, job, "completed", customer.provisioning_message or
                                  "Sesi PPPoE dan koneksi upstream MikroTik terverifikasi; akses Wi-Fi pelanggan belum diuji.", progress=100)
            elif customer.provisioning_status == "provisioned":
                message = (wan_sync or {}).get("message") or "BestWeb melanjutkan pemeriksaan sesi PPPoE dan upstream MikroTik."
                job.status = "waiting"
                job.started_at = _utcnow()
                job.finished_at = None
                job.current_activity = "Memverifikasi sesi PPPoE dan Internet"
                job.result_message = message
                job.progress_percent = min(job.progress_percent or 90, 95)
                await db.commit()
            elif customer.provisioning_status == "failed":
                job.last_error = (customer.provisioning_message or "Provisioning sementara gagal.")[:1000]
                job.status = "waiting"
                job.started_at = _utcnow()
                job.finished_at = None
                job.result_message = "Tahap provisioning belum terkonfirmasi. BestWeb akan mencoba kembali otomatis."
                await db.commit()
            elif customer.provisioning_status in {"waiting_session", "waiting_internet"}:
                message = (wan_sync or {}).get("message") or ((customer.provisioning_message or "Konfigurasi perangkat sudah diterapkan.") + " BestWeb akan memeriksa sesi PPPoE dan mencoba pemulihan otomatis.")
                job.status = "waiting"
                job.started_at = _utcnow()
                job.finished_at = None
                job.current_activity = "Menunggu sesi PPPoE dan verifikasi internet"
                job.result_message = message
                job.progress_percent = 90
                await _write_stage(db, job_id, job.current_activity, 90, "waiting", message)
                await db.refresh(job)
                job.started_at = _utcnow()
                await db.commit()
            else:
                job.status = "waiting"
                job.started_at = _utcnow()
                job.finished_at = None
                job.result_message = "BestWeb terus memeriksa status provisioning dan akan menjalankan pemulihan otomatis."
                await db.commit()
        except Exception:
            logger.exception("Provisioning job %s failed unexpectedly", job_id)
            await db.rollback()
            job = await db.get(ProvisioningJob, job_id)
            if job:
                job.last_error = "Unhandled provisioning worker exception; see server log."
                await _finish_job(db, job, "failed", "Terjadi kesalahan internal saat provisioning. Detail teknis tersimpan di log server.")


async def _check_waiting_job(job_id: int) -> None:
    async with AsyncSessionLocal() as db:
        job = await db.get(ProvisioningJob, job_id)
        if not job or job.status != "waiting":
            return
        customer = await db.get(Customer, job.customer_id)
        if not customer:
            await _finish_job(db, job, "failed", "Data pelanggan untuk pemantauan tidak ditemukan.")
            return
        started = job.started_at or job.created_at or _utcnow()
        if started.tzinfo is None:
            started = started.replace(tzinfo=timezone.utc)
        wan_sync = None
        if (psb_wan_sync_supported(customer)
                and customer.olt_provisioning_status in {"provisioned", "waiting_session"}
                and customer.mikrotik_provisioning_status in {"provisioned", "waiting_session", "waiting_internet"}):
            wan_sync = await sync_psb_customer_wan(customer, db)
            await _write_stage(db, job_id, "Menyelaraskan WAN Internet ONT", 85,
                               "success" if wan_sync.get("ready") else ("failed" if wan_sync.get("state") == "failed" else "waiting"),
                               wan_sync.get("message", "Memeriksa WAN Internet ONT."))
            await db.refresh(job)
        retry_interval = 60 if psb_wan_sync_supported(customer) else 600
        retry_due = (_utcnow() - started).total_seconds() >= retry_interval
        retry_states = {"failed", "pending_configuration"}
        if not psb_wan_sync_supported(customer):
            retry_states.add("waiting_session")
        if retry_due and customer.provisioning_status in retry_states:
            await _write_stage(db, job_id, "Memulihkan konfigurasi WAN dan sesi PPPoE", 90, "processing", "Belum ada sesi untuk username pelanggan; BestWeb mengirim ulang konfigurasi WAN yang sama dan memeriksa sesi kembali.")
            async def on_stage(name, percent, state, message):
                await _write_stage(db, job_id, name, percent, state, message)

            await run_onboarding(customer, db, on_stage=on_stage)
            await db.refresh(customer)
            await db.refresh(job)
            job.started_at = _utcnow()
            if customer.provisioning_status == "provisioned" and await _provisioning_complete(customer, db, wan_sync):
                await _finish_job(db, job, "completed", "Sesi PPPoE dan koneksi upstream MikroTik terverifikasi; akses Wi-Fi pelanggan belum diuji.", progress=100)
                return
            if customer.provisioning_status == "provisioned":
                message = "BestWeb memeriksa ulang bukti sesi PPPoE dan konektivitas Internet."
                job.status = "waiting"
                job.finished_at = None
                job.result_message = message
                await _write_stage(db, job_id, "Memverifikasi sesi PPPoE dan Internet", 95, "waiting", message)
                await db.refresh(job)
                job.started_at = _utcnow()
                await db.commit()
                return
            if customer.provisioning_status in {"failed", "pending_configuration"}:
                job.result_message = "BestWeb mengulang provisioning otomatis karena koneksi belum terkonfirmasi. Pemeriksaan berlanjut."
            else:
                job.result_message = customer.provisioning_message or "BestWeb menunggu sesi PPPoE dan Internet pelanggan."
            job.last_error = None
            job.status = "waiting"
            await _write_stage(db, job_id, "Menunggu sesi PPPoE dan verifikasi internet", 90, "waiting", job.result_message)
            await db.refresh(job)
            job.started_at = _utcnow()
            await db.commit()
            return
        try:
            state = await refresh_customer_online_status(customer, db)
            await db.refresh(job)
            if state == "active" and await _provisioning_complete(customer, db, wan_sync):
                await _finish_job(db, job, "completed", "Sesi PPPoE dan koneksi upstream MikroTik terverifikasi; akses Wi-Fi pelanggan belum diuji.", progress=100)
            else:
                job.status = "waiting"
                job.finished_at = None
                if wan_sync and not wan_sync.get("ready"):
                    customer.status = "waiting_session"
                    customer.provisioning_status = "waiting_session"
                    customer.provisioning_message = wan_sync.get("message") or "Menunggu WAN Internet ONT."
                    job.current_activity = "Menyelaraskan WAN Internet ONT"
                    job.result_message = wan_sync.get("message") or "Menunggu konfigurasi WAN Internet ONT."
                    percent = 90
                elif state == "active":
                    job.current_activity = "Memverifikasi sesi PPPoE dan Internet"
                    job.result_message = "BestWeb memeriksa bukti sesi PPPoE dan konektivitas Internet."
                    percent = 95
                else:
                    job.current_activity = "Menunggu sesi PPPoE dan verifikasi internet"
                    job.result_message = customer.provisioning_message or "BestWeb memantau sesi pelanggan dan trafik Internet secara otomatis; pemantauan berlanjut."
                    percent = 90
                await _write_stage(db, job_id, job.current_activity, percent, "waiting", job.result_message)
        except Exception:
            logger.exception("Read-only provisioning monitor failed for job %s", job_id)
            await db.rollback()


async def recover_interrupted_provisioning_jobs() -> None:
    """Do not replay partially applied device commands after an app restart."""
    async with AsyncSessionLocal() as db:
        jobs = (await db.execute(select(ProvisioningJob).where(
            ProvisioningJob.target == "onboarding", ProvisioningJob.status == "running"
        ))).scalars().all()
        for job in jobs:
            job.status = "waiting"
            job.finished_at = None
            job.started_at = _utcnow()
            job.current_activity = "Melanjutkan pemeriksaan provisioning otomatis"
            job.result_message = "Server sempat berhenti saat provisioning. BestWeb melanjutkan pemulihan dan verifikasi otomatis."
            job.last_error = "Provisioning worker resumed after application restart."
            open_events = (await db.execute(select(ProvisioningEvent).where(
                ProvisioningEvent.job_id == job.id,
                ProvisioningEvent.status.in_(["pending", "processing"]),
            ))).scalars().all()
            for event in open_events:
                if event.status == "processing":
                    event.status = "waiting"
                    event.message = "Server melanjutkan pemeriksaan tahap ini secara otomatis."
                else:
                    event.status = "skipped"
                    event.message = "Tahap belum dijalankan karena proses terhenti."
            customer = await db.get(Customer, job.customer_id)
            if customer:
                customer.provisioning_status = "waiting_session"
                customer.status = "waiting_session"
                customer.provisioning_message = job.result_message
            db.add(ProvisioningEvent(
                customer_id=job.customer_id, job_id=job.id, target="onboarding_result",
                status="waiting", activity_name="Pemulihan provisioning otomatis",
                progress_percent=job.progress_percent,
                message=job.result_message,
            ))
        if jobs:
            await db.commit()


async def _scan_waiting_acs_enrollment() -> None:
    """Keep ACS enrollment asynchronous, so a late Inform never blocks PSB."""
    async with AsyncSessionLocal() as db:
        customer_ids = (await db.execute(select(Customer.id).where(
            Customer.is_archived == False,
            Customer.acs_wifi_status == "waiting_inform",
        ).order_by(Customer.id).limit(100))).scalars().all()
        changed = False
        for customer_id in customer_ids:
            customer = await db.get(Customer, customer_id)
            if not customer:
                continue
            before = customer.acs_wifi_status
            await sync_acs_enrollment(customer, db)
            changed = changed or customer.acs_wifi_status != before
        if customer_ids:
            await db.commit()


async def provisioning_worker_loop(stop_event: asyncio.Event | None = None) -> None:
    """Run queued PSB jobs independently of browser connections; persist all progress."""
    stop_event = stop_event or asyncio.Event()
    last_waiting_scan = 0.0
    last_acs_scan = 0.0
    while not stop_event.is_set():
        try:
            async with AsyncSessionLocal() as db:
                queued = await db.scalar(select(ProvisioningJob.id).where(
                    ProvisioningJob.target == "onboarding", ProvisioningJob.status == "queued"
                ).order_by(ProvisioningJob.id).limit(1))
                if queued:
                    await _process_queued(queued)
                    continue
                now = asyncio.get_running_loop().time()
                scan_acs = now - last_acs_scan >= 60
                if scan_acs:
                    last_acs_scan = now
                if now - last_waiting_scan >= 15:
                    waiting_ids = (await db.execute(select(ProvisioningJob.id).where(
                        ProvisioningJob.target == "onboarding", ProvisioningJob.status == "waiting"
                    ).order_by(ProvisioningJob.id))).scalars().all()
                    last_waiting_scan = now
                else:
                    waiting_ids = []
            for job_id in waiting_ids:
                if stop_event.is_set():
                    break
                await _check_waiting_job(job_id)
            if scan_acs and not stop_event.is_set():
                await _scan_waiting_acs_enrollment()
            try:
                await asyncio.wait_for(stop_event.wait(), timeout=1.5)
            except asyncio.TimeoutError:
                pass
        except asyncio.CancelledError:
            raise
        except Exception:
            logger.exception("Provisioning worker loop error")
            try:
                await asyncio.wait_for(stop_event.wait(), timeout=3)
            except asyncio.TimeoutError:
                pass
