from __future__ import annotations

from .shared import *

@router.post("/experiment-sync")
async def create_experiment_sync(
    request: ExperimentSyncRequest,
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """创建实验结果同步记录，满足阈值时自动同步。"""
    _ = current_user
    service = ExperimentSyncService(db)
    try:
        data = await service.auto_sync_experiment_result(
            experiment_id=request.experiment_id,
            truth_node_id=request.truth_node_id,
            tenant_id=tenant_id,
            project_id=request.project_id,
            sync_type=request.sync_type,
            auto_apply_threshold=request.auto_apply_threshold,
        )
        return success_response(data=data)
    except ValueError as exc:
        return JSONResponse(
            status_code=404,
            content=error_response(ErrorCode.NOT_FOUND, str(exc)),
        )
    except Exception as exc:
        return JSONResponse(
            status_code=500,
            content=error_response(ErrorCode.INTERNAL_ERROR, f"创建同步失败: {exc}"),
        )

@router.get("/experiment-sync")
async def list_experiment_sync_records(
    truth_node_id: Optional[int] = Query(default=None),
    limit: int = Query(default=50, ge=1, le=200),
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """查询实验同步记录。"""
    _ = current_user
    service = ExperimentSyncService(db)
    try:
        data = await service.list_sync_records(
            tenant_id=tenant_id,
            truth_node_id=truth_node_id,
            limit=limit,
        )
        return success_response(data=data)
    except Exception as exc:
        return JSONResponse(
            status_code=500,
            content=error_response(ErrorCode.INTERNAL_ERROR, f"查询同步记录失败: {exc}"),
        )

@router.post("/experiment-sync/{sync_id}/review")
async def review_experiment_sync(
    sync_id: int,
    request: ExperimentSyncReviewRequest,
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """人工审核实验同步记录。"""
    service = ExperimentSyncService(db)
    try:
        data = await service.review_sync(
            sync_id=sync_id,
            tenant_id=tenant_id,
            reviewer_id=current_user.id,
            action=request.action,
            review_notes=request.review_notes,
        )
        return success_response(data=data)
    except ValueError as exc:
        return JSONResponse(
            status_code=400,
            content=error_response(ErrorCode.BAD_REQUEST, str(exc)),
        )
    except Exception as exc:
        return JSONResponse(
            status_code=500,
            content=error_response(ErrorCode.INTERNAL_ERROR, f"审核同步失败: {exc}"),
        )

@router.post("/experiment-sync/{sync_id}/rollback")
async def rollback_experiment_sync(
    sync_id: int,
    request: ExperimentSyncRollbackRequest,
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """回滚已应用的实验同步。"""
    service = ExperimentSyncService(db)
    try:
        data = await service.rollback_sync(
            sync_id=sync_id,
            tenant_id=tenant_id,
            reviewer_id=current_user.id,
            rollback_notes=request.rollback_notes,
        )
        return success_response(data=data)
    except ValueError as exc:
        return JSONResponse(
            status_code=400,
            content=error_response(ErrorCode.BAD_REQUEST, str(exc)),
        )
    except Exception as exc:
        return JSONResponse(
            status_code=500,
            content=error_response(ErrorCode.INTERNAL_ERROR, f"回滚同步失败: {exc}"),
        )