"""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
from app.models.models import Customer, ProvisioningEvent, ProvisioningJob

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


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


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
        "Memerlukan tindakan admin" 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)
            if customer.provisioning_status == "provisioned":
                confirmed_by_user = (
                    customer.internet_check_status == "verified"
                    and customer.internet_checked_by == "user_confirmation"
                )
                completion_message = (
                    customer.provisioning_message
                    if confirmed_by_user
                    else "Provisioning selesai setelah akses internet pelanggan dikonfirmasi."
                )
                await _finish_job(db, job, "completed", completion_message, progress=100)
            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"}:
                await _write_stage(db, job_id, "Menunggu sesi PPPoE dan verifikasi internet", 90, "waiting", "Konfigurasi perangkat selesai; BestWeb menunggu sesi PPPoE dan trafik Internet pelanggan.")
                await db.refresh(job)
                job.status = "waiting"
                job.result_message = "Konfigurasi perangkat sudah diterapkan. Menunggu sesi PPPoE dan verifikasi internet; pemeriksaan berlanjut otomatis."
                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)
        retry_due = (_utcnow() - started).total_seconds() >= 600
        if retry_due and customer.provisioning_status in {"waiting_session", "failed", "pending_configuration"}:
            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":
                await _finish_job(db, job, "completed", "Provisioning selesai; sesi PPPoE pelanggan dan Internet terverifikasi.", progress=100)
                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":
                await _finish_job(db, job, "completed", "Sesi PPPoE pelanggan dan konektivitas Internet terverifikasi otomatis.", progress=100)
            else:
                job.status = "waiting"
                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."
                await _write_stage(db, job_id, job.current_activity, 90, "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 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
    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()
                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)
            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
