"""Queue worker (TZ 2.1.6.7): cron mode (``--max-seconds 55``) or Docker mode (``--forever``)."""

from __future__ import annotations

import os
import signal
import socket
import time
from typing import Any

from django.conf import settings
from django.core.management.base import BaseCommand, CommandError
from django.db import close_old_connections
from django.utils import timezone

from snapfile.core.locks import acquire_lock, release_lock
from snapfile.core.models import WorkerHeartbeat
from snapfile.jobs.models import WebhookDelivery
from snapfile.jobs.queue import make_owner, skip_locked_supported
from snapfile.jobs.service import reap_render_jobs, run_one
from snapfile.jobs.webhooks import deliver
from snapfile.jobs.webhooks import queue as webhook_queue

RENDER_QUEUES = ("render-high", "render")


def _rss_mb() -> int | None:
    try:
        import resource

        rss = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
        return int(rss / 1024 / (1024 if os.uname().sysname == "Darwin" else 1))
    except Exception:
        return None


class Command(BaseCommand):
    help = "Process render jobs and webhook deliveries from the DB queue (SKIP LOCKED + lease)"

    def add_arguments(self, parser: Any) -> None:
        parser.add_argument(
            "--max-seconds", type=float, default=55.0, help="Stop taking new jobs after this many seconds (cron mode)"
        )
        parser.add_argument(
            "--min-start-seconds", type=float, default=10.0, help="Do not start a job if less budget than this remains"
        )
        parser.add_argument("--forever", action="store_true", help="Docker worker mode")
        parser.add_argument("--queues", default="render-high,render,webhooks")
        parser.add_argument("--max-jobs", type=int, default=500)
        parser.add_argument("--max-rss-mb", type=int, default=600)

    def handle(self, *args: Any, **opts: Any) -> None:
        if not skip_locked_supported():
            raise CommandError("Database does not support SELECT ... FOR UPDATE SKIP LOCKED (MySQL 8+/PG required)")
        forever = opts["forever"]
        max_seconds = 3600.0 if forever and opts["max_seconds"] == 55.0 else opts["max_seconds"]
        queues = [q.strip() for q in opts["queues"].split(",") if q.strip()]
        render_queues = [q for q in queues if q in RENDER_QUEUES]
        owner = make_owner()
        stop = {"flag": False}

        def on_term(signum: int, frame: Any) -> None:
            stop["flag"] = True

        signal.signal(signal.SIGTERM, on_term)
        signal.signal(signal.SIGINT, on_term)
        slot = None
        if not forever:
            for n in range(max(1, settings.SNAPFILE_CRON_MAX_WORKERS)):
                name = f"cron-worker:{n}"
                if acquire_lock(name, owner, max_seconds + settings.RENDER_TIMEOUT_ASYNC + 30):
                    slot = name
                    break
            if slot is None:
                self.stdout.write("all cron worker slots are busy; exiting")
                return
        started = time.monotonic()
        WorkerHeartbeat.objects.update_or_create(
            owner=owner,
            defaults={
                "host": socket.gethostname()[:128],
                "pid": os.getpid(),
                "mode": "worker" if forever else "cron",
                "queues": ",".join(queues)[:128],
                "started_at": timezone.now(),
                "last_seen_at": timezone.now(),
            },
        )
        done = 0
        idle = 0.5
        last_reap = 0.0
        last_beat = time.monotonic()
        try:
            while not stop["flag"]:
                now = time.monotonic()
                if now - last_reap > 30:
                    requeued, failed = reap_render_jobs()
                    webhook_queue.reap()
                    if requeued or failed:
                        self.stdout.write(f"reaper: requeued={requeued} failed={failed}")
                    last_reap = now
                if now - last_beat > 15:
                    WorkerHeartbeat.objects.filter(owner=owner).update(
                        last_seen_at=timezone.now(), jobs_done=done, rss_mb=_rss_mb()
                    )
                    last_beat = now
                remaining = max_seconds - (now - started)
                if remaining < opts["min_start_seconds"] or done >= opts["max_jobs"]:
                    break
                rss = _rss_mb()
                if forever and rss and rss > opts["max_rss_mb"]:
                    self.stdout.write(f"rss {rss} MB above limit; exiting for a restart")
                    break
                worked = False
                if render_queues:
                    status = run_one(render_queues, owner)
                    if status is not None:
                        worked = True
                        done += 1
                        self.stdout.write(f"render job -> {status}")
                if not worked and "webhooks" in queues:
                    delivery = webhook_queue.claim(owner, ["webhooks"])
                    if delivery is not None:
                        delivery = WebhookDelivery.objects.select_related("project").get(pk=delivery.pk)
                        result = deliver(delivery, owner)
                        worked = True
                        done += 1
                        self.stdout.write(f"webhook {delivery.event} -> {result}")
                if worked:
                    idle = 0.5
                    continue
                if not forever:
                    break
                close_old_connections()
                time.sleep(idle)
                idle = min(2.0, idle * 2)
        finally:
            WorkerHeartbeat.objects.filter(owner=owner).update(last_seen_at=timezone.now(), jobs_done=done)
            if slot:
                release_lock(slot, owner)
        self.stdout.write(f"run_jobs finished: {done} job(s)")
