"""DB-backed queue: SKIP LOCKED claim, lease + heartbeat, fencing, reaper, retries (TZ 2.1.6)."""

from __future__ import annotations

import os
import random
import socket
from datetime import timedelta
from typing import Any, TypeVar

from django.conf import settings
from django.db import connection, models, transaction
from django.db.models import F, Value
from django.db.models.functions import Coalesce
from django.utils import timezone

from snapfile.core.ids import uuid7

M = TypeVar("M", bound=models.Model)

BACKOFF_SECONDS = (10, 60, 300)
REAPER_GRACE_SECONDS = 10


def make_owner() -> str:
    return f"{socket.gethostname()[:40]}:{os.getpid()}:{uuid7().hex[:16]}"


def backoff(attempt: int, schedule: tuple[int, ...] = BACKOFF_SECONDS) -> timedelta:
    base = schedule[min(max(attempt, 1), len(schedule)) - 1]
    return timedelta(seconds=base * random.uniform(0.8, 1.2))


def skip_locked_supported() -> bool:
    return bool(connection.features.has_select_for_update_skip_locked)


class JobQueue:
    """Queue logic shared by every table with :class:`snapfile.jobs.models.QueueFields`."""

    def __init__(self, model: type[Any]) -> None:
        self.model = model

    def claim(self, owner: str, queues: list[str], lease_seconds: int | None = None) -> Any | None:
        lease = timedelta(seconds=lease_seconds or settings.SNAPFILE_JOB_LEASE_SECONDS)
        now = timezone.now()
        with transaction.atomic():
            job = (
                self.model.objects.select_for_update(skip_locked=True)
                .filter(status="queued", queue__in=queues, available_at__lte=now)
                .order_by("priority", "available_at", "id")
                .first()
            )
            if job is None:
                return None
            fields: dict[str, Any] = {
                "status": "running",
                "lease_owner": owner,
                "lease_until": now + lease,
                "heartbeat_at": now,
                "attempts": F("attempts") + 1,
            }
            if hasattr(self.model, "started_at"):
                fields["started_at"] = Coalesce("started_at", Value(now))
            self.model.objects.filter(pk=job.pk).update(**fields)
        job.refresh_from_db()
        return job

    def heartbeat(self, pk: Any, owner: str, lease_seconds: int | None = None) -> tuple[bool, bool]:
        """Extend the lease. Returns (lease_still_held, cancel_requested)."""
        now = timezone.now()
        lease = timedelta(seconds=lease_seconds or settings.SNAPFILE_JOB_LEASE_SECONDS)
        updated = self.model.objects.filter(pk=pk, lease_owner=owner, status="running").update(
            lease_until=now + lease, heartbeat_at=now
        )
        if not updated:
            return False, False
        cancel = False
        if hasattr(self.model, "cancel_requested"):
            cancel = bool(self.model.objects.filter(pk=pk).values_list("cancel_requested", flat=True).first())
        return True, cancel

    def finish(self, pk: Any, owner: str, **fields: Any) -> bool:
        """Fenced completion: only the lease owner of a running job may finish it."""
        return bool(self.model.objects.filter(pk=pk, lease_owner=owner, status="running").update(**fields))

    def retry_or_fail(self, job: Any, owner: str, code: str, message: str, retryable: bool) -> str:
        now = timezone.now()
        if retryable and job.attempts < job.max_attempts:
            ok = self.finish(
                job.pk,
                owner,
                status="queued",
                available_at=now + backoff(job.attempts),
                lease_owner=None,
                lease_until=None,
                error_code=code,
                error_message=message[:2000],
            )
            return "queued" if ok else "lost"
        fields: dict[str, Any] = {"status": "failed", "error_code": code, "error_message": message[:2000]}
        if hasattr(self.model, "finished_at"):
            fields["finished_at"] = now
        ok = self.finish(job.pk, owner, **fields)
        return "failed" if ok else "lost"

    def reap(self) -> tuple[list[Any], list[Any]]:
        """Expired leases -> back to the queue (or failed with WORKER_LOST). Returns (requeued, failed)."""
        now = timezone.now()
        cutoff = now - timedelta(seconds=REAPER_GRACE_SECONDS)
        requeued: list[Any] = []
        failed: list[Any] = []
        with transaction.atomic():
            stuck = list(
                self.model.objects.select_for_update(skip_locked=True).filter(status="running", lease_until__lt=cutoff)[
                    :100
                ]
            )
            for job in stuck:
                if job.attempts < job.max_attempts:
                    self.model.objects.filter(pk=job.pk).update(
                        status="queued",
                        available_at=now + backoff(job.attempts),
                        lease_owner=None,
                        lease_until=None,
                        error_code="WORKER_LOST",
                    )
                    requeued.append(job.pk)
                else:
                    fields: dict[str, Any] = {
                        "status": "failed",
                        "error_code": "WORKER_LOST",
                        "error_message": "Worker lost the lease",
                        "lease_owner": None,
                    }
                    if hasattr(self.model, "finished_at"):
                        fields["finished_at"] = now
                    self.model.objects.filter(pk=job.pk).update(**fields)
                    failed.append(job.pk)
        return requeued, failed
