"""Minute scheduler (TZ 2.10.4): reaper, file TTL cleanup, retention. Each task under a DB lock."""

from __future__ import annotations

import time
from collections.abc import Callable
from datetime import timedelta
from typing import Any

from django.conf import settings
from django.core.management.base import BaseCommand
from django.utils import timezone

from snapfile.core.locks import acquire_lock, release_lock
from snapfile.core.models import AppLock, RateCounter, SchedulerRun
from snapfile.core.storage import store
from snapfile.integration.models import IdempotencyKey, RequestNonce
from snapfile.jobs.models import RenderFile, RenderJob, WebhookDelivery
from snapfile.jobs.queue import make_owner
from snapfile.jobs.service import reap_render_jobs
from snapfile.jobs.webhooks import queue as webhook_queue


def reap_jobs() -> str:
    r, f = reap_render_jobs()
    webhook_queue.reap()
    return f"requeued={r} failed={f}"


def cleanup_renders() -> str:
    now = timezone.now()
    files = list(RenderFile.objects.filter(expires_at__lt=now, deleted_at__isnull=True)[:500])
    for f in files:
        store().delete(f.path)
    RenderFile.objects.filter(pk__in=[f.pk for f in files]).update(deleted_at=now)
    expired = RenderJob.objects.filter(status="succeeded", expires_at__lt=now).update(status="expired")
    return f"files={len(files)} jobs_expired={expired}"


def cleanup_tmp() -> str:
    tmp = settings.SNAPFILE_TMP_DIR
    n = 0
    if tmp.exists():
        cutoff = time.time() - 2 * 3600
        for p in tmp.rglob("*"):
            if p.is_file() and p.stat().st_mtime < cutoff:
                p.unlink(missing_ok=True)
                n += 1
    return f"removed={n}"


def cleanup_retention() -> str:
    now = timezone.now()
    old = now - timedelta(days=settings.JOB_RETENTION_DAYS)
    jobs = RenderJob.objects.filter(finished_at__lt=old, status__in=("succeeded", "failed", "canceled", "expired"))
    n_jobs = 0
    for job in jobs[:500]:
        store().delete_tree(f"renders/{job.created_at:%Y/%m/%d}/{job.id}")
        job.delete()
        n_jobs += 1
    n_idem = IdempotencyKey.objects.filter(expires_at__lt=now).delete()[0]
    n_nonce = RequestNonce.objects.filter(expires_at__lt=now).delete()[0]
    n_rate = RateCounter.objects.filter(expires_at__lt=now).delete()[0]
    n_wh = WebhookDelivery.objects.filter(created_at__lt=now - timedelta(days=30)).delete()[0]
    n_locks = AppLock.objects.filter(lease_until__lt=now - timedelta(days=1)).delete()[0]
    return f"jobs={n_jobs} idem={n_idem} nonces={n_nonce} rate={n_rate} webhooks={n_wh} locks={n_locks}"


# (name, period seconds, function)
TASKS: list[tuple[str, int, Callable[[], str]]] = [
    ("reap_jobs", 60, reap_jobs),
    ("cleanup_renders", 15 * 60, cleanup_renders),
    ("cleanup_tmp", 3600, cleanup_tmp),
    ("cleanup_retention", 24 * 3600, cleanup_retention),
]


class Command(BaseCommand):
    help = "Run due scheduler tasks (call every minute from cron / supercronic)"

    def add_arguments(self, parser: Any) -> None:
        parser.add_argument("--max-seconds", type=float, default=50.0)
        parser.add_argument("--force", action="store_true", help="Run all tasks regardless of schedule")

    def handle(self, *args: Any, **opts: Any) -> None:
        owner = make_owner()
        started = time.monotonic()
        now = timezone.now()
        for name, period, fn in TASKS:
            if time.monotonic() - started > opts["max_seconds"]:
                break
            run = SchedulerRun.objects.filter(task=name).first()
            if (
                run
                and run.last_started_at
                and not opts["force"]
                and (now - run.last_started_at).total_seconds() < period - 5
            ):
                continue
            lock = f"sched:{name}"
            if not acquire_lock(lock, owner, 120):
                continue
            t0 = time.monotonic()
            SchedulerRun.objects.update_or_create(task=name, defaults={"last_started_at": timezone.now()})
            try:
                result = fn()
                status, error = "ok", None
            except Exception as exc:  # keep the other tasks running
                result, status, error = "", "error", f"{type(exc).__name__}: {exc}"
            finally:
                release_lock(lock, owner)
            SchedulerRun.objects.filter(task=name).update(
                last_finished_at=timezone.now(),
                last_status=status,
                last_error=error,
                last_duration_ms=int((time.monotonic() - t0) * 1000),
            )
            self.stdout.write(f"{name}: {status} {result or error}")
