"""每日产出清算。

释放规则：
1. 授权金额在整个授权天数内线性释放。授权天数取 license 起止日期之差。
2. 在线率 = 当日授权窗口内的在线秒数 / 当日授权有效秒数。
   尚未关闭的在线区间，若最后心跳已超过超时时间，只计算到最后一次心跳。
3. 任务响应率 = 校验通过且执行成功的任务数 / 当日内下发任务数。
4. 当天没有下发任务时，表现系数等于在线率，避免调度器故障误伤节点。
   有任务时，表现系数 = 在线权重 × 在线率 + 任务权重 × 响应率。
5. 算力产出 = 授权金额 × 表现系数。
   当日积分 = 算力产出 / 授权天数。
6. 单节点累计积分不超过授权金额。已存在的当日流水不会被覆盖。
"""

from __future__ import annotations

from dataclasses import dataclass
from datetime import date, datetime, timedelta
from decimal import Decimal

from sqlalchemy import or_, select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session

from app.clock import day_bounds, utcnow
from app.config import settings
from app.errors import AppError
from app.models import ComputeNode, ComputeTask, NodeYield, TaskStatus, UptimeInterval, YieldStatus
from app.money import money, rate, ratio, to_decimal
from app.services.common import get_node_by_sn
from app.services.tasks import expire_overdue_tasks


@dataclass
class YieldComputation:
    eligible: bool
    yield_date: date
    online_seconds: int = 0
    eligible_seconds: int = 0
    online_rate: Decimal = Decimal("0")
    tasks_dispatched: int = 0
    tasks_completed: int = 0
    task_response_rate: Decimal = Decimal("0")
    online_weight: Decimal = Decimal("0")
    task_weight: Decimal = Decimal("0")
    performance: Decimal = Decimal("0")
    compute_output: Decimal = Decimal("0")
    points_delta: Decimal = Decimal("0")
    cycle_days: int = 0


@dataclass
class SettleSummary:
    yield_date: date
    created: int
    skipped: int
    total_points: Decimal
    is_partial: bool


def compute_node_yield(
    session: Session,
    node: ComputeNode,
    yield_date: date,
    now: datetime | None = None,
) -> YieldComputation:
    moment = now or utcnow()
    day_start, day_end = day_bounds(yield_date)
    window_start = max(day_start, node.licensed_at)
    window_end = min(day_end, node.license_expires_at)
    cycle_days = (node.license_expires_at.date() - node.licensed_at.date()).days
    if window_end <= window_start or cycle_days <= 0:
        return YieldComputation(eligible=False, yield_date=yield_date, cycle_days=max(cycle_days, 0))

    eligible_seconds = int((window_end - window_start).total_seconds())
    online_seconds = min(_online_seconds(session, node, window_start, window_end, moment), eligible_seconds)
    online_rate = ratio(online_seconds, eligible_seconds)

    tasks = session.scalars(
        select(ComputeTask).where(
            ComputeTask.node_id == node.id,
            ComputeTask.dispatched_at >= window_start,
            ComputeTask.dispatched_at < window_end,
        )
    ).all()
    tasks_dispatched = len(tasks)
    tasks_completed = sum(1 for task in tasks if task.status == TaskStatus.COMPLETED)
    response_rate = ratio(tasks_completed, tasks_dispatched) if tasks_dispatched else Decimal("0")

    if tasks_dispatched == 0:
        applied_online = Decimal("1")
        applied_task = Decimal("0")
    else:
        applied_online = to_decimal(settings.online_weight)
        applied_task = to_decimal(settings.task_weight)
    performance = rate(applied_online * online_rate + applied_task * response_rate)
    compute_output = money(to_decimal(node.purchase_amount) * performance)
    points_delta = money(compute_output / Decimal(cycle_days))
    points_delta = min(points_delta, _remaining_points(session, node))

    return YieldComputation(
        eligible=True,
        yield_date=yield_date,
        online_seconds=online_seconds,
        eligible_seconds=eligible_seconds,
        online_rate=online_rate,
        tasks_dispatched=tasks_dispatched,
        tasks_completed=tasks_completed,
        task_response_rate=response_rate,
        online_weight=money(applied_online),
        task_weight=money(applied_task),
        performance=performance,
        compute_output=compute_output,
        points_delta=points_delta,
        cycle_days=cycle_days,
    )


def settle_yield_date(session: Session, yield_date: date, now: datetime | None = None) -> SettleSummary:
    """清算指定 UTC 日。每个节点当天已有流水时跳过，保证脚本重复执行不会重复入账。"""
    moment = now or utcnow()
    if yield_date > moment.date():
        raise AppError("不能清算未来日期")
    expire_overdue_tasks(session, moment)
    day_start, day_end = day_bounds(yield_date)
    nodes = session.scalars(
        select(ComputeNode)
        .where(
            ComputeNode.licensed_at < day_end,
            ComputeNode.license_expires_at > day_start,
        )
        .order_by(ComputeNode.id)
    ).all()
    created = 0
    skipped = 0
    total = Decimal("0")
    partial = yield_date == moment.date()
    for node in nodes:
        exists = session.scalar(
            select(NodeYield.id).where(NodeYield.node_id == node.id, NodeYield.yield_date == yield_date)
        )
        if exists is not None:
            skipped += 1
            continue
        computed = compute_node_yield(session, node, yield_date, moment)
        if not computed.eligible:
            continue
        try:
            with session.begin_nested():
                session.add(_to_row(node, computed, partial))
        except IntegrityError:
            skipped += 1
            continue
        created += 1
        total += computed.points_delta
    return SettleSummary(
        yield_date=yield_date,
        created=created,
        skipped=skipped,
        total_points=money(total),
        is_partial=partial,
    )


def list_node_yields(session: Session, sn: str) -> list[NodeYield]:
    node = get_node_by_sn(session, sn.strip())
    return list(
        session.scalars(
            select(NodeYield).where(NodeYield.node_id == node.id).order_by(NodeYield.yield_date.desc())
        ).all()
    )


def _online_seconds(
    session: Session,
    node: ComputeNode,
    window_start: datetime,
    window_end: datetime,
    now: datetime,
) -> int:
    intervals = session.scalars(
        select(UptimeInterval).where(
            UptimeInterval.node_id == node.id,
            UptimeInterval.started_at < window_end,
            or_(UptimeInterval.ended_at.is_(None), UptimeInterval.ended_at > window_start),
        )
    ).all()
    total = 0
    for interval in intervals:
        start = max(interval.started_at, window_start)
        end = min(_proven_end(interval, node, now), window_end)
        if end > start:
            total += int((end - start).total_seconds())
    return total


def _proven_end(interval: UptimeInterval, node: ComputeNode, now: datetime) -> datetime:
    """开放区间只能证明到最后一次心跳；心跳仍在超时窗口内才延续到当前时间。"""
    if interval.ended_at is not None:
        return interval.ended_at
    last_seen = node.last_heartbeat_at or interval.started_at
    if last_seen + timedelta(minutes=settings.heartbeat_timeout_minutes) < now:
        return last_seen
    return now


def _remaining_points(session: Session, node: ComputeNode) -> Decimal:
    paid_rows = session.scalars(select(NodeYield.points_delta).where(NodeYield.node_id == node.id)).all()
    paid = sum((to_decimal(item) for item in paid_rows), Decimal("0"))
    remaining = to_decimal(node.purchase_amount) - paid
    if remaining <= 0:
        return Decimal("0")
    return money(remaining)


def _to_row(node: ComputeNode, computed: YieldComputation, partial: bool) -> NodeYield:
    return NodeYield(
        node_id=node.id,
        user_id=node.user_id,
        yield_date=computed.yield_date,
        compute_output=computed.compute_output,
        points_delta=computed.points_delta,
        online_seconds=computed.online_seconds,
        eligible_seconds=computed.eligible_seconds,
        online_rate=computed.online_rate,
        tasks_dispatched=computed.tasks_dispatched,
        tasks_completed=computed.tasks_completed,
        task_response_rate=computed.task_response_rate,
        online_weight=computed.online_weight,
        task_weight=computed.task_weight,
        performance=computed.performance,
        cycle_days=computed.cycle_days,
        status=YieldStatus.SETTLED,
        is_partial=partial,
        created_at=utcnow(),
    )