company-ai-platform/app/modules/reports/service.py

from datetime import date, datetime, timedelta
from decimal import Decimal
from typing import Any

from sqlalchemy import func, or_, select
from sqlalchemy.orm import Session

from app.core.constants import ActorValue
from app.core.pagination import bounded_limit
from app.core.time import utc_now
from app.modules.audit.constants import AuditAction, AuditSource, AuditTargetType
from app.modules.audit.schemas import AuditLogCreate
from app.modules.audit.service import AuditService
from app.modules.business.constants import (
    ATTENDANCE_ABNORMAL_STATUSES,
    DONE_STATUSES,
    GENERATED_RISK_EVENT_TYPES,
    PROJECT_CLOSED_STATUSES,
    PENDING_APPROVAL_STATUSES,
    SUPPLIER_RISK_LEVELS,
    RiskLevel,
    StatusValue,
)
from app.modules.business.models import (
    AttendanceRecord,
    Expense,
    FundAccount,
    Procurement,
    Project,
    ReportPushRun,
    RiskEvent,
    Supplier,
    WorkReport,
    WorkTask,
)
from app.modules.business.service import serialize_model
from app.modules.feishu.service import FeishuService
from app.modules.reports.constants import (
    ATTENTION_SCORE_THRESHOLD,
    HEALTH_PENALTY_WEIGHTS,
    HEALTH_SCORE_MAX,
    HEALTH_SCORE_MIN,
    HEALTHY_SCORE_THRESHOLD,
    LIFECYCLE_RISK_SCORE_WEIGHTS,
    HealthLevel,
    LifecycleAttentionKey,
    LifecycleFilterKey,
    LifecycleResponseKey,
    LifecycleSection,
    MetricKey,
    ReportResponseKey,
    ReportPushStatus,
    ReportStatus,
    ReportText,
    ReportTitle,
    ReportType,
    WorkReportMetricKey,
)
from app.modules.risk.constants import RiskSummaryKey, risk_level_for_score
from app.modules.risk.service import RiskService


def _money(value: Decimal | int | float | None) -> str:
    """Format a numeric value as a two-decimal money string."""

    amount = Decimal(value or 0)
    return f"{amount:,.2f}"


def _json_safe(value: Any) -> Any:
    """Convert nested report payloads into JSON-storable values."""

    if isinstance(value, Decimal):
        return float(value)
    if isinstance(value, (datetime, date)):
        return value.isoformat()
    if isinstance(value, list):
        return [_json_safe(item) for item in value]
    if isinstance(value, dict):
        return {key: _json_safe(item) for key, item in value.items()}
    return value


def _next_code(prefix: str) -> str:
    """Build a compact unique code for generated report records."""

    return f"{prefix}-{utc_now():%Y%m%d%H%M%S%f}"


def _rate(numerator: int | Decimal, denominator: int | Decimal) -> float:
    """Return a rounded percentage rate, using zero when the denominator is empty."""

    if not denominator:
        return 0.0
    return round(float(numerator) / float(denominator) * 100, 2)


def _as_decimal(value: Decimal | int | float | None) -> Decimal:
    return Decimal(str(value or 0))


class ReportService:
    """Build operational reports and push them through Feishu."""

    def __init__(self, db: Session):
        self.db = db
        self.risks = RiskService(db)

    def _count(self, model: type, *conditions: Any) -> int:
        stmt = select(func.count()).select_from(model)
        for condition in conditions:
            stmt = stmt.where(condition)
        return int(self.db.execute(stmt).scalar() or 0)

    def _sum(self, column: Any, *conditions: Any) -> Decimal:
        stmt = select(func.sum(column))
        for condition in conditions:
            stmt = stmt.where(condition)
        return _as_decimal(self.db.execute(stmt).scalar())

    def _avg(self, column: Any, *conditions: Any) -> float:
        stmt = select(func.avg(column))
        for condition in conditions:
            stmt = stmt.where(condition)
        value = self.db.execute(stmt).scalar()
        return round(float(value or 0), 2)

    def _group_counts(self, model: type, column: Any, *conditions: Any) -> dict[str, int]:
        stmt = select(column, func.count()).select_from(model)
        for condition in conditions:
            stmt = stmt.where(condition)
        stmt = stmt.group_by(column)
        return {
            str(key or ReportStatus.UNKNOWN): int(count)
            for key, count in self.db.execute(stmt).all()
        }

    def _records(
        self,
        model: type,
        *conditions: Any,
        limit: int = 10,
        order_by: Any | None = None,
    ) -> list[Any]:
        stmt = select(model)
        for condition in conditions:
            stmt = stmt.where(condition)
        if order_by is not None:
            stmt = stmt.order_by(order_by)
        else:
            stmt = stmt.order_by(model.id.desc())
        return list(self.db.execute(stmt.limit(bounded_limit(limit))).scalars())

    def create_push_run(
        self,
        report_type: str,
        title: str | None,
        receive_id: str | None,
        receive_id_type: str,
        actor: str,
        status: str = ReportPushStatus.PENDING,
    ) -> ReportPushRun:
        record = ReportPushRun(
            code=_next_code("PUSH"),
            report_type=report_type,
            title=title,
            receive_id=receive_id,
            receive_id_type=receive_id_type,
            status=status,
            actor=actor,
            queued_at=utc_now(),
        )
        self.db.add(record)
        self.db.commit()
        self.db.refresh(record)
        return record

    def update_push_run(
        self,
        code: str,
        status: str,
        task_id: str | None = None,
        provider_response: dict[str, Any] | None = None,
        error_message: str | None = None,
        sent: bool = False,
    ) -> ReportPushRun:
        record = self._get_push_run(code)
        record.status = status
        if task_id is not None:
            record.task_id = task_id
        if provider_response is not None:
            record.provider_response = _json_safe(provider_response)
        record.error_message = error_message
        if sent:
            record.sent_at = utc_now()
        self.db.commit()
        self.db.refresh(record)
        return record

    def list_push_runs(
        self,
        status_filter: str | None = None,
        limit: int = 100,
    ) -> list[dict[str, Any]]:
        stmt = select(ReportPushRun).order_by(ReportPushRun.id.desc()).limit(
            bounded_limit(limit)
        )
        if status_filter:
            stmt = (
                select(ReportPushRun)
                .where(ReportPushRun.status == status_filter)
                .order_by(ReportPushRun.id.desc())
                .limit(bounded_limit(limit))
            )
        return [serialize_model(item) for item in self.db.execute(stmt).scalars()]

    def get_push_run(self, code: str) -> dict[str, Any]:
        return serialize_model(self._get_push_run(code))

    def _get_push_run(self, code: str) -> ReportPushRun:
        from fastapi import HTTPException, status

        record = self.db.execute(
            select(ReportPushRun).where(ReportPushRun.code == code)
        ).scalar_one_or_none()
        if record is None:
            raise HTTPException(
                status_code=status.HTTP_404_NOT_FOUND,
                detail="Report push run not found",
            )
        return record

    def daily_brief(self) -> dict:
        project_count = self._count(Project)
        task_count = self._count(WorkTask)
        procurement_pending = self._count(
            Procurement,
            Procurement.approval_status.in_(PENDING_APPROVAL_STATUSES),
        )
        expense_pending = self._count(
            Expense,
            Expense.approval_status.in_(PENDING_APPROVAL_STATUSES),
        )
        fund_total = (
            self.db.execute(select(func.sum(FundAccount.current_balance))).scalar()
            or Decimal("0")
        )
        risk_summary = self.risks.summary()
        attendance = self.attendance_summary()
        lines = [
            f"- 项目总数：{project_count}",
            f"- 任务总数：{task_count}",
            f"- 待处理采购：{procurement_pending}",
            f"- 待处理费用：{expense_pending}",
            f"- 当前账户总余额：{_money(fund_total)}",
            (
                f"- 今日打卡记录：{attendance[ReportResponseKey.TOTAL]}，"
                f"异常：{attendance[ReportResponseKey.ABNORMAL_TOTAL]}"
            ),
            f"- 逾期任务：{len(risk_summary[RiskSummaryKey.OVERDUE_TASKS])}",
            f"- 延期项目：{len(risk_summary[RiskSummaryKey.DELAYED_PROJECTS])}",
            f"- 超预算项目：{len(risk_summary[RiskSummaryKey.OVER_BUDGET_PROJECTS])}",
            f"- 资金风险账户：{len(risk_summary[RiskSummaryKey.FUND_RISKS])}",
            f"- 供应商风险：{len(risk_summary[RiskSummaryKey.SUPPLIER_RISKS])}",
            f"- 打开风险事件：{len(risk_summary[RiskSummaryKey.OPEN_EVENTS])}",
            f"- 综合风险等级：{risk_summary[RiskSummaryKey.RISK_LEVEL]}",
        ]
        return {
            ReportResponseKey.TITLE: ReportTitle.DAILY_BRIEF,
            ReportResponseKey.LINES: lines,
            ReportResponseKey.CONTENT: "\n".join(lines),
        }

    def project_weekly(self) -> dict:
        active = self._count(
            Project,
            Project.status.notin_(PROJECT_CLOSED_STATUSES),
        )
        delayed = self.risks.delayed_projects()
        over_budget = self.risks.over_budget_projects()
        open_risks = self.risks.list_events(status_filter=StatusValue.OPEN)
        lines = [
            f"- 活跃项目：{active}",
            f"- 延期项目：{len(delayed)}",
            f"- 超预算项目：{len(over_budget)}",
            f"- 打开风险事件：{len(open_risks)}",
            "- 需要管理层关注：",
        ]
        for item in delayed[:10]:
            lines.append(
                f"  - 延期：{item.get('code')} {item.get('name')}，"
                f"负责人 {item.get('owner')}"
            )
        for item in over_budget[:10]:
            lines.append(f"  - 超预算：{item.get('code')} {item.get('name')}")
        return {
            ReportResponseKey.TITLE: ReportTitle.PROJECT_WEEKLY,
            ReportResponseKey.LINES: lines,
            ReportResponseKey.CONTENT: "\n".join(lines),
        }

    def project_lifecycle_report(
        self,
        project_code: str | None = None,
        owner: str | None = None,
        period_start: date | None = None,
        period_end: date | None = None,
        include_ai: bool = False,
        actor: str = ActorValue.API,
    ) -> dict[str, Any]:
        """Build a full lifecycle report for project progress, delivery, cost, and risk."""

        filters = self._lifecycle_filters(project_code, owner, period_start, period_end)
        project_conditions = filters[LifecycleSection.PROJECTS]
        task_conditions = filters[LifecycleSection.TASKS]
        procurement_conditions = filters[LifecycleSection.PROCUREMENTS]
        expense_conditions = filters[LifecycleSection.EXPENSES]
        attendance_conditions = filters[LifecycleSection.ATTENDANCE]
        risk_conditions = filters[LifecycleSection.RISKS]

        project_stats = self._lifecycle_project_stats(project_conditions)
        task_stats = self._lifecycle_task_stats(task_conditions)
        procurement_stats = self._lifecycle_procurement_stats(procurement_conditions)
        expense_stats = self._lifecycle_expense_stats(expense_conditions)
        fund_stats = self._lifecycle_fund_stats()
        supplier_stats = self._lifecycle_supplier_stats()
        attendance_stats = self._lifecycle_attendance_stats(attendance_conditions)
        risk_stats = self._lifecycle_risk_stats(
            project_conditions,
            task_conditions,
            risk_conditions,
        )
        include_global_risk = not (project_code or owner)
        health = self._lifecycle_health(
            project_stats,
            task_stats,
            risk_stats,
            supplier_stats,
            include_global_risk,
        )
        attention = self._lifecycle_attention(project_conditions, task_conditions)
        recommendations = self._lifecycle_recommendations(
            project_stats,
            task_stats,
            procurement_stats,
            expense_stats,
            fund_stats,
            supplier_stats,
            risk_stats,
            include_global_risk,
        )

        metrics = {
            LifecycleSection.HEALTH: health,
            LifecycleSection.PROJECTS: project_stats,
            LifecycleSection.TASKS: task_stats,
            LifecycleSection.PROCUREMENTS: procurement_stats,
            LifecycleSection.EXPENSES: expense_stats,
            LifecycleSection.FUNDS: fund_stats,
            LifecycleSection.SUPPLIERS: supplier_stats,
            LifecycleSection.ATTENDANCE: attendance_stats,
            LifecycleSection.RISKS: risk_stats,
        }
        lines = self._lifecycle_lines(
            filters[LifecycleFilterKey.LABELS],
            metrics,
            recommendations,
        )
        report = {
            LifecycleResponseKey.TITLE: ReportTitle.PROJECT_LIFECYCLE,
            LifecycleResponseKey.FILTERS: filters[LifecycleFilterKey.LABELS],
            LifecycleResponseKey.METRICS: _json_safe(metrics),
            LifecycleResponseKey.ATTENTION: _json_safe(attention),
            LifecycleResponseKey.RECOMMENDATIONS: recommendations,
            LifecycleResponseKey.LINES: lines,
            LifecycleResponseKey.CONTENT: "\n".join(lines),
        }
        if include_ai:
            report[LifecycleResponseKey.AI_ANALYSIS] = self._lifecycle_ai_analysis(report, actor)
        return report

    def _lifecycle_filters(
        self,
        project_code: str | None,
        owner: str | None,
        period_start: date | None,
        period_end: date | None,
    ) -> dict[str, Any]:
        project_conditions: list[Any] = []
        task_conditions: list[Any] = []
        procurement_conditions: list[Any] = []
        expense_conditions: list[Any] = []
        attendance_conditions: list[Any] = []
        risk_conditions: list[Any] = []
        labels = {
            LifecycleFilterKey.PROJECT_CODE: project_code,
            LifecycleFilterKey.OWNER: owner,
            LifecycleFilterKey.PERIOD_START: period_start.isoformat() if period_start else None,
            LifecycleFilterKey.PERIOD_END: period_end.isoformat() if period_end else None,
        }

        if project_code:
            project_conditions.append(Project.code == project_code)
            task_conditions.append(WorkTask.project_code == project_code)
            procurement_conditions.append(Procurement.project_code == project_code)
            expense_conditions.append(Expense.project_code == project_code)
            attendance_conditions.append(AttendanceRecord.project_code == project_code)
            risk_conditions.append(RiskEvent.project_code == project_code)
        if owner:
            project_conditions.append(Project.owner == owner)
            task_conditions.append(WorkTask.owner == owner)
            risk_conditions.append(RiskEvent.owner == owner)
        if period_start:
            project_conditions.append(
                or_(Project.due_date.is_(None), Project.due_date >= period_start)
            )
            task_conditions.append(WorkTask.due_date >= period_start)
            attendance_conditions.append(AttendanceRecord.work_date >= period_start)
            risk_conditions.append(
                RiskEvent.detected_at >= datetime.combine(period_start, datetime.min.time())
            )
        if period_end:
            project_conditions.append(
                or_(Project.start_date.is_(None), Project.start_date <= period_end)
            )
            task_conditions.append(WorkTask.due_date <= period_end)
            attendance_conditions.append(AttendanceRecord.work_date <= period_end)
            risk_conditions.append(
                RiskEvent.detected_at <= datetime.combine(period_end, datetime.max.time())
            )
        if period_start:
            start_at = datetime.combine(period_start, datetime.min.time())
            procurement_conditions.append(Procurement.created_at >= start_at)
            expense_conditions.append(Expense.created_at >= start_at)
        if period_end:
            end_at = datetime.combine(period_end, datetime.max.time())
            procurement_conditions.append(Procurement.created_at <= end_at)
            expense_conditions.append(Expense.created_at <= end_at)

        return {
            LifecycleFilterKey.LABELS: labels,
            LifecycleSection.PROJECTS: project_conditions,
            LifecycleSection.TASKS: task_conditions,
            LifecycleSection.PROCUREMENTS: procurement_conditions,
            LifecycleSection.EXPENSES: expense_conditions,
            LifecycleSection.ATTENDANCE: attendance_conditions,
            LifecycleSection.RISKS: risk_conditions,
        }

    def _lifecycle_project_stats(self, conditions: list[Any]) -> dict[str, Any]:
        total = self._count(Project, *conditions)
        active = self._count(Project, Project.status.notin_(PROJECT_CLOSED_STATUSES), *conditions)
        closed = total - active
        budget_total = self._sum(Project.budget_amount, *conditions)
        actual_total = self._sum(Project.actual_amount, *conditions)
        delayed = self._count(
            Project,
            Project.due_date.is_not(None),
            Project.due_date < date.today(),
            Project.status.notin_(PROJECT_CLOSED_STATUSES),
            *conditions,
        )
        over_budget = self._count(
            Project,
            Project.budget_amount > 0,
            Project.actual_amount > Project.budget_amount,
            *conditions,
        )
        return {
            MetricKey.TOTAL: total,
            MetricKey.ACTIVE: active,
            MetricKey.CLOSED: closed,
            MetricKey.AVERAGE_PROGRESS_PERCENT: self._avg(
                Project.progress_percent,
                *conditions,
            ),
            MetricKey.BY_STATUS: self._group_counts(Project, Project.status, *conditions),
            MetricKey.BY_RISK_LEVEL: self._group_counts(Project, Project.risk_level, *conditions),
            MetricKey.BUDGET_TOTAL: budget_total,
            MetricKey.ACTUAL_TOTAL: actual_total,
            MetricKey.BUDGET_USAGE_RATE: _rate(actual_total, budget_total),
            MetricKey.DELAYED: delayed,
            MetricKey.OVER_BUDGET: over_budget,
        }

    def _lifecycle_task_stats(self, conditions: list[Any]) -> dict[str, Any]:
        total = self._count(WorkTask, *conditions)
        completed = self._count(WorkTask, WorkTask.status.in_(DONE_STATUSES), *conditions)
        overdue = self._count(
            WorkTask,
            WorkTask.due_date.is_not(None),
            WorkTask.due_date < date.today(),
            WorkTask.status.notin_(DONE_STATUSES),
            *conditions,
        )
        blocked = self._count(
            WorkTask,
            WorkTask.blocker.is_not(None),
            WorkTask.status.notin_(DONE_STATUSES),
            *conditions,
        )
        return {
            MetricKey.TOTAL: total,
            MetricKey.COMPLETED: completed,
            MetricKey.OPEN: total - completed,
            MetricKey.OVERDUE: overdue,
            MetricKey.BLOCKED: blocked,
            MetricKey.COMPLETION_RATE: _rate(completed, total),
            MetricKey.BY_STATUS: self._group_counts(WorkTask, WorkTask.status, *conditions),
            MetricKey.BY_PRIORITY: self._group_counts(WorkTask, WorkTask.priority, *conditions),
        }

    def _lifecycle_procurement_stats(self, conditions: list[Any]) -> dict[str, Any]:
        total = self._count(Procurement, *conditions)
        pending_approval = self._count(
            Procurement,
            Procurement.approval_status.in_(PENDING_APPROVAL_STATUSES),
            *conditions,
        )
        pending_delivery = self._count(
            Procurement,
            Procurement.delivery_status.notin_(DONE_STATUSES),
            *conditions,
        )
        unpaid = self._count(
            Procurement,
            Procurement.payment_status != StatusValue.PAID,
            *conditions,
        )
        expected_total = self._sum(Procurement.expected_amount, *conditions)
        actual_total = self._sum(Procurement.actual_amount, *conditions)
        return {
            MetricKey.TOTAL: total,
            MetricKey.PENDING_APPROVAL: pending_approval,
            MetricKey.PENDING_DELIVERY: pending_delivery,
            MetricKey.UNPAID: unpaid,
            MetricKey.EXPECTED_TOTAL: expected_total,
            MetricKey.ACTUAL_TOTAL: actual_total,
            MetricKey.ACTUAL_VS_EXPECTED_RATE: _rate(actual_total, expected_total),
        }

    def _lifecycle_expense_stats(self, conditions: list[Any]) -> dict[str, Any]:
        total = self._count(Expense, *conditions)
        pending_approval = self._count(
            Expense,
            Expense.approval_status.in_(PENDING_APPROVAL_STATUSES),
            *conditions,
        )
        unpaid = self._count(Expense, Expense.payment_status != StatusValue.PAID, *conditions)
        return {
            MetricKey.TOTAL: total,
            MetricKey.PENDING_APPROVAL: pending_approval,
            MetricKey.UNPAID: unpaid,
            MetricKey.AMOUNT_TOTAL: self._sum(Expense.amount, *conditions),
            MetricKey.BY_TYPE: self._group_counts(Expense, Expense.expense_type, *conditions),
        }

    def _lifecycle_fund_stats(self) -> dict[str, Any]:
        balance = self._sum(FundAccount.current_balance)
        receivable = self._sum(FundAccount.expected_receivable)
        payable = self._sum(FundAccount.expected_payable)
        safety_line = self._sum(FundAccount.safety_line)
        risk_accounts = self._count(
            FundAccount,
            FundAccount.current_balance < FundAccount.safety_line,
        )
        return {
            MetricKey.ACCOUNTS_TOTAL: self._count(FundAccount),
            MetricKey.CURRENT_BALANCE_TOTAL: balance,
            MetricKey.EXPECTED_RECEIVABLE_TOTAL: receivable,
            MetricKey.EXPECTED_PAYABLE_TOTAL: payable,
            MetricKey.SAFETY_LINE_TOTAL: safety_line,
            MetricKey.NET_POSITION: balance + receivable - payable,
            MetricKey.RISK_ACCOUNTS: risk_accounts,
        }

    def _lifecycle_supplier_stats(self) -> dict[str, Any]:
        risky = self._count(
            Supplier,
            (Supplier.blacklist_status != StatusValue.NORMAL)
            | Supplier.risk_level.in_(SUPPLIER_RISK_LEVELS),
        )
        blacklisted = self._count(Supplier, Supplier.blacklist_status != StatusValue.NORMAL)
        return {
            MetricKey.TOTAL: self._count(Supplier),
            MetricKey.RISKY: risky,
            MetricKey.BLACKLISTED: blacklisted,
            MetricKey.BY_RISK_LEVEL: self._group_counts(Supplier, Supplier.risk_level),
        }

    def _lifecycle_attendance_stats(self, conditions: list[Any]) -> dict[str, Any]:
        total = self._count(AttendanceRecord, *conditions)
        abnormal = self._count(
            AttendanceRecord,
            AttendanceRecord.status.in_(ATTENDANCE_ABNORMAL_STATUSES),
            *conditions,
        )
        return {
            MetricKey.TOTAL: total,
            MetricKey.ABNORMAL: abnormal,
            MetricKey.ABNORMAL_RATE: _rate(abnormal, total),
            MetricKey.BY_STATUS: self._group_counts(
                AttendanceRecord,
                AttendanceRecord.status,
                *conditions,
            ),
        }

    def _lifecycle_risk_stats(
        self,
        project_conditions: list[Any],
        task_conditions: list[Any],
        risk_conditions: list[Any],
    ) -> dict[str, Any]:
        overdue_tasks = self._count(
            WorkTask,
            WorkTask.due_date.is_not(None),
            WorkTask.due_date < date.today(),
            WorkTask.status.notin_(DONE_STATUSES),
            *task_conditions,
        )
        delayed_projects = self._count(
            Project,
            Project.due_date.is_not(None),
            Project.due_date < date.today(),
            Project.status.notin_(PROJECT_CLOSED_STATUSES),
            *project_conditions,
        )
        over_budget_projects = self._count(
            Project,
            Project.budget_amount > 0,
            Project.actual_amount > Project.budget_amount,
            *project_conditions,
        )
        open_events = self._count(
            RiskEvent,
            RiskEvent.status == StatusValue.OPEN,
            *risk_conditions,
        )
        high_events = self._count(
            RiskEvent,
            RiskEvent.status == StatusValue.OPEN,
            RiskEvent.risk_level == RiskLevel.HIGH,
            *risk_conditions,
        )
        external_open_events = self._count(
            RiskEvent,
            RiskEvent.status == StatusValue.OPEN,
            RiskEvent.risk_type.notin_(GENERATED_RISK_EVENT_TYPES),
            *risk_conditions,
        )
        external_high_events = self._count(
            RiskEvent,
            RiskEvent.status == StatusValue.OPEN,
            RiskEvent.risk_level == RiskLevel.HIGH,
            RiskEvent.risk_type.notin_(GENERATED_RISK_EVENT_TYPES),
            *risk_conditions,
        )
        risk_score = (
            overdue_tasks * LIFECYCLE_RISK_SCORE_WEIGHTS[MetricKey.OVERDUE_TASKS]
            + delayed_projects * LIFECYCLE_RISK_SCORE_WEIGHTS[MetricKey.DELAYED_PROJECTS]
            + over_budget_projects * LIFECYCLE_RISK_SCORE_WEIGHTS[MetricKey.OVER_BUDGET_PROJECTS]
            + external_open_events * LIFECYCLE_RISK_SCORE_WEIGHTS[MetricKey.EXTERNAL_OPEN_EVENTS]
            + external_high_events * LIFECYCLE_RISK_SCORE_WEIGHTS[MetricKey.EXTERNAL_HIGH_EVENTS]
        )
        return {
            MetricKey.RISK_LEVEL: risk_level_for_score(risk_score),
            MetricKey.RISK_SCORE: risk_score,
            MetricKey.OVERDUE_TASKS: overdue_tasks,
            MetricKey.DELAYED_PROJECTS: delayed_projects,
            MetricKey.OVER_BUDGET_PROJECTS: over_budget_projects,
            MetricKey.OPEN_EVENTS: open_events,
            MetricKey.HIGH_EVENTS: high_events,
            MetricKey.EXTERNAL_OPEN_EVENTS: external_open_events,
            MetricKey.EXTERNAL_HIGH_EVENTS: external_high_events,
            MetricKey.EVENTS_BY_TYPE: self._group_counts(
                RiskEvent,
                RiskEvent.risk_type,
                *risk_conditions,
            ),
            MetricKey.EVENTS_BY_LEVEL: self._group_counts(
                RiskEvent,
                RiskEvent.risk_level,
                *risk_conditions,
            ),
        }

    def _lifecycle_health(
        self,
        projects: dict[str, Any],
        tasks: dict[str, Any],
        risks: dict[str, Any],
        suppliers: dict[str, Any],
        include_global_risk: bool,
    ) -> dict[str, Any]:
        penalty = (
            risks[MetricKey.OVERDUE_TASKS] * HEALTH_PENALTY_WEIGHTS[MetricKey.OVERDUE_TASKS]
            + risks[MetricKey.DELAYED_PROJECTS]
            * HEALTH_PENALTY_WEIGHTS[MetricKey.DELAYED_PROJECTS]
            + risks[MetricKey.OVER_BUDGET_PROJECTS]
            * HEALTH_PENALTY_WEIGHTS[MetricKey.OVER_BUDGET_PROJECTS]
            + risks[MetricKey.EXTERNAL_HIGH_EVENTS]
            * HEALTH_PENALTY_WEIGHTS[MetricKey.EXTERNAL_HIGH_EVENTS]
            + max(
                HEALTH_SCORE_MIN,
                projects[MetricKey.BUDGET_USAGE_RATE] - HEALTH_SCORE_MAX,
            )
            * HEALTH_PENALTY_WEIGHTS[MetricKey.BUDGET_USAGE_RATE]
            + (HEALTH_SCORE_MAX - tasks[MetricKey.COMPLETION_RATE])
            * HEALTH_PENALTY_WEIGHTS[MetricKey.COMPLETION_RATE]
        )
        if include_global_risk:
            penalty += suppliers[MetricKey.BLACKLISTED] * HEALTH_PENALTY_WEIGHTS[
                MetricKey.BLACKLISTED
            ]
        score = max(
            HEALTH_SCORE_MIN,
            min(HEALTH_SCORE_MAX, round(HEALTH_SCORE_MAX - penalty, 2)),
        )
        if score >= HEALTHY_SCORE_THRESHOLD:
            level = HealthLevel.HEALTHY
        elif score >= ATTENTION_SCORE_THRESHOLD:
            level = HealthLevel.ATTENTION
        else:
            level = HealthLevel.CRITICAL
        return {MetricKey.SCORE: score, MetricKey.LEVEL: level}

    def _lifecycle_attention(
        self,
        project_conditions: list[Any],
        task_conditions: list[Any],
    ) -> dict[str, Any]:
        delayed = self._records(
            Project,
            Project.due_date.is_not(None),
            Project.due_date < date.today(),
            Project.status.notin_(PROJECT_CLOSED_STATUSES),
            *project_conditions,
            limit=10,
            order_by=Project.due_date.asc(),
        )
        over_budget = self._records(
            Project,
            Project.budget_amount > 0,
            Project.actual_amount > Project.budget_amount,
            *project_conditions,
            limit=10,
            order_by=Project.id.desc(),
        )
        overdue_tasks = self._records(
            WorkTask,
            WorkTask.due_date.is_not(None),
            WorkTask.due_date < date.today(),
            WorkTask.status.notin_(DONE_STATUSES),
            *task_conditions,
            limit=10,
            order_by=WorkTask.due_date.asc(),
        )
        return {
            LifecycleAttentionKey.DELAYED_PROJECTS: [serialize_model(item) for item in delayed],
            LifecycleAttentionKey.OVER_BUDGET_PROJECTS: [
                serialize_model(item) for item in over_budget
            ],
            LifecycleAttentionKey.OVERDUE_TASKS: [
                serialize_model(item) for item in overdue_tasks
            ],
        }

    def _lifecycle_recommendations(
        self,
        projects: dict[str, Any],
        tasks: dict[str, Any],
        procurements: dict[str, Any],
        expenses: dict[str, Any],
        funds: dict[str, Any],
        suppliers: dict[str, Any],
        risks: dict[str, Any],
        include_global_risk: bool,
    ) -> list[str]:
        recommendations: list[str] = []
        if risks[MetricKey.DELAYED_PROJECTS]:
            recommendations.append(ReportText.RECOMMEND_DELAYED)
        if risks[MetricKey.OVER_BUDGET_PROJECTS]:
            recommendations.append(ReportText.RECOMMEND_OVER_BUDGET)
        if tasks[MetricKey.OVERDUE]:
            recommendations.append(ReportText.RECOMMEND_OVERDUE_TASKS)
        if (
            procurements[MetricKey.PENDING_APPROVAL]
            or expenses[MetricKey.PENDING_APPROVAL]
        ):
            recommendations.append(ReportText.RECOMMEND_APPROVALS)
        if include_global_risk and funds[MetricKey.RISK_ACCOUNTS]:
            recommendations.append(ReportText.RECOMMEND_FUNDS)
        if include_global_risk and suppliers[MetricKey.RISKY]:
            recommendations.append(ReportText.RECOMMEND_SUPPLIERS)
        if not recommendations:
            recommendations.append(ReportText.RECOMMEND_STABLE)
        return [str(item) for item in recommendations]

    def _lifecycle_lines(
        self,
        filters: dict[str, Any],
        metrics: dict[str, Any],
        recommendations: list[str],
    ) -> list[str]:
        scope = (
            "、".join(f"{key}={value}" for key, value in filters.items() if value)
            or ReportText.DEFAULT_SCOPE
        )
        projects = metrics[LifecycleSection.PROJECTS]
        tasks = metrics[LifecycleSection.TASKS]
        procurements = metrics[LifecycleSection.PROCUREMENTS]
        expenses = metrics[LifecycleSection.EXPENSES]
        funds = metrics[LifecycleSection.FUNDS]
        suppliers = metrics[LifecycleSection.SUPPLIERS]
        attendance = metrics[LifecycleSection.ATTENDANCE]
        risks = metrics[LifecycleSection.RISKS]
        health = metrics[LifecycleSection.HEALTH]
        lines = [
            f"- 范围：{scope}",
            f"- 生命周期健康分：{health[MetricKey.SCORE]}（{health[MetricKey.LEVEL]}）",
            (
                f"- 项目：总数 {projects[MetricKey.TOTAL]}，"
                f"活跃 {projects[MetricKey.ACTIVE]}，"
                f"平均进度 {projects[MetricKey.AVERAGE_PROGRESS_PERCENT]}%"
            ),
            (
                f"- 成本：预算 {_money(projects[MetricKey.BUDGET_TOTAL])}，"
                f"实际 {_money(projects[MetricKey.ACTUAL_TOTAL])}，"
                f"预算使用率 {projects[MetricKey.BUDGET_USAGE_RATE]}%"
            ),
            (
                f"- 任务：总数 {tasks[MetricKey.TOTAL]}，"
                f"完成 {tasks[MetricKey.COMPLETED]}，"
                f"完成率 {tasks[MetricKey.COMPLETION_RATE]}%，"
                f"逾期 {tasks[MetricKey.OVERDUE]}"
            ),
            (
                f"- 采购/费用：待批采购 {procurements[MetricKey.PENDING_APPROVAL]}，"
                f"待批费用 {expenses[MetricKey.PENDING_APPROVAL]}，"
                f"未付款采购 {procurements[MetricKey.UNPAID]}"
            ),
            (
                f"- 资金：余额 {_money(funds[MetricKey.CURRENT_BALANCE_TOTAL])}，"
                f"净头寸 {_money(funds[MetricKey.NET_POSITION])}，"
                f"风险账户 {funds[MetricKey.RISK_ACCOUNTS]}"
            ),
            (
                f"- 风险：等级 {risks[MetricKey.RISK_LEVEL]}，"
                f"风险分 {risks[MetricKey.RISK_SCORE]}，"
                f"延期项目 {risks[MetricKey.DELAYED_PROJECTS]}，"
                f"超预算项目 {risks[MetricKey.OVER_BUDGET_PROJECTS]}，"
                f"打开事件 {risks[MetricKey.OPEN_EVENTS]}"
            ),
            (
                f"- 供应商/考勤：风险供应商 {suppliers[MetricKey.RISKY]}，"
                f"异常打卡 {attendance[MetricKey.ABNORMAL]}，"
                f"异常率 {attendance[MetricKey.ABNORMAL_RATE]}%"
            ),
            ReportText.ACTION_HEADER,
        ]
        lines.extend(f"  - {item}" for item in recommendations)
        return lines

    def _lifecycle_ai_analysis(self, report: dict[str, Any], actor: str) -> dict[str, Any]:
        try:
            from app.modules.ai_agent.constants import AIResponseKey
            from app.modules.ai_agent.skills import AISkillId
            from app.modules.ai_agent.service import AIService

            report_snapshot = _json_safe(report)
            result = AIService(self.db).run_skill(
                AISkillId.PROJECT_LIFECYCLE_ANALYSIS,
                context={LifecycleResponseKey.PROJECT_LIFECYCLE_REPORT: report_snapshot},
                actor=actor,
            )
        except Exception as exc:
            return {
                AIResponseKey.OK: False,
                AIResponseKey.ERROR: str(exc),
                AIResponseKey.TYPE: type(exc).__name__,
            }
        return _json_safe({AIResponseKey.OK: True, **result})

    def attendance_summary(self, work_date: date | None = None) -> dict[str, Any]:
        """Summarize attendance records for one business day."""

        target_date = work_date or date.today()
        rows = self.db.execute(
            select(AttendanceRecord.status, func.count())
            .where(AttendanceRecord.work_date == target_date)
            .group_by(AttendanceRecord.status)
        ).all()
        status_counts = {str(status): int(count) for status, count in rows}
        abnormal_total = sum(
            count
            for status, count in status_counts.items()
            if status in ATTENDANCE_ABNORMAL_STATUSES
        )
        total = sum(status_counts.values())
        lines = [
            f"- 日期：{target_date.isoformat()}",
            f"- 打卡记录：{total}",
            f"- 异常记录：{abnormal_total}",
        ]
        for status, count in sorted(status_counts.items()):
            lines.append(f"- {status}：{count}")
        return {
            ReportResponseKey.TITLE: ReportTitle.ATTENDANCE_SUMMARY,
            ReportResponseKey.WORK_DATE: target_date.isoformat(),
            ReportResponseKey.TOTAL: total,
            ReportResponseKey.ABNORMAL_TOTAL: abnormal_total,
            ReportResponseKey.STATUS_COUNTS: status_counts,
            ReportResponseKey.LINES: lines,
            ReportResponseKey.CONTENT: "\n".join(lines),
        }

    def generate_work_report(
        self,
        report_type: str = ReportType.DAILY,
        reporter: str = ActorValue.SYSTEM,
        department: str | None = None,
        project_code: str | None = None,
        period_start: date | None = None,
        period_end: date | None = None,
        persist: bool = True,
        actor: str = ActorValue.API,
    ) -> dict[str, Any]:
        """Generate a daily or weekly operating report, optionally persisting it."""

        start, end = self._resolve_period(report_type, period_start, period_end)
        metrics = self._report_metrics(start, end, project_code, department)
        risk_summary = _json_safe(self.risks.summary())
        title = (
            ReportTitle.WORK_DAILY
            if report_type == ReportType.DAILY
            else ReportTitle.WORK_WEEKLY
        )
        lines = self._work_report_lines(title, start, end, metrics, risk_summary)
        report = {
            ReportResponseKey.TITLE: title,
            ReportResponseKey.REPORT_TYPE: report_type,
            ReportResponseKey.PERIOD_START: start.isoformat(),
            ReportResponseKey.PERIOD_END: end.isoformat(),
            ReportResponseKey.LINES: lines,
            ReportResponseKey.CONTENT: "\n".join(lines),
            ReportResponseKey.METRICS: metrics,
            ReportResponseKey.RISK_SUMMARY: risk_summary,
        }

        record_data = None
        if persist:
            record = WorkReport(
                code=_next_code(f"REPORT-{report_type.upper()}"),
                report_type=report_type,
                title=title,
                reporter=reporter,
                department=department,
                project_code=project_code,
                period_start=start,
                period_end=end,
                content=report[ReportResponseKey.CONTENT],
                metrics=metrics,
                risk_summary=risk_summary,
            )
            self.db.add(record)
            self.db.commit()
            self.db.refresh(record)
            record_data = serialize_model(record)
            AuditService(self.db).log(
                AuditLogCreate(
                    actor=actor,
                    source=AuditSource.REPORTS,
                    action=f"generate_{report_type}_report",
                    target_type=AuditTargetType.WORK_REPORTS,
                    target_id=str(record.id),
                    response_payload=record_data,
                )
            )

        return {ReportResponseKey.REPORT: report, ReportResponseKey.DATA: record_data}

    def _resolve_period(
        self,
        report_type: str,
        period_start: date | None,
        period_end: date | None,
    ) -> tuple[date, date]:
        today = date.today()
        if report_type == ReportType.DAILY:
            start = period_start or period_end or today
            return start, period_end or start
        end = period_end or today
        start = period_start or end - timedelta(days=6)
        return start, end

    def _report_metrics(
        self,
        start: date,
        end: date,
        project_code: str | None,
        department: str | None,
    ) -> dict[str, Any]:
        task_filters = [
            WorkTask.due_date.is_not(None),
            WorkTask.due_date >= start,
            WorkTask.due_date <= end,
        ]
        project_filters = []
        risk_filters = [RiskEvent.status == StatusValue.OPEN]
        procurement_filters = [
            Procurement.approval_status.in_(PENDING_APPROVAL_STATUSES),
        ]
        expense_filters = [
            Expense.approval_status.in_(PENDING_APPROVAL_STATUSES),
        ]
        attendance_filters = [
            AttendanceRecord.work_date >= start,
            AttendanceRecord.work_date <= end,
        ]
        if project_code:
            project_filters.append(Project.code == project_code)
            task_filters.append(WorkTask.project_code == project_code)
            procurement_filters.append(Procurement.project_code == project_code)
            expense_filters.append(Expense.project_code == project_code)
            attendance_filters.append(AttendanceRecord.project_code == project_code)
            risk_filters.append(RiskEvent.project_code == project_code)
        if department:
            expense_filters.append(Expense.department == department)
            attendance_filters.append(AttendanceRecord.department == department)

        completed_tasks = self._count(WorkTask, WorkTask.status.in_(DONE_STATUSES), *task_filters)
        overdue_tasks = self._count(
            WorkTask,
            WorkTask.due_date < date.today(),
            WorkTask.status.notin_(DONE_STATUSES),
            *task_filters,
        )
        return {
            WorkReportMetricKey.PROJECTS_TOTAL: self._count(Project, *project_filters),
            WorkReportMetricKey.ACTIVE_PROJECTS: self._count(
                Project,
                Project.status.notin_(PROJECT_CLOSED_STATUSES),
                *project_filters,
            ),
            WorkReportMetricKey.TASKS_TOTAL: self._count(WorkTask, *task_filters),
            WorkReportMetricKey.TASKS_COMPLETED: completed_tasks,
            WorkReportMetricKey.TASKS_OVERDUE: overdue_tasks,
            WorkReportMetricKey.PROCUREMENTS_PENDING: self._count(
                Procurement,
                *procurement_filters,
            ),
            WorkReportMetricKey.EXPENSES_PENDING: self._count(Expense, *expense_filters),
            WorkReportMetricKey.ATTENDANCE_TOTAL: self._count(
                AttendanceRecord,
                *attendance_filters,
            ),
            WorkReportMetricKey.OPEN_RISK_EVENTS: self._count(RiskEvent, *risk_filters),
        }

    def _work_report_lines(
        self,
        title: str,
        start: date,
        end: date,
        metrics: dict[str, Any],
        risk_summary: dict[str, Any],
    ) -> list[str]:
        return [
            f"- 报告：{title}",
            f"- 周期：{start.isoformat()} 至 {end.isoformat()}",
            (
                f"- 项目：总数 {metrics[WorkReportMetricKey.PROJECTS_TOTAL]}，"
                f"活跃 {metrics[WorkReportMetricKey.ACTIVE_PROJECTS]}"
            ),
            (
                f"- 任务：总数 {metrics[WorkReportMetricKey.TASKS_TOTAL]}，"
                f"完成 {metrics[WorkReportMetricKey.TASKS_COMPLETED]}"
            ),
            f"- 逾期任务：{metrics[WorkReportMetricKey.TASKS_OVERDUE]}",
            f"- 待处理采购：{metrics[WorkReportMetricKey.PROCUREMENTS_PENDING]}",
            f"- 待处理费用：{metrics[WorkReportMetricKey.EXPENSES_PENDING]}",
            f"- 打卡记录：{metrics[WorkReportMetricKey.ATTENDANCE_TOTAL]}",
            f"- 打开风险事件：{metrics[WorkReportMetricKey.OPEN_RISK_EVENTS]}",
            f"- 综合风险等级：{risk_summary[RiskSummaryKey.RISK_LEVEL]}",
        ]

    def push_report(
        self,
        report: dict,
        receive_id: str | None,
        receive_id_type: str,
        actor: str,
        push_run_code: str | None = None,
    ) -> dict:
        report_type = str(report.get(ReportResponseKey.REPORT_TYPE) or report.get("type") or "report")
        title = report.get(ReportResponseKey.TITLE)
        push_run = (
            self._get_push_run(push_run_code)
            if push_run_code
            else self.create_push_run(
                report_type=report_type,
                title=title,
                receive_id=receive_id,
                receive_id_type=receive_id_type,
                actor=actor,
            )
        )
        card = FeishuService.build_basic_card(
            report[ReportResponseKey.TITLE],
            report[ReportResponseKey.LINES],
        )
        try:
            result = FeishuService(self.db).send_card(card, receive_id, receive_id_type, actor)
        except Exception as exc:
            self.update_push_run(
                push_run.code,
                ReportPushStatus.FAILED,
                error_message=str(exc),
            )
            raise
        self.update_push_run(
            push_run.code,
            ReportPushStatus.SUCCESS,
            provider_response=result,
            sent=True,
        )
        AuditService(self.db).log(
            AuditLogCreate(
                actor=actor,
                source=AuditSource.REPORTS,
                action=AuditAction.REPORT_PUSH,
                target_id=push_run.code,
                response_payload={"status": ReportPushStatus.SUCCESS},
            )
        )
        return result