"""Named DB locks with lease (``app_locks``) and fixed-window counters (``rate_counters``).

Portable "upsert": UPDATE, on 0 rows INSERT, on IntegrityError retry UPDATE (TZ 2.2.1 p.12.3).
"""

from __future__ import annotations

import contextlib
import time
from collections.abc import Iterator
from datetime import timedelta

from django.db import IntegrityError, transaction
from django.db.models import F, Q
from django.utils import timezone

from .models import AppLock, RateCounter


def acquire_lock(name: str, owner: str, lease_seconds: float) -> bool:
    now = timezone.now()
    until = now + timedelta(seconds=lease_seconds)
    updated = AppLock.objects.filter(Q(name=name) & (Q(lease_until__lt=now) | Q(owner=owner))).update(
        owner=owner, lease_until=until, acquired_at=now
    )
    if updated:
        return True
    try:
        with transaction.atomic():
            AppLock.objects.create(name=name, owner=owner, lease_until=until, acquired_at=now)
        return True
    except IntegrityError:
        return False


def release_lock(name: str, owner: str) -> None:
    AppLock.objects.filter(name=name, owner=owner).update(lease_until=timezone.now() - timedelta(seconds=1))


@contextlib.contextmanager
def db_lock(name: str, owner: str, lease_seconds: float = 30, wait_seconds: float = 5.0) -> Iterator[bool]:
    """Try to take the lock, polling up to ``wait_seconds``; yields whether it was acquired."""
    deadline = time.monotonic() + wait_seconds
    acquired = acquire_lock(name, owner, lease_seconds)
    while not acquired and time.monotonic() < deadline:
        time.sleep(0.1)
        acquired = acquire_lock(name, owner, lease_seconds)
    try:
        yield acquired
    finally:
        if acquired:
            release_lock(name, owner)


def lock_held(name: str) -> bool:
    return AppLock.objects.filter(name=name, lease_until__gte=timezone.now()).exists()


def incr_counter(bucket: str, ttl_seconds: int) -> int:
    now = timezone.now()
    updated = RateCounter.objects.filter(bucket=bucket).update(count=F("count") + 1)
    if not updated:
        try:
            with transaction.atomic():
                RateCounter.objects.create(bucket=bucket, count=1, expires_at=now + timedelta(seconds=ttl_seconds))
            return 1
        except IntegrityError:
            RateCounter.objects.filter(bucket=bucket).update(count=F("count") + 1)
    row = RateCounter.objects.filter(bucket=bucket).values_list("count", flat=True).first()
    return int(row or 0)
