from datetime import date
from math import ceil

from fastapi import APIRouter, Depends, HTTPException, Query, Response, status
from sqlalchemy import select
from sqlalchemy.orm import Session, selectinload

from app.database import get_db
from app.deps import require_roles
from app.models import (
    Equipment,
    Personnel,
    ProductionReport,
    ProductionReportAllocation,
    ReportStatus,
    Role,
)
from app.schemas import (
    PageResponse,
    UsageStatsDailyRow,
    UsageStatsDetailOut,
    UsageStatsReportRow,
    UsageStatsRow,
)
from app.services.attendance_points import accessible_point_names, require_attendance_point_access
from app.services.common import round2
from app.services.report_lifecycle import purge_expired_voided_reports
from app.services.usage_stats import UsageStatRow, build_usage_stats_from_allocations
from app.services.usage_stats_export import export_usage_stats_rows

router = APIRouter(prefix="/api/usage-stats", tags=["usage-stats"])


def _clean(value: str | None) -> str:
    return str(value or "").strip()


def _requested_points(db: Session, user: Personnel, attendance_point_name: str | None) -> list[str]:
    requested_name = _clean(attendance_point_name)
    if requested_name:
        try:
            return [require_attendance_point_access(db, user, requested_name)]
        except ValueError as exc:
            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc)) from exc
        except PermissionError as exc:
            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=str(exc)) from exc
    return accessible_point_names(db, user)


def _equipment_type_map(db: Session, point_names: list[str]) -> dict[tuple[str, str], str]:
    if not point_names:
        return {}
    rows = db.scalars(select(Equipment).where(Equipment.attendance_point_name.in_(point_names))).all()
    return {(_clean(row.attendance_point_name), _clean(row.device_no)): row.device_type for row in rows}


def _approved_allocations_query(
    point_names: list[str],
    start_date: date | None,
    end_date: date | None,
):
    query = (
        select(ProductionReportAllocation)
        .join(ProductionReportAllocation.report)
        .join(ProductionReportAllocation.item)
        .options(
            selectinload(ProductionReportAllocation.report).selectinload(ProductionReport.employee),
            selectinload(ProductionReportAllocation.item),
        )
        .where(
            ProductionReport.status == ReportStatus.approved,
            ProductionReport.is_voided.is_(False),
            ProductionReport.attendance_point_name.in_(point_names),
        )
    )
    if start_date:
        query = query.where(ProductionReportAllocation.allocation_date >= start_date)
    if end_date:
        query = query.where(ProductionReportAllocation.allocation_date <= end_date)
    return query.order_by(
        ProductionReportAllocation.allocation_date.desc(),
        ProductionReportAllocation.report_id.desc(),
        ProductionReportAllocation.id.desc(),
    )


def _sort_usage_rows(rows: list[UsageStatRow], sort_by: str) -> list[UsageStatRow]:
    if sort_by == "count":
        return sorted(rows, key=lambda row: (-row.report_count, -row.value, row.name))
    return sorted(rows, key=lambda row: (-row.value, -row.report_count, row.name))


def _usage_row_search_text(row: UsageStatRow) -> str:
    values = [
        row.id,
        row.category,
        row.attendance_point_name,
        row.name,
        row.object_type,
        row.metric_kind,
        row.product_name,
        row.process_name,
        row.stamping_method,
        row.value,
        row.report_count,
        *row.tags,
    ]
    return " ".join(str(value or "") for value in values).lower()


def _filter_usage_rows(rows: list[UsageStatRow], keyword: str | None) -> list[UsageStatRow]:
    text = _clean(keyword).lower()
    if not text:
        return rows
    return [row for row in rows if text in _usage_row_search_text(row)]


def _to_schema_row(row: UsageStatRow) -> UsageStatsRow:
    return UsageStatsRow(
        id=row.id,
        category=row.category,
        attendance_point_name=row.attendance_point_name,
        name=row.name,
        object_type=row.object_type,
        metric_kind=row.metric_kind,
        value=row.value,
        report_count=row.report_count,
        product_name=row.product_name,
        process_name=row.process_name,
        stamping_method=row.stamping_method,
        tags=list(row.tags),
    )


def _to_detail_out(
    row: UsageStatRow,
    *,
    daily_rows: list[UsageStatsDailyRow] | None = None,
    report_rows: list[UsageStatsReportRow] | None = None,
) -> UsageStatsDetailOut:
    return UsageStatsDetailOut(
        id=row.id,
        category=row.category,
        attendance_point_name=row.attendance_point_name,
        name=row.name,
        object_type=row.object_type,
        metric_kind=row.metric_kind,
        value=row.value,
        report_count=row.report_count,
        product_name=row.product_name,
        process_name=row.process_name,
        stamping_method=row.stamping_method,
        tags=list(row.tags),
        daily_rows=daily_rows or [],
        report_rows=report_rows or [],
    )


def _matches_target(
    row: UsageStatRow,
    *,
    id: str,
    category: str,
    attendance_point_name: str,
    name: str,
    product_name: str,
    process_name: str,
    stamping_method: str,
    metric_kind: str,
) -> bool:
    if id:
        return row.id == id
    if row.category != category:
        return False
    if attendance_point_name and row.attendance_point_name != attendance_point_name:
        return False
    if metric_kind and row.metric_kind != metric_kind:
        return False
    if category == "device":
        return row.name == name
    return (
        row.product_name == product_name
        and row.process_name == process_name
        and row.stamping_method == stamping_method
    )


def _build_usage_stats_export_response(device_rows: list[UsageStatRow], mold_rows: list[UsageStatRow]) -> Response:
    content = export_usage_stats_rows(device_rows, mold_rows)
    return Response(
        content=content,
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        headers={"Content-Disposition": 'attachment; filename="usage-stats.xlsx"'},
    )


def _build_usage_stats_detail_from_allocations(
    *,
    allocations: list,
    category: str,
    target_args: dict,
    equipment_type_by_key: dict[tuple[str, str], str],
) -> UsageStatsDetailOut:
    rows = build_usage_stats_from_allocations(
        allocations=allocations,
        category=category,
        equipment_type_by_key=equipment_type_by_key,
    )
    target = next((row for row in rows if _matches_target(row, **target_args)), None)
    if target is None:
        return UsageStatsDetailOut(
            id=target_args["id"],
            category=category,
            attendance_point_name=target_args["attendance_point_name"],
            name=target_args["name"],
            product_name=target_args["product_name"],
            process_name=target_args["process_name"],
            stamping_method=target_args["stamping_method"],
            metric_kind=target_args["metric_kind"],
        )

    grouped_allocations: dict[tuple[date, int], list] = {}
    group_reports: dict[tuple[date, int], object | None] = {}
    for allocation in allocations:
        allocation_date = getattr(allocation, "allocation_date")
        report = getattr(allocation, "report", None)
        report_id = getattr(allocation, "report_id", None)
        if report_id is None and report is not None:
            report_id = getattr(report, "id", None)
        group_key = (allocation_date, report_id if report_id is not None else id(allocation))
        grouped_allocations.setdefault(group_key, []).append(allocation)
        group_reports.setdefault(group_key, report)

    daily_rows: dict[date, UsageStatsDailyRow] = {}
    report_rows: list[UsageStatsReportRow] = []
    for (allocation_date, report_key), group in grouped_allocations.items():
        group_matches = build_usage_stats_from_allocations(
            allocations=group,
            category=category,
            equipment_type_by_key=equipment_type_by_key,
        )
        match = next((row for row in group_matches if _matches_target(row, **target_args)), None)
        if match is None:
            continue

        day = daily_rows.setdefault(
            allocation_date,
            UsageStatsDailyRow(report_date=allocation_date),
        )
        day.value = round2(day.value + match.value)
        day.report_count += match.report_count

        report = group_reports[(allocation_date, report_key)]
        employee = getattr(report, "employee", None) if report is not None else None
        report_id = (
            getattr(report, "id", None)
            if report is not None
            else getattr(group[0], "report_id", None)
        )
        employee_phone = getattr(report, "employee_phone", "") if report is not None else ""
        report_rows.append(
            UsageStatsReportRow(
                report_id=report_id or 0,
                report_date=allocation_date,
                employee_phone=employee_phone,
                employee_name=employee.name if employee else "",
                display_name=target.name,
                value=match.value,
                report_count=match.report_count,
            )
        )

    return _to_detail_out(
        target,
        daily_rows=sorted(daily_rows.values(), key=lambda row: row.report_date),
        report_rows=sorted(
            report_rows,
            key=lambda row: (row.report_date, row.report_id),
            reverse=True,
        ),
    )


@router.get("/summary", response_model=PageResponse)
def usage_stats_summary(
    category: str = Query("device", pattern="^(device|mold)$"),
    start_date: date | None = None,
    end_date: date | None = None,
    attendance_point_name: str = "",
    keyword: str = "",
    sort_by: str = Query("value", pattern="^(value|count)$"),
    page: int = Query(1, ge=1),
    page_size: int = Query(10, ge=1, le=100),
    user: Personnel = Depends(require_roles(Role.admin, Role.manager)),
    db: Session = Depends(get_db),
) -> PageResponse:
    purge_expired_voided_reports(db)
    point_names = _requested_points(db, user, attendance_point_name)
    allocations = db.scalars(_approved_allocations_query(point_names, start_date, end_date)).all()
    rows = _sort_usage_rows(
        _filter_usage_rows(
            build_usage_stats_from_allocations(
                allocations=allocations,
                category=category,
                equipment_type_by_key=_equipment_type_map(db, point_names),
            ),
            keyword,
        ),
        sort_by,
    )
    safe_page_size = min(100, max(1, page_size))
    total = len(rows)
    total_pages = max(1, ceil(total / safe_page_size))
    start = (page - 1) * safe_page_size
    return PageResponse(
        page=page,
        page_size=safe_page_size,
        total=total,
        total_pages=total_pages,
        rows=[_to_schema_row(row) for row in rows[start : start + safe_page_size]],
    )


@router.get("/export")
def export_usage_stats_excel(
    start_date: date | None = None,
    end_date: date | None = None,
    attendance_point_name: str = "",
    keyword: str = "",
    sort_by: str = Query("value", pattern="^(value|count)$"),
    user: Personnel = Depends(require_roles(Role.admin, Role.manager)),
    db: Session = Depends(get_db),
) -> Response:
    purge_expired_voided_reports(db)
    point_names = _requested_points(db, user, attendance_point_name)
    equipment_type_by_key = _equipment_type_map(db, point_names)
    allocations = db.scalars(_approved_allocations_query(point_names, start_date, end_date)).all()
    device_rows = _sort_usage_rows(
        _filter_usage_rows(
            build_usage_stats_from_allocations(
                allocations=allocations,
                category="device",
                equipment_type_by_key=equipment_type_by_key,
            ),
            keyword,
        ),
        sort_by,
    )
    mold_rows = _sort_usage_rows(
        _filter_usage_rows(
            build_usage_stats_from_allocations(
                allocations=allocations,
                category="mold",
                equipment_type_by_key=equipment_type_by_key,
            ),
            keyword,
        ),
        sort_by,
    )
    return _build_usage_stats_export_response(device_rows, mold_rows)


@router.get("/detail", response_model=UsageStatsDetailOut)
def usage_stats_detail(
    category: str = Query("device", pattern="^(device|mold)$"),
    id: str = "",
    metric_kind: str = "",
    start_date: date | None = None,
    end_date: date | None = None,
    attendance_point_name: str = "",
    name: str = "",
    product_name: str = "",
    process_name: str = "",
    stamping_method: str = "",
    user: Personnel = Depends(require_roles(Role.admin, Role.manager)),
    db: Session = Depends(get_db),
) -> UsageStatsDetailOut:
    purge_expired_voided_reports(db)
    point_names = _requested_points(db, user, attendance_point_name)
    equipment_type_by_key = _equipment_type_map(db, point_names)
    allocations = db.scalars(_approved_allocations_query(point_names, start_date, end_date)).all()
    target_args = {
        "id": _clean(id),
        "category": category,
        "attendance_point_name": _clean(attendance_point_name),
        "name": _clean(name),
        "product_name": _clean(product_name),
        "process_name": _clean(process_name),
        "stamping_method": _clean(stamping_method),
        "metric_kind": _clean(metric_kind),
    }
    return _build_usage_stats_detail_from_allocations(
        allocations=allocations,
        category=category,
        target_args=target_args,
        equipment_type_by_key=equipment_type_by_key,
    )