CardScoreDataServer/app/api/formate_xy.py

import requests
import json
import copy
import hashlib
from enum import Enum
from time import perf_counter

from fastapi import APIRouter, Depends, HTTPException, Query, Body
from fastapi.concurrency import run_in_threadpool

from mysql.connector.pooling import PooledMySQLConnection

from app.core.config import settings
from app.core.logger import get_logger
from app.core.database_loader import get_db_connection
from app.api.users import check_card_permission, get_current_user
from app.utils.scheme import (
    CardDetailResponse, ImageType
)
from app.crud import crud_card
from app.utils.xy_process import convert_internal_to_xy_format, convert_xy_to_internal_format
from app.core.minio_client import minio_client
from app.utils.rating_report_utils import crop_defect_image

logger = get_logger(__name__)
router = APIRouter()
db_dependency = Depends(get_db_connection)


class QueryMode(str, Enum):
    current = "current"
    next = "next"
    prev = "prev"


def _resolve_recalc_score_type(image_type: str):
    """
    将 14 类新版 image_type 归一到 score_recalculate 接口接受的 score_type。
    新版 stitch 导入后，同一面的 fusion/ring/stripe 共用该面 JSON；
    编辑重算时按正反面统一归到 front_ring / back_ring。
    """
    image_type_to_recalc_score_type = {
        ImageType.front_fusion.value: ImageType.front_ring.value,
        ImageType.front_ring.value: ImageType.front_ring.value,
        ImageType.front_gray.value: ImageType.front_ring.value,
        ImageType.front_stripe1.value: ImageType.front_ring.value,
        ImageType.front_stripe2.value: ImageType.front_ring.value,
        ImageType.front_stripe3.value: ImageType.front_ring.value,
        ImageType.front_stripe4.value: ImageType.front_ring.value,

        ImageType.back_fusion.value: ImageType.back_ring.value,
        ImageType.back_ring.value: ImageType.back_ring.value,
        ImageType.back_gray.value: ImageType.back_ring.value,
        ImageType.back_stripe1.value: ImageType.back_ring.value,
        ImageType.back_stripe2.value: ImageType.back_ring.value,
        ImageType.back_stripe3.value: ImageType.back_ring.value,
        ImageType.back_stripe4.value: ImageType.back_ring.value,

        # 兼容历史同轴光数据
        ImageType.front_coaxial.value: ImageType.front_coaxial.value,
        ImageType.back_coaxial.value: ImageType.back_coaxial.value,
    }
    return image_type_to_recalc_score_type.get(image_type)


def _is_center_box_shapes_empty(center_result: dict) -> bool:
    """
    判断 center_result 中 inner/outer box 的 shapes 是否都为空。
    前端某些场景会传空 shapes，直接下发给算分服务可能触发其内部越界。
    """
    if not isinstance(center_result, dict):
        return True
    box_result = center_result.get("box_result", {})
    if not isinstance(box_result, dict):
        return True

    inner_shapes = box_result.get("inner_box", {}).get("shapes", [])
    outer_shapes = box_result.get("outer_box", {}).get("shapes", [])
    return not inner_shapes and not outer_shapes


def _normalize_center_result(center_result: dict) -> dict:
    """
    兜底补齐算分服务依赖的 center_result 结构，避免 KeyError: 'box_result'。
    """
    normalized = center_result if isinstance(center_result, dict) else {}
    box_result = normalized.get("box_result")
    if not isinstance(box_result, dict):
        box_result = {}
        normalized["box_result"] = box_result

    inner_box = box_result.get("inner_box")
    if not isinstance(inner_box, dict):
        inner_box = {}
        box_result["inner_box"] = inner_box
    if not isinstance(inner_box.get("shapes"), list):
        inner_box["shapes"] = []

    outer_box = box_result.get("outer_box")
    if not isinstance(outer_box, dict):
        outer_box = {}
        box_result["outer_box"] = outer_box
    if not isinstance(outer_box.get("shapes"), list):
        outer_box["shapes"] = []

    return normalized


def _prepare_recalculate_payload(edited_json: dict, source_json: dict) -> dict:
    """
    以数据库里的原始 JSON 为底稿，合并前端编辑结果，得到更稳定的重算入参。
    当前仅明确覆盖 defects；center_result 只有在前端传了非空 shapes 时才覆盖。
    对前端标记为删除(edit_type=del)的缺陷，在这里直接过滤，避免重算后再次写回 modified_json。
    """
    base = copy.deepcopy(source_json) if isinstance(source_json, dict) else {}
    incoming = edited_json if isinstance(edited_json, dict) else {}

    if "id" in incoming:
        base["id"] = incoming["id"]
    if "imageWidth" in incoming:
        base["imageWidth"] = incoming["imageWidth"]
    if "imageHeight" in incoming:
        base["imageHeight"] = incoming["imageHeight"]

    base.setdefault("result", {})
    incoming_result = incoming.get("result", {})
    if not isinstance(incoming_result, dict):
        incoming_result = {}

    # defects 使用前端编辑结果覆盖；前端标记删除的项不参与重算，也不写回 modified_json
    incoming_defects = (
        incoming_result.get("defect_result", {}).get("defects", [])
        if isinstance(incoming_result.get("defect_result", {}), dict)
        else []
    )
    base["result"].setdefault("defect_result", {})
    filtered_defects = []
    if isinstance(incoming_defects, list):
        filtered_defects = [
            defect for defect in incoming_defects
            if not (isinstance(defect, dict) and defect.get("edit_type") == "del")
        ]
    base["result"]["defect_result"]["defects"] = filtered_defects

    # center_result 仅在前端有有效 shapes 时覆盖；否则沿用底稿
    incoming_center = incoming_result.get("center_result")
    if isinstance(incoming_center, dict) and not _is_center_box_shapes_empty(incoming_center):
        base["result"]["center_result"] = incoming_center
    elif "center_result" not in base["result"]:
        base["result"]["center_result"] = incoming_center if isinstance(incoming_center, dict) else {}
    base["result"]["center_result"] = _normalize_center_result(base["result"].get("center_result"))

    return base


_GRAY_IMAGE_TYPES = frozenset({
    ImageType.front_gray.value,
    ImageType.back_gray.value,
})

# 以融合图 JSON 中的缺陷为准，在同面下列类型原图上裁图（不含灰度图）
_FRONT_DEFECT_URL_TARGET_TYPES = [
    ImageType.front_fusion.value,
    ImageType.front_ring.value,
    ImageType.front_stripe1.value,
    ImageType.front_stripe2.value,
    ImageType.front_stripe3.value,
    ImageType.front_stripe4.value,
    ImageType.front_coaxial.value,  # 兼容历史同轴光
]
_BACK_DEFECT_URL_TARGET_TYPES = [
    ImageType.back_fusion.value,
    ImageType.back_ring.value,
    ImageType.back_stripe1.value,
    ImageType.back_stripe2.value,
    ImageType.back_stripe3.value,
    ImageType.back_stripe4.value,
    ImageType.back_coaxial.value,
]
_DEFECT_URL_TARGET_TYPES_BY_SIDE = {
    "front": _FRONT_DEFECT_URL_TARGET_TYPES,
    "back": _BACK_DEFECT_URL_TARGET_TYPES,
}

# ring / stripe 等可能落在 card_gray_images，裁图时需与主表合并
_ALL_DEFECT_URL_TARGET_TYPES = frozenset(
    _FRONT_DEFECT_URL_TARGET_TYPES + _BACK_DEFECT_URL_TARGET_TYPES
)


def _is_gray_image_type(image_type: str) -> bool:
    return image_type in _GRAY_IMAGE_TYPES


def _side_key_from_image_type(image_type: str) -> str:
    if image_type.startswith("front_"):
        return "front"
    if image_type.startswith("back_"):
        return "back"
    return ""


def _defect_rect_hash(min_rect) -> str:
    if not min_rect or len(min_rect) != 3:
        return ""
    rect_str = str(min_rect)
    return hashlib.md5(rect_str.encode("utf-8")).hexdigest()[:8]


def _resolve_fusion_images_by_side(all_images: list) -> dict:
    """每面仅以融合图 JSON 作为缺陷与裁图坐标来源。"""
    type_to_img = {getattr(img, "image_type", ""): img for img in all_images}
    return {
        "front": type_to_img.get(ImageType.front_fusion.value),
        "back": type_to_img.get(ImageType.back_fusion.value),
    }


class _DefectCropImageRef:
    """裁图用的轻量图片引用（主表 Pydantic 或灰度辅助表行均可）。"""

    __slots__ = ("id", "image_type", "image_path")

    def __init__(self, image_id: int, image_type: str, image_path: str):
        self.id = image_id
        self.image_type = image_type
        self.image_path = image_path


def _build_defect_crop_pool_by_type(
        card_id: int,
        all_images: list,
        db_conn: PooledMySQLConnection = None,
) -> dict:
    """
    合并主表 card_images 与辅助表 card_gray_images 中的裁图目标。
    同类型主表优先；ring/stripe 导入在灰度表时也能被 defectImgUrls 用到。
    """
    pool: dict = {}
    for img in all_images or []:
        image_type = getattr(img, "image_type", "")
        if image_type not in _ALL_DEFECT_URL_TARGET_TYPES:
            continue
        pool[image_type] = img

    if db_conn is not None:
        cursor = None
        try:
            cursor = db_conn.cursor(dictionary=True)
            cursor.execute(
                f"SELECT id, image_type, image_path FROM {settings.DB_GRAY_IMAGE_TABLE_NAME} "
                f"WHERE card_id = %s",
                (card_id,),
            )
            for row in cursor.fetchall():
                image_type = row.get("image_type") or ""
                if image_type not in _ALL_DEFECT_URL_TARGET_TYPES:
                    continue
                if image_type in pool:
                    continue
                pool[image_type] = _DefectCropImageRef(
                    row["id"],
                    image_type,
                    settings.get_full_url(row.get("image_path")),
                )
        finally:
            if cursor:
                cursor.close()

    return pool


def _defect_url_target_type_list(crop_pool_by_type: dict, side_key: str) -> list:
    """同面裁图类型列表；若已有 stripe 则不再使用历史 coaxial。"""
    target_types = list(_DEFECT_URL_TARGET_TYPES_BY_SIDE.get(side_key, []))
    has_stripe = any(
        t.startswith(f"{side_key}_stripe") and t in crop_pool_by_type
        for t in target_types
    )
    if has_stripe:
        coaxial = ImageType.front_coaxial.value if side_key == "front" else ImageType.back_coaxial.value
        target_types = [t for t in target_types if t != coaxial]
    return target_types


def _defect_url_target_images(crop_pool_by_type: dict, side_key: str) -> list:
    """按固定类型顺序返回同面需生成 defectImgUrls 的图片（灰度图除外）。"""
    targets = []
    for image_type in _defect_url_target_type_list(crop_pool_by_type, side_key):
        img = crop_pool_by_type.get(image_type)
        if img is not None:
            targets.append(img)
    return targets


def _sanitize_defects_for_recalculate(defects: list):
    """
    清理前端展示/编辑辅助字段，减少算分服务解析失败概率。
    """
    if not isinstance(defects, list):
        return
    for d in defects:
        if not isinstance(d, dict):
            continue
        if d.get("label") == "slight_scratch":
            d["label"] = "scratch"
        d.pop("defectImgUrl", None)
        d.pop("defectImgUrls", None)
        d.pop("gray_id", None)
        d.pop("fusion_id", None)
        d.pop("edit_type", None)
        d.pop("severity_level", None)
        d.pop("new_score", None)


def _generate_defect_img_urls_for_json(
        card_id: int,
        fusion_img_id: int,
        json_data: dict,
        side_key: str,
        crop_pool_by_type: dict,
        generate_related_images: bool = True,
) -> dict:
    """
    以融合图 JSON 中的缺陷 min_rect 为准，在同面各目标类型原图上裁图，
    生成 defectImgUrls 并返回 rect_hash -> urls 缓存，供同面其它图复用。
    """
    start_time = perf_counter()
    url_cache_by_rect = {}
    if not json_data or "result" not in json_data:
        logger.info(
            "耗时埋点 _generate_defect_img_urls: card_id=%s fusion_image_id=%s side=%s defects=0 elapsed_ms=%.2f",
            card_id, fusion_img_id, side_key, (perf_counter() - start_time) * 1000,
        )
        return url_cache_by_rect

    defect_result = json_data["result"].get("defect_result", {})
    defects = defect_result.get("defects", [])
    crop_target_images = _defect_url_target_images(crop_pool_by_type, side_key)
    target_types = _defect_url_target_type_list(crop_pool_by_type, side_key)
    missing_types = [t for t in target_types if t not in crop_pool_by_type]
    if missing_types:
        logger.info(
            "defectImgUrls 裁图目标缺失: card_id=%s side=%s missing=%s",
            card_id, side_key, ",".join(missing_types),
        )

    for idx, defect in enumerate(defects, start=1):
        min_rect = defect.get("min_rect")
        defect_img_url_list = []
        rect_hash = _defect_rect_hash(min_rect)

        if min_rect and len(min_rect) == 3 and generate_related_images and crop_target_images:
            for s_img in crop_target_images:
                s_img_type = getattr(s_img, "image_type", "")
                s_img_path = getattr(s_img, "image_path", "")
                s_img_id = getattr(s_img, "id", 0)

                s_filename = f"xy_{card_id}_{s_img_id}_{idx}_{rect_hash}.jpg"
                s_out_rel_path = f"/DefectImage/{s_filename}"
                s_out_object_name = f"{settings.MINIO_BASE_PREFIX}{s_out_rel_path}"

                s_url = ""
                try:
                    minio_client.stat_object(settings.MINIO_BUCKET, s_out_object_name)
                    s_url = settings.get_full_url(s_out_rel_path)
                except Exception:
                    if s_img_path:
                        s_url = crop_defect_image(s_img_path, min_rect, s_filename)

                if s_url:
                    defect_img_url_list.append({
                        "image_type": s_img_type,
                        "url": s_url,
                    })

        defect["defectImgUrls"] = defect_img_url_list
        if rect_hash:
            url_cache_by_rect[rect_hash] = copy.deepcopy(defect_img_url_list)

    logger.info(
        "耗时埋点 _generate_defect_img_urls: card_id=%s fusion_image_id=%s side=%s "
        "defects=%s target_types=%s elapsed_ms=%.2f",
        card_id,
        fusion_img_id,
        side_key,
        len(defects),
        len(crop_target_images),
        (perf_counter() - start_time) * 1000,
    )
    return url_cache_by_rect


def _apply_defect_img_urls_from_cache(json_data: dict, url_cache_by_rect: dict):
    """同面非 canonical 图：按 min_rect 哈希复用已生成的 defectImgUrls，不再访问 MinIO。"""
    if not json_data or "result" not in json_data or not url_cache_by_rect:
        return
    defects = json_data["result"].get("defect_result", {}).get("defects", [])
    for defect in defects:
        if not isinstance(defect, dict):
            continue
        rect_hash = _defect_rect_hash(defect.get("min_rect"))
        defect["defectImgUrls"] = copy.deepcopy(url_cache_by_rect.get(rect_hash, []))


def _clear_defect_img_urls(json_data: dict):
    """灰度图不生成关联缺陷图，清空展示用字段。"""
    if not json_data or "result" not in json_data:
        return
    defects = json_data["result"].get("defect_result", {}).get("defects", [])
    for defect in defects:
        if isinstance(defect, dict):
            defect["defectImgUrls"] = []


def _process_images_to_xy_format(
        card_data: dict,
        generate_related_images: bool = True,
        db_conn: PooledMySQLConnection = None,
):
    """
    内部辅助函数：遍历卡牌数据中的图片，将 JSON 格式转换为前端需要的 XY 格式。
    每面仅以融合图 JSON 生成一次 defectImgUrls（按固定 14 类中的同面非灰类型裁图），
    再拷贝到同面 ring / stripe 等；灰度图不生成 defectImgUrls。
    直接修改传入的 card_data 字典。
    """
    start_time = perf_counter()
    card_id = card_data.get("id")
    all_images = card_data.get("images", [])
    fusion_by_side = _resolve_fusion_images_by_side(all_images) if all_images else {}
    crop_pool_by_type = _build_defect_crop_pool_by_type(
        card_id, all_images, db_conn=db_conn,
    )
    detection_url_cache_by_side = {}
    modified_url_cache_by_side = {}

    if all_images:
        parsed_json_by_img_id = {}
        for img in all_images:
            d_internal = img.detection_json
            if isinstance(d_internal, str):
                d_internal = json.loads(d_internal) if d_internal else None
            m_internal = img.modified_json
            if isinstance(m_internal, str):
                m_internal = json.loads(m_internal) if m_internal else None
            parsed_json_by_img_id[img.id] = {
                "detection": d_internal,
                "modified": m_internal,
            }

        if generate_related_images:
            for side_key, fusion_img in fusion_by_side.items():
                if not fusion_img:
                    continue
                parsed = parsed_json_by_img_id.get(fusion_img.id, {})
                d_internal = parsed.get("detection")
                if d_internal:
                    detection_url_cache_by_side[side_key] = _generate_defect_img_urls_for_json(
                        card_id,
                        fusion_img.id,
                        d_internal,
                        side_key,
                        crop_pool_by_type,
                        generate_related_images=True,
                    )
                m_internal = parsed.get("modified")
                if m_internal:
                    modified_url_cache_by_side[side_key] = _generate_defect_img_urls_for_json(
                        card_id,
                        fusion_img.id,
                        m_internal,
                        side_key,
                        crop_pool_by_type,
                        generate_related_images=True,
                    )

        for img in all_images:
            image_type = img.image_type
            is_gray = _is_gray_image_type(image_type)
            side_key = _side_key_from_image_type(image_type)
            parsed = parsed_json_by_img_id.get(img.id, {})
            d_internal = parsed.get("detection")
            m_internal = parsed.get("modified")

            if d_internal:
                if is_gray:
                    _clear_defect_img_urls(d_internal)
                elif side_key and detection_url_cache_by_side.get(side_key):
                    _apply_defect_img_urls_from_cache(
                        d_internal, detection_url_cache_by_side[side_key],
                    )
                img.detection_json = convert_internal_to_xy_format(d_internal)
            else:
                img.detection_json = convert_internal_to_xy_format({})

            if m_internal:
                if is_gray:
                    _clear_defect_img_urls(m_internal)
                elif side_key and modified_url_cache_by_side.get(side_key):
                    _apply_defect_img_urls_from_cache(
                        m_internal, modified_url_cache_by_side[side_key],
                    )
                img.modified_json = convert_internal_to_xy_format(m_internal)
            else:
                m_fallback = copy.deepcopy(d_internal) if d_internal else {}
                img.modified_json = convert_internal_to_xy_format(m_fallback)
    logger.info(
        "耗时埋点 _process_images_to_xy_format: card_id=%s image_count=%s elapsed_ms=%.2f",
        card_id, len(all_images), (perf_counter() - start_time) * 1000
    )
    return card_data


def pregenerate_defect_images_for_card(db_conn: PooledMySQLConnection, card_id: int) -> int:
    """
    导入阶段预生成缺陷裁图：以融合图 JSON 为准，按面在同面各类型原图上裁图并写入 MinIO。
    查询接口 get_card_details 命中已存在的裁图后即可直接拼 URL，无需再实时裁图。

    返回本次涉及裁图的缺陷数量（仅用于日志/统计）。
    """
    start_time = perf_counter()
    card_data = crud_card.get_card_with_details(db_conn, card_id)
    if not card_data:
        logger.warning("预生成缺陷裁图跳过：card_id=%s 未找到卡牌", card_id)
        return 0

    all_images = card_data.get("images", [])
    if not all_images:
        return 0

    fusion_by_side = _resolve_fusion_images_by_side(all_images)
    crop_pool_by_type = _build_defect_crop_pool_by_type(card_id, all_images, db_conn=db_conn)

    total_defects = 0
    for side_key, fusion_img in fusion_by_side.items():
        if not fusion_img:
            continue
        for json_field in ("detection_json", "modified_json"):
            raw_json = getattr(fusion_img, json_field, None)
            if isinstance(raw_json, str):
                raw_json = json.loads(raw_json) if raw_json else None
            if not raw_json:
                continue
            # 复制一份，避免污染 Pydantic 对象；只关心裁图副作用（写入 MinIO）
            cache = _generate_defect_img_urls_for_json(
                card_id,
                fusion_img.id,
                copy.deepcopy(raw_json),
                side_key,
                crop_pool_by_type,
                generate_related_images=True,
            )
            total_defects += len(cache)

    logger.info(
        "预生成缺陷裁图完成: card_id=%s defects=%s elapsed_ms=%.2f",
        card_id, total_defects, (perf_counter() - start_time) * 1000,
    )
    return total_defects


@router.get("/query", response_model=CardDetailResponse, summary="获取卡牌详细信息(格式化xy), 支持前后翻页 [用户调用]")
def get_card_details(
        card_id: int = Query(..., description="基准卡牌ID"),
        mode: QueryMode = Query(QueryMode.current, description="查询模式: current(当前), next(下一个), prev(上一个)"),
        db_conn: PooledMySQLConnection = db_dependency
):
    """
    获取卡牌元数据以及所有与之关联的图片信息，并将坐标转换为 xy 格式。
    同时返回上一张和下一张卡牌的ID。

    - **current**: 查询 card_id 对应的卡牌。
    - **next**: 查询 ID 比 card_id 大的第一张卡牌。
    - **prev**: 查询 ID 比 card_id 小的第一张卡牌。
    """
    target_id = card_id
    cursor = None
    start_time = perf_counter()

    try:
        cursor = db_conn.cursor(dictionary=True)

        # 1. 如果是查询上一个或下一个，先计算目标ID
        if mode != QueryMode.current:
            if mode == QueryMode.next:
                query_target = (f"SELECT id FROM {settings.DB_CARD_TABLE_NAME} "
                                f"WHERE id > %s ORDER BY id ASC LIMIT 1")
            else:  # mode == QueryMode.prev
                query_target = (f"SELECT id FROM {settings.DB_CARD_TABLE_NAME} "
                                f"WHERE id < %s ORDER BY id DESC LIMIT 1")

            cursor.execute(query_target, (card_id,))
            row = cursor.fetchone()

            if not row:
                msg = "没有下一张" if mode == QueryMode.next else "没有上一张"
                # 边界场景返回 404，避免与 response_model=CardDetailResponse 冲突
                raise HTTPException(status_code=404, detail=msg)

            target_id = row['id']

        # 2. 获取目标卡牌的详细数据 (Dict 格式)
        card_data = crud_card.get_card_with_details(db_conn, target_id)

        if not card_data:
            raise HTTPException(status_code=404, detail=f"ID为 {target_id} 的卡牌未找到。")

        # 3. 补充当前目标卡牌的 id_prev 和 id_next
        # 注意：这里需要重新获取 cursor，或者使用 cursor (非 dict 模式可能更方便取值，但 dict 模式也行)
        # 这里为了简单直接用 raw SQL

        # 查询上一个ID
        sql_prev = f"SELECT id FROM {settings.DB_CARD_TABLE_NAME} WHERE id < %s ORDER BY id DESC LIMIT 1"
        cursor.execute(sql_prev, (target_id,))
        row_prev = cursor.fetchone()
        card_data['id_prev'] = row_prev['id'] if row_prev else None

        # 查询下一个ID
        sql_next = f"SELECT id FROM {settings.DB_CARD_TABLE_NAME} WHERE id > %s ORDER BY id ASC LIMIT 1"
        cursor.execute(sql_next, (target_id,))
        row_next = cursor.fetchone()
        card_data['id_next'] = row_next['id'] if row_next else None

        # 4. 遍历图片，转换格式 (使用抽取出的辅助函数)
        _process_images_to_xy_format(
            card_data,
            generate_related_images=True,
            db_conn=db_conn,
        )

        # 5. 将 images 从 Pydantic 对象转为 dict，避免 model_validate 重复验证导致类型异常
        if "images" in card_data:
            card_data["images"] = [
                img.model_dump() if hasattr(img, 'model_dump') else img
                for img in card_data["images"]
            ]

        # 6. 验证并返回
        return CardDetailResponse.model_validate(card_data)

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"查询卡牌详情失败 (Mode: {mode}, BaseID: {card_id}): {e}")
        raise HTTPException(status_code=500, detail="数据库查询失败")
    finally:
        logger.info(
            "耗时埋点 get_card_details: base_card_id=%s target_card_id=%s mode=%s elapsed_ms=%.2f",
            card_id, target_id, mode, (perf_counter() - start_time) * 1000
        )
        if cursor:
            cursor.close()


@router.put("/update/json/{id}", status_code=200, summary="接收xy格式, 还原后重计算分数并保存 [用户调用]")
async def update_image_modified_json(
        id: int,
        new_json_data: dict = Body(..., description="前端传来的包含xy对象格式的JSON"),
        current_user: dict = Depends(get_current_user),
        db_conn: PooledMySQLConnection = db_dependency
):
    """
    接收前端传来的特殊格式 JSON (points 为对象列表)。
    1. 将格式还原为后端标准格式 (points 为 [[x,y]])。
    2. 根据 id 获取 image_type。
    3. 调用外部接口重新计算分数。
    4. 更新 modified_json。
    """
    card_id_to_update = None
    cursor = None

    # *** 1. 格式还原 ***
    # 将前端的 xy dict 格式转回 [[x,y]]
    internal_json_payload = convert_xy_to_internal_format(new_json_data)

    try:
        cursor = db_conn.cursor(dictionary=True)

        # 2. 获取图片信息
        cursor.execute(
            f"SELECT image_type, card_id, detection_json, modified_json "
            f"FROM {settings.DB_IMAGE_TABLE_NAME} WHERE id = %s",
            (id,)
        )
        row = cursor.fetchone()
        if not row:
            raise HTTPException(status_code=404, detail=f"ID为 {id} 的图片未找到。")

        card_id_to_update = row["card_id"]
        check_card_permission(db_conn, current_user, card_id_to_update)
        image_type = row["image_type"]
        
        # score_recalculate 接口只接受 coaxial / ring 类型的 score_type，
        # 融合图/灰度图/调光图都按正反面归到对应 ring。
        score_type = _resolve_recalc_score_type(image_type)
        if not score_type:
            raise HTTPException(status_code=400, detail=f"未知的 image_type: {image_type}")

        # 3. 准备重算 payload：以库内原始 JSON 为底稿，仅覆盖编辑后的 defects
        # 对 fusion 图，score_type 会映射到 ring；此时底稿也应优先使用 ring 图 JSON，
        # 否则 fusion 图常见的空框结构会导致算分服务在 ring 逻辑下越界。
        source_json_str = row["modified_json"] if row["modified_json"] else row["detection_json"]
        if image_type in (ImageType.front_fusion.value, ImageType.back_fusion.value):
            target_ring_type = (
                ImageType.front_ring.value
                if image_type == ImageType.front_fusion.value
                else ImageType.back_ring.value
            )
            cursor.execute(
                f"SELECT detection_json, modified_json FROM {settings.DB_IMAGE_TABLE_NAME} "
                f"WHERE card_id = %s AND image_type = %s LIMIT 1",
                (card_id_to_update, target_ring_type)
            )
            ring_row = cursor.fetchone()
            if ring_row:
                source_json_str = ring_row["modified_json"] if ring_row["modified_json"] else ring_row["detection_json"]
            else:
                logger.warning(
                    "fusion图重算未找到对应ring底稿，回退到当前图: image_id=%s card_id=%s image_type=%s target_ring_type=%s",
                    id, card_id_to_update, image_type, target_ring_type
                )

        if isinstance(source_json_str, str):
            source_json_data = json.loads(source_json_str)
        else:
            source_json_data = source_json_str if isinstance(source_json_str, dict) else {}

        payload_for_recalculate = _prepare_recalculate_payload(internal_json_payload, source_json_data)
        _defects = payload_for_recalculate.get("result", {}).get("defect_result", {}).get("defects", [])
        _sanitize_defects_for_recalculate(_defects)

        logger.info(f"开始计算分数 (ID: {id}, Type: {score_type})")

        # 4. 调用远程计算接口
        try:
            response = await run_in_threadpool(
                lambda: requests.post(
                    settings.SCORE_RECALCULATE_ENDPOINT,
                    params={"score_type": score_type},
                    json=payload_for_recalculate,
                    timeout=20
                )
            )
        except Exception as e:
            logger.error(
                "调用分数计算服务失败(update/json): image_id=%s card_id=%s score_type=%s endpoint=%s error=%s",
                id, card_id_to_update, score_type, settings.SCORE_RECALCULATE_ENDPOINT, e,
                exc_info=True
            )
            raise HTTPException(status_code=500, detail=f"调用分数计算服务失败: {e}")

        if response.status_code != 200:
            logger.error(
                "分数计算接口返回错误(update/json): image_id=%s card_id=%s score_type=%s endpoint=%s status=%s body=%s",
                id, card_id_to_update, score_type, settings.SCORE_RECALCULATE_ENDPOINT, response.status_code, response.text
            )
            raise HTTPException(status_code=response.status_code,
                                detail=f"分数计算接口返回错误: {response.text}")
        logger.info("分数计算完成")

        # 获取计算服务返回的结果（这个结果通常已经是标准的 internal 格式，带有分数和面积）
        final_json_data = response.json()

        # 5. 保存结果到数据库
        recalculated_json_str = json.dumps(final_json_data, ensure_ascii=False)
        update_query = (f"UPDATE {settings.DB_IMAGE_TABLE_NAME} "
                        f"SET modified_json = %s, is_edited = TRUE "
                        f"WHERE id = %s")

        cursor.execute(update_query, (recalculated_json_str, id))

        db_conn.commit()
        logger.info(f"图片ID {id} 的 modified_json 已更新并重新计算。")

        # 更新对应的 cards 的分数状态
        try:
            crud_card.update_card_scores_and_status(db_conn, card_id_to_update)
            logger.info(f"卡牌 {card_id_to_update} 的分数和状态已更新。")
        except Exception as score_update_e:
            logger.error(f"更新卡牌 {card_id_to_update} 分数失败: {score_update_e}")

        # 更新卡牌审核状态
        try:
            with db_conn.cursor() as cursor:
                review_state = 2
                # 更新指定 card_id 的 review_state 字段
                # 注意：MySQL 在“值未变化”时 rowcount 可能为 0，这不代表记录不存在。
                query_update = f"UPDATE {settings.DB_CARD_TABLE_NAME} SET review_state = %s WHERE id = %s"
                cursor.execute(query_update, (review_state, card_id_to_update))

                if cursor.rowcount == 0:
                    cursor.execute(f"SELECT 1 FROM {settings.DB_CARD_TABLE_NAME} WHERE id = %s LIMIT 1",
                                   (card_id_to_update,))
                    if not cursor.fetchone():
                        raise HTTPException(status_code=404, detail=f"ID为 {card_id_to_update} 的卡牌未找到。")

                db_conn.commit()
                logger.info(f"卡牌 ID {card_id_to_update} 的审核状态已成功修改为 {review_state}。")

        except Exception as e:
            db_conn.rollback()
            logger.error(f"修改卡牌 {id} 审核状态失败: {e}")
            if isinstance(e, HTTPException):
                raise e
            raise HTTPException(status_code=500, detail="修改审核状态失败，数据库操作错误。")

        return {
            "detail": f"成功更新图片ID {id} 的JSON数据",
            "image_type": image_type,
            "score_type": score_type
        }

    except HTTPException:
        db_conn.rollback()
        raise
    except Exception as e:
        db_conn.rollback()
        logger.error(f"更新JSON失败 ({id}): {e}")
        raise HTTPException(status_code=500, detail=f"更新JSON数据失败: {e}")
    finally:
        if cursor:
            cursor.close()


# 处理灰度如
@router.put("/update/json_gray/{id}", status_code=200, summary="[灰度] 接收xy格式, 合并至Ring图重计算并保存 [用户调用]")
async def update_gray_image_json(
        id: int,
        new_json_data: dict = Body(..., description="前端传来的灰度图编辑后的JSON(xy格式)"),
        current_user: dict = Depends(get_current_user),
        db_conn: PooledMySQLConnection = db_dependency
):
    """
    针对灰度图 (front_gray/back_gray) 的保存逻辑。
    """
    cursor = None

    # 1. 格式还原
    internal_gray_json = convert_xy_to_internal_format(new_json_data)
    gray_defects = internal_gray_json.get("result", {}).get("defect_result", {}).get("defects", [])
    
    # 丢弃前端展示用的辅助字段，防止传给算分服务导致报错
    for d in gray_defects:
        if d.get("label") == "slight_scratch":
            d["label"] = "scratch"
        d.pop("defectImgUrl", None)
        d.pop("defectImgUrls", None)

    try:
        cursor = db_conn.cursor(dictionary=True)

        # 2. 获取辅助图（灰度图/融合图）信息
        # 以前只查 card_gray_images，现在融合图是在 card_images 表里
        # 先查 card_gray_images
        cursor.execute(f"SELECT card_id, image_type FROM {settings.DB_GRAY_IMAGE_TABLE_NAME} WHERE id = %s", (id,))
        gray_row = cursor.fetchone()
        
        if not gray_row:
            # 如果灰度表没找到，去主表找找看是不是融合图
            cursor.execute(f"SELECT card_id, image_type FROM {settings.DB_IMAGE_TABLE_NAME} WHERE id = %s AND image_type IN ('front_fusion', 'back_fusion')", (id,))
            gray_row = cursor.fetchone()
            if not gray_row:
                raise HTTPException(status_code=404, detail=f"ID为 {id} 的辅助图未找到。")

        card_id = gray_row['card_id']
        check_card_permission(db_conn, current_user, card_id)
        gray_image_type = gray_row['image_type']

        # 3. 确定目标 Ring 图类型
        target_ring_type = None
        if gray_image_type in (ImageType.front_gray.value, ImageType.front_fusion.value):
            target_ring_type = ImageType.front_ring.value
        elif gray_image_type in (ImageType.back_gray.value, ImageType.back_fusion.value):
            target_ring_type = ImageType.back_ring.value
        else:
            raise HTTPException(status_code=400, detail=f"不支持的辅助图类型: {gray_image_type}")

        # 4. 获取目标 Ring 图数据 (Card Images 表)
        cursor.execute(
            f"SELECT id, detection_json, modified_json FROM {settings.DB_IMAGE_TABLE_NAME} "
            f"WHERE card_id = %s AND image_type = %s",
            (card_id, target_ring_type)
        )
        ring_row = cursor.fetchone()

        if not ring_row:
            raise HTTPException(status_code=404, detail=f"未找到对应的 Ring 图 ({target_ring_type})，无法应用修改。")

        ring_image_id = ring_row['id']
        # 优先使用 modified_json，如果没有则使用 detection_json
        source_json_str = ring_row['modified_json'] if ring_row['modified_json'] else ring_row['detection_json']

        if isinstance(source_json_str, str):
            ring_json_data = json.loads(source_json_str)
        else:
            ring_json_data = source_json_str

        # 5. 合并逻辑 (Merge Logic)
        # 确保路径存在
        if "result" not in ring_json_data: ring_json_data["result"] = {}
        if "defect_result" not in ring_json_data["result"]: ring_json_data["result"]["defect_result"] = {}
        if "defects" not in ring_json_data["result"]["defect_result"]: ring_json_data["result"]["defect_result"][
            "defects"] = []

        ring_defects = ring_json_data["result"]["defect_result"]["defects"]

        # 遍历灰度图传来的新缺陷列表
        for new_defect in gray_defects:
            is_fusion = gray_image_type in (ImageType.front_fusion.value, ImageType.back_fusion.value)
            key_to_check = "fusion_id" if is_fusion else "gray_id"
            
            identifier = new_defect.get(key_to_check)

            # 只有带有对应标识的才进行特殊合并处理
            # 如果没有，视作普通新缺陷直接添加
            if not identifier:
                ring_defects.append(new_defect)
                continue

            # 在 Ring 图现有的缺陷中寻找匹配的标识
            match_index = -1
            for i, old_defect in enumerate(ring_defects):
                if old_defect.get(key_to_check) == identifier:
                    match_index = i
                    break

            if match_index != -1:
                # 存在：替换 (Replace)
                ring_defects[match_index] = new_defect
            else:
                # 不存在：添加 (Append)
                ring_defects.append(new_defect)

        # 6. 调用计算服务 (对 Ring 图数据进行重算)
        # score_recalculate 接口接受 ring 类型，直接用目标 ring 类型即可
        score_type = _resolve_recalc_score_type(target_ring_type)

        logger.info(f"开始重计算 Ring 图分数 (GrayID: {id} -> RingID: {ring_image_id}, Type: {score_type})")

        try:
            response = await run_in_threadpool(
                lambda: requests.post(
                    settings.SCORE_RECALCULATE_ENDPOINT,
                    params={"score_type": score_type},
                    json=ring_json_data,  # 发送合并后的 Ring 数据
                    timeout=20
                )
            )
        except Exception as e:
            logger.error(
                "调用分数计算服务失败(update/json_gray): gray_id=%s ring_id=%s card_id=%s score_type=%s endpoint=%s error=%s",
                id, ring_image_id, card_id, score_type, settings.SCORE_RECALCULATE_ENDPOINT, e,
                exc_info=True
            )
            raise HTTPException(status_code=500, detail=f"调用分数计算服务失败: {e}")

        if response.status_code != 200:
            logger.error(
                "分数计算接口返回错误(update/json_gray): gray_id=%s ring_id=%s card_id=%s score_type=%s endpoint=%s status=%s body=%s",
                id, ring_image_id, card_id, score_type, settings.SCORE_RECALCULATE_ENDPOINT, response.status_code, response.text
            )
            raise HTTPException(status_code=response.status_code,
                                detail=f"分数计算接口返回错误: {response.text}")

        final_ring_json = response.json()

        # 7. 保存结果到数据库 (保存到 Ring 图记录)
        final_json_str = json.dumps(final_ring_json, ensure_ascii=False)

        update_query = (
            f"UPDATE {settings.DB_IMAGE_TABLE_NAME} "
            f"SET modified_json = %s, is_edited = TRUE "
            f"WHERE id = %s"
        )
        cursor.execute(update_query, (final_json_str, ring_image_id))
        db_conn.commit()

        logger.info(f"Ring 图 {ring_image_id} 已根据灰度图 {id} 的修改进行了更新。")

        # 8. 更新卡牌总分状态
        try:
            crud_card.update_card_scores_and_status(db_conn, card_id)
        except Exception as e:
            logger.error(f"更新卡牌 {card_id} 分数状态失败: {e}")

        # 更新卡牌审核状态
        try:
            with db_conn.cursor() as cursor:
                review_state = 2
                # 更新指定 card_id 的 review_state 字段
                # 注意：MySQL 在 “值未变化” 的情况下 rowcount 可能为 0，但这不代表记录不存在。
                query_update = f"UPDATE {settings.DB_CARD_TABLE_NAME} SET review_state = %s WHERE id = %s"
                cursor.execute(query_update, (review_state, card_id))

                if cursor.rowcount == 0:
                    cursor.execute(f"SELECT 1 FROM {settings.DB_CARD_TABLE_NAME} WHERE id = %s LIMIT 1", (card_id,))
                    if not cursor.fetchone():
                        raise HTTPException(status_code=404, detail=f"ID为 {card_id} 的卡牌未找到。")

                db_conn.commit()
                logger.info(f"卡牌 ID {card_id} 的审核状态已成功修改为 {review_state}。")

        except Exception as e:
            db_conn.rollback()
            logger.error(f"修改卡牌 {id} 审核状态失败: {e}")
            if isinstance(e, HTTPException):
                raise e
            raise HTTPException(status_code=500, detail="修改审核状态失败，数据库操作错误。")

        return {
            "detail": f"成功应用灰度图修改到 {target_ring_type}",
            "target_ring_id": ring_image_id,
            "gray_id": id
        }

    except HTTPException:
        db_conn.rollback()
        raise
    except Exception as e:
        db_conn.rollback()
        logger.error(f"灰度图更新失败 ({id}): {e}")
        raise HTTPException(status_code=500, detail=f"系统内部错误: {e}")
    finally:
        if cursor:
            cursor.close()