"""Runs und ihre Streaming-Ereignisse (→ Konzept 4.4, 9)."""

import uuid
from datetime import datetime
from typing import Any

from sqlalchemy import (
    JSON,
    BigInteger,
    Boolean,
    ForeignKey,
    Identity,
    Index,
    Integer,
    String,
    Text,
    UniqueConstraint,
    Uuid,
    func,
    text,
)
from sqlalchemy.orm import Mapped, mapped_column

from app.core.database import Base, now


class TaskRun(Base):
    """Ein Run ist zugleich der Job in der Queue: queued + available_at <= jetzt = fällig."""

    __tablename__ = "task_runs"
    # Für das Beanspruchen: nur fällige Runs im Index
    __table_args__ = (Index("ix_task_runs_due", "available_at", postgresql_where=text("status = 'queued'")),)

    id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, default=uuid.uuid4)
    workspace_id: Mapped[int] = mapped_column(ForeignKey("workspaces.id", ondelete="CASCADE"), index=True)
    # Kopie aus dem Workspace für das Limit gleichzeitiger Runs je Team
    team_id: Mapped[int] = mapped_column(ForeignKey("teams.id"), index=True)
    chat_session_id: Mapped[int | None] = mapped_column(ForeignKey("chat_sessions.id", ondelete="CASCADE"))
    # Subagenten laufen als Kind-Runs (→ Konzept 7.9)
    parent_run_id: Mapped[uuid.UUID | None] = mapped_column(Uuid, ForeignKey("task_runs.id"))
    kind: Mapped[str] = mapped_column(String(20), default="chat")
    status: Mapped[str] = mapped_column(String(30), default="queued", index=True)
    input: Mapped[dict[str, Any]] = mapped_column(JSON, default=dict)
    result: Mapped[dict[str, Any]] = mapped_column(JSON, default=dict)
    error: Mapped[str] = mapped_column(Text, default="")
    attempts: Mapped[int] = mapped_column(Integer, default=0)
    # Zeit der Datenbank, wie beim Beanspruchen: Uhren von Web, Worker und Datenbank weichen ab
    available_at: Mapped[datetime] = mapped_column(default=func.now())
    # Lease (→ Konzept 9.3): wer den Run gerade bearbeitet und bis wann
    locked_by: Mapped[str | None] = mapped_column(String(100))
    locked_until: Mapped[datetime | None]
    # Abbruch eines laufenden Runs: der Worker sieht es beim nächsten Heartbeat
    cancel_requested: Mapped[bool] = mapped_column(Boolean, default=False)
    # Zustand eines pausierten Runs für die Wiederaufnahme (Verlauf, offene Tool-Aufrufe, Snapshots)
    state: Mapped[dict[str, Any]] = mapped_column(JSON, default=dict)
    # Verwendete Hugin-Versionen u. a. (→ Konzept 7.9)
    config_versions: Mapped[dict[str, Any]] = mapped_column(JSON, default=dict)
    created_by: Mapped[int] = mapped_column(ForeignKey("users.id"))
    created: Mapped[datetime] = mapped_column(default=now)
    started: Mapped[datetime | None]
    finished: Mapped[datetime | None]


class RunEvent(Base):
    __tablename__ = "run_events"
    __table_args__ = (UniqueConstraint("run_id", "seq"),)

    id: Mapped[int] = mapped_column(BigInteger, Identity(), primary_key=True)
    run_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("task_runs.id", ondelete="CASCADE"))
    seq: Mapped[int] = mapped_column(Integer)
    type: Mapped[str] = mapped_column(String(30))  # status | token | message | error
    data: Mapped[dict[str, Any]] = mapped_column(JSON, default=dict)
    created: Mapped[datetime] = mapped_column(default=now)