"""全能创作 · 会话与消息的写入服务(契约 §1/§2)。

只放「怎么把一条消息安全落库」这类底座能力;agent 循环、工具执行、SSE 在
后续的 creation_agent.py 里,别混进来。
"""
from __future__ import annotations

from datetime import timedelta

from django.core.cache import cache
from django.db import transaction
from django.db.models import Max
from django.utils import timezone

from .models import CreationConversation, CreationMessage


@transaction.atomic
def append_message(
    conversation: CreationConversation,
    *,
    role: str,
    kind: str = CreationMessage.Kind.TEXT,
    text: str = "",
    payload: dict | None = None,
    refs: list | None = None,
    task=None,
) -> CreationMessage:
    """往会话尾部追加一条消息,并刷新 last_active_at。

    seq 在事务里 select_for_update 锁住会话行再取 max+1 —— SSE 流式期间可能有
    并发写(用户抢答 / 轮询回填),不锁会撞 uniq_creation_message_seq。
    """
    locked = CreationConversation.objects.select_for_update().get(pk=conversation.pk)
    next_seq = (locked.messages.aggregate(m=Max("seq"))["m"] or 0) + 1
    message = CreationMessage.objects.create(
        conversation=locked,
        role=role,
        kind=kind,
        text=text,
        payload=payload or {},
        refs=refs or [],
        task=task,
        seq=next_seq,
    )
    locked.last_active_at = timezone.now()
    locked.save(update_fields=["last_active_at", "updated_at"])
    conversation.last_active_at = locked.last_active_at
    return message


def _assets_from_task(task) -> list[dict]:
    """任务落库的资产 → 结果卡要用的 {id,url,cover,type}。

    URL 必须走长期直链:预签名链 1 小时过期,写进消息 payload 第二天就打不开。
    """
    from apps.ai.services import asset_stable_url
    from apps.assets.models import Asset

    items = []
    assets = Asset.objects.filter(
        origin_task=task, is_deleted=False, purged_at__isnull=True,
    ).prefetch_related("files")
    for asset in assets:
        url, cover = asset_stable_url(asset)
        if not url:
            continue
        items.append({
            "id": str(asset.id),
            "url": url,
            "cover": cover or url,
            "type": "video" if asset.asset_type == Asset.Type.VIDEO else "image",
        })
    return items


def _meta_from_task(task, message: CreationMessage) -> dict:
    payload = message.payload or {}
    req = task.request_payload or {}
    model = ""
    if task.model_config_id:
        model = task.model_config.display_name or task.model_config.name
    return {
        "model": model or payload.get("model") or req.get("model") or "",
        "ratio": req.get("ratio") or payload.get("ratio") or "",
        "prompt": payload.get("prompt") or req.get("prompt") or "",
    }


def _message_task(message: CreationMessage):
    """GENERATING 消息挂的任务:优先 FK,payload.task_id 兜底(旧数据 / 序列化往返)。"""
    if message.task_id:
        return message.task
    task_id = (message.payload or {}).get("task_id")
    if not task_id:
        return None
    from .models import AITask

    return AITask.objects.select_related("model_config").filter(id=task_id).first()


@transaction.atomic
def fail_generating_message(message: CreationMessage, error: str) -> CreationMessage:
    """生成失败:GENERATING 原地改成 ERROR,不另开一条,避免中间态刷屏。"""
    message.kind = CreationMessage.Kind.ERROR
    message.text = (error or "生成失败")[:500]
    message.save(update_fields=["kind", "text", "updated_at"])
    conversation = message.conversation
    conversation.status = CreationConversation.Status.FAILED
    conversation.last_active_at = timezone.now()
    conversation.save(update_fields=["status", "last_active_at", "updated_at"])
    return message


def sync_generating_message(message: CreationMessage) -> bool:
    """看挂着的 AITask 是否已经终态,是就把 GENERATING 改成 RESULT / ERROR。

    出图/出片在 worker 里跑,agent 只提交。前端轮询 GET 会话时靠这个回填;
    worker 结束时也会调一次,不用干等到下一次轮询。
    返回是否改了这条消息。
    """
    from .models import AITask

    if message.kind != CreationMessage.Kind.GENERATING:
        return False
    task = _message_task(message)
    if task is None:
        return False
    if task.status == AITask.Status.SUCCEEDED:
        assets = _assets_from_task(task)
        if not assets:
            return False  # 状态已成功但资产还没落(极端竞态),下轮再试
        finish_generating_message(message, assets=assets, meta=_meta_from_task(task, message))
        return True
    if task.status in (AITask.Status.FAILED, AITask.Status.CANCELLED):
        fail_generating_message(message, task.error_message or "生成失败")
        return True
    return False


def sync_generating_messages(conversation: CreationConversation) -> int:
    """把一条会话里所有已结束的 GENERATING 回填。返回改了几条。"""
    pending = list(
        conversation.messages.filter(kind=CreationMessage.Kind.GENERATING)
        .select_related("task", "task__model_config")
    )
    return sum(1 for message in pending if sync_generating_message(message))


def sync_generating_for_task(task) -> int:
    """worker / poll 终态后:只扫挂在这个任务上的 GENERATING。失败不能向外抛。"""
    try:
        pending = list(
            CreationMessage.objects.filter(
                task=task, kind=CreationMessage.Kind.GENERATING,
            ).select_related("conversation", "task", "task__model_config")
        )
        return sum(1 for message in pending if sync_generating_message(message))
    except Exception:  # noqa: BLE001 — 回填失败不能把已经成功的出图任务打成失败
        import logging

        logging.getLogger(__name__).warning(
            "omni create: sync generating for task %s failed", getattr(task, "id", "?"),
            exc_info=True,
        )
        return 0


@transaction.atomic
def finish_generating_message(message: CreationMessage, *, assets: list[dict], meta: dict) -> CreationMessage:
    """把「生成中」原地改成「结果」(契约 §2:不新增消息,避免中间态刷屏)。

    重生成是**新开一条** GENERATING → RESULT,所以对话流仍然是往下叠加;
    这里改的只是同一次生成自己的中间态。
    """
    message.kind = CreationMessage.Kind.RESULT
    message.payload = {**(message.payload or {}), **meta, "assets": assets}
    message.save(update_fields=["kind", "payload", "updated_at"])
    conversation = message.conversation
    conversation.status = CreationConversation.Status.COMPLETED
    conversation.last_active_at = timezone.now()
    conversation.save(update_fields=["status", "last_active_at", "updated_at"])
    return message


def pin_refs(conversation: CreationConversation, refs: list[dict]) -> list[dict]:
    """把本轮引用的实体并进「实体锁定」。按 (type, id) 去重,保留首次出现的顺序 ——
    每轮无条件带上它们,这是多次生成之间锁脸/锁商品的唯一手段(契约 §5)。
    """
    merged = list(conversation.pinned_refs or [])
    seen = {(item.get("type"), str(item.get("id"))) for item in merged}
    changed = False
    for ref in refs or []:
        ref_type, ref_id = ref.get("type"), ref.get("id")
        if not ref_type or not ref_id:
            continue  # 缺 type/id 的 ref 解析不出实体,直接丢
        key = (ref_type, str(ref_id))
        if key in seen:
            continue
        merged.append(ref)
        seen.add(key)
        changed = True
    if changed:
        conversation.pinned_refs = merged
        conversation.save(update_fields=["pinned_refs", "updated_at"])
    return merged


# ---------------------------------------------------------------- Agent 在途锁(一账号同时只整理一份方案)

AGENT_LOCK_TTL_SECONDS = 20 * 60
AGENT_STALE_MINUTES = 20
AGENT_BUSY_DETAIL = "当前已有对话正在整理方案，请等待完成后再试"


def agent_lock_key(team_id) -> str:
    return f"omni:agent:{team_id}"


def release_agent_lock(team_id, conversation_id=None) -> None:
    """释放团队级 agent 锁。传 conversation_id 时只在锁仍指向该会话时删,避免误伤。"""
    key = agent_lock_key(team_id)
    if conversation_id is None:
        cache.delete(key)
        return
    if str(cache.get(key) or "") == str(conversation_id):
        cache.delete(key)


def acquire_agent_lock(team_id, conversation_id) -> bool:
    """cache.add 原子占坑。成功返回 True;已有占用返回 False。"""
    return bool(cache.add(agent_lock_key(team_id), str(conversation_id), timeout=AGENT_LOCK_TTL_SECONDS))


def cleanup_stale_agent_planning(team) -> int:
    """把超时仍卡在 planning 的会话清回 idle,并尝试释放对应 Redis 锁。"""
    from django.db.models import Q

    cutoff = timezone.now() - timedelta(minutes=AGENT_STALE_MINUTES)
    stale = list(
        CreationConversation.objects.filter(
            team=team,
            agent_status=CreationConversation.AgentStatus.PLANNING,
            is_deleted=False,
        ).filter(
            # started_at 为空也当过期(异常写入)
            Q(agent_started_at__lt=cutoff) | Q(agent_started_at__isnull=True)
        )[:20]
    )
    cleared = 0
    now = timezone.now()
    for conv in stale:
        updated = CreationConversation.objects.filter(
            pk=conv.pk,
            agent_status=CreationConversation.AgentStatus.PLANNING,
        ).update(
            agent_status=CreationConversation.AgentStatus.IDLE,
            agent_started_at=None,
            updated_at=now,
        )
        if updated:
            release_agent_lock(team.id, conv.id)
            cleared += 1
    return cleared


def find_planning_conversation(team, *, exclude_id=None):
    """返回团队里仍在 planning 的会话(已先清过期)。"""
    cleanup_stale_agent_planning(team)
    qs = CreationConversation.objects.filter(
        team=team,
        agent_status=CreationConversation.AgentStatus.PLANNING,
        is_deleted=False,
    )
    if exclude_id is not None:
        qs = qs.exclude(pk=exclude_id)
    return qs.order_by("-agent_started_at", "-last_active_at").first()


def team_agent_busy(team, *, exclude_id=None) -> bool:
    """DB planning 或 Redis 锁任一占用 → 忙。exclude_id 用于同一会话续跑自检。"""
    if find_planning_conversation(team, exclude_id=exclude_id) is not None:
        return True
    holder = cache.get(agent_lock_key(team.id))
    if not holder:
        return False
    if exclude_id is not None and str(holder) == str(exclude_id):
        return False
    # 锁还在但持有会话已不在 planning → 孤儿锁,清掉放行
    still = CreationConversation.objects.filter(
        id=holder,
        team=team,
        agent_status=CreationConversation.AgentStatus.PLANNING,
        is_deleted=False,
    ).exists()
    if not still:
        release_agent_lock(team.id, holder)
        return False
    return True


def begin_agent_planning(conversation: CreationConversation) -> bool:
    """占 Redis 锁并把会话标成 planning。失败(冲突)返回 False,调用方回 409。"""
    team_id = conversation.team_id
    if team_agent_busy(conversation.team, exclude_id=conversation.id):
        return False
    if not acquire_agent_lock(team_id, conversation.id):
        # 锁被别人占了;若锁指向自己(重入),允许续写状态
        holder = cache.get(agent_lock_key(team_id))
        if str(holder or "") != str(conversation.id):
            return False
    now = timezone.now()
    CreationConversation.objects.filter(pk=conversation.pk).update(
        agent_status=CreationConversation.AgentStatus.PLANNING,
        agent_started_at=now,
        last_active_at=now,
        updated_at=now,
    )
    conversation.agent_status = CreationConversation.AgentStatus.PLANNING
    conversation.agent_started_at = now
    conversation.last_active_at = now
    clear_agent_cancel(conversation.id)
    return True


def finish_agent_planning(
    conversation: CreationConversation,
    *,
    awaiting_user: bool = False,
) -> None:
    """Celery finally:写回 agent_status 并释放锁。"""
    status = (
        CreationConversation.AgentStatus.AWAITING_USER
        if awaiting_user
        else CreationConversation.AgentStatus.IDLE
    )
    now = timezone.now()
    CreationConversation.objects.filter(pk=conversation.pk).update(
        agent_status=status,
        agent_started_at=None,
        last_active_at=now,
        updated_at=now,
    )
    conversation.agent_status = status
    conversation.agent_started_at = None
    release_agent_lock(conversation.team_id, conversation.id)
    # 正常结束也清掉取消标记,避免下一轮误判
    clear_agent_cancel(conversation.id)


def agent_cancel_key(conversation_id) -> str:
    return f"omni:agent:cancel:{conversation_id}"


def clear_agent_cancel(conversation_id) -> None:
    cache.delete(agent_cancel_key(conversation_id))


def is_agent_cancel_requested(conversation_id) -> bool:
    """Celery tool round 之间读:用户点了终止则 True。"""
    return bool(cache.get(agent_cancel_key(conversation_id)))


def request_agent_cancel(conversation: CreationConversation) -> bool:
    """用户终止整理方案:打 Redis 取消标,立刻 idle + 释放团队锁。

    仅当当前仍是 planning 时成功。Celery 在下一轮工具间隙看到标后停跑,
    已落库消息保留。返回 True=已受理, False=当时不是 planning(调用方回 409)。
    """
    # 先打标,再收态 —— worker 在长 LLM 调用回来后也能看见
    cache.set(agent_cancel_key(conversation.id), "1", timeout=AGENT_LOCK_TTL_SECONDS)
    updated = CreationConversation.objects.filter(
        pk=conversation.pk,
        agent_status=CreationConversation.AgentStatus.PLANNING,
    ).update(
        agent_status=CreationConversation.AgentStatus.IDLE,
        agent_started_at=None,
        last_active_at=timezone.now(),
        updated_at=timezone.now(),
    )
    if not updated:
        # 已经不是 planning(竞态完成/别人清了);仍留标一会儿无害,清掉避免脏状态
        clear_agent_cancel(conversation.id)
        conversation.refresh_from_db(fields=["agent_status", "agent_started_at"])
        return False
    conversation.agent_status = CreationConversation.AgentStatus.IDLE
    conversation.agent_started_at = None
    release_agent_lock(conversation.team_id, conversation.id)
    return True