菜單圖片 AI 辨識：上傳照片自動建立菜單

# app/services/ai_service.py
import asyncio
import json
import re
import tempfile
import time
from pathlib import Path

class AiService:
    async def recognize_menu(self, image_bytes: bytes) -> dict:
        """
        辨識菜單圖片（使用 Claude Code (CLI) + Read 工具）

        Returns:
            {
                "categories": [
                    {
                        "name": "分類名稱",
                        "items": [
                            {
                                "name": "品項名稱",
                                "price": 100,
                                "description": "描述",
                                "variants": [{"name": "M", "price": 50}]
                            }
                        ]
                    }
                ]
            }
        """
        # 建立暫存檔
        temp_dir = Path(tempfile.gettempdir()) / "jaba-ai"
        temp_dir.mkdir(exist_ok=True)
        temp_path = str(temp_dir / f"menu_temp_{int(time.time())}.jpg")

        with open(temp_path, 'wb') as f:
            f.write(image_bytes)

        try:
            # 取得菜單辨識提示詞（從快取/DB）
            prompt = CacheService.get_prompt("menu_recognition")
            if not prompt:
                return {
                    "categories": [],
                    "error": "找不到菜單辨識提示詞"
                }

            # 建構 Claude Code (CLI) 命令
            full_prompt = f"請先使用 Read 工具讀取圖片 {temp_path}，然後{prompt}"
            cmd = [
                self.claude_path, "-p", full_prompt,
                "--model", self.menu_model,
                "--tools", "Read",
                "--allowedTools", "Read",
                "--dangerously-skip-permissions"
            ]

            # 非同步執行
            proc = await asyncio.create_subprocess_exec(
                *cmd,
                stdout=asyncio.subprocess.PIPE,
                stderr=asyncio.subprocess.PIPE,
                cwd=self.working_dir,
            )
            stdout_bytes, stderr_bytes = await asyncio.wait_for(
                proc.communicate(),
                timeout=300  # 圖片辨識可能需要較長時間
            )
            response_text = (stdout_bytes.decode('utf-8') if stdout_bytes else '').strip()

            # 解析 JSON 回應
            json_match = re.search(r'\{[\s\S]*\}', response_text)
            if json_match:
                menu_data = json.loads(json_match.group())
                if "categories" in menu_data:
                    return menu_data

            return {"categories": [], "error": "AI 回應格式錯誤"}

        except asyncio.TimeoutError:
            return {"categories": [], "error": "辨識超時，請稍後再試"}
        finally:
            # 清理暫存檔
            if os.path.exists(temp_path):
                os.unlink(temp_path)

# migrations/versions/002_seed_ai_prompts.py
DEFAULT_PROMPTS = {
    "menu_recognition": """請分析這張菜單圖片，提取所有菜單項目以及店家資訊。

回傳 JSON 格式：
```json
{
  "store_info": {
    "name": "店家名稱（如果圖片中有顯示）",
    "phone": "電話號碼（如果圖片中有顯示）",
    "address": "地址（如果圖片中有顯示）"
  },
  "categories": [
    {
      "name": "分類名稱",
      "items": [
        {
          "name": "品項名稱",
          "price": 數字價格,
          "variants": [{"name": "M", "price": 50}, {"name": "L", "price": 60}],
          "description": "描述（如有）",
          "promo": null
        }
      ]
    }
  ],
  "warnings": ["無法辨識的項目或需要確認的事項"]
}

# app/services/menu_service.py
from PIL import Image
import io

class MenuService:
    def _compress_image(
        self, image_bytes: bytes, max_size: int = 1920, quality: int = 85
    ) -> bytes:
        """
        壓縮圖片（用於 AI 辨識）

        智能檢查：如果圖片檔案 < 500KB 且尺寸 <= max_size，跳過壓縮避免品質損失
        """
        try:
            img = Image.open(io.BytesIO(image_bytes))
            original_size = len(image_bytes)
            needs_resize = max(img.size) > max_size
            needs_convert = img.mode in ("RGBA", "P")

            # 智能檢查：檔案已經夠小且尺寸合適，跳過壓縮
            if original_size < 500 * 1024 and not needs_resize and not needs_convert:
                logger.debug(f"圖片已壓縮，跳過處理")
                return image_bytes

            # 轉換為 RGB（如果是 RGBA）
            if needs_convert:
                img = img.convert("RGB")

            # 保持比例縮放
            if needs_resize:
                ratio = max_size / max(img.size)
                new_size = (int(img.size[0] * ratio), int(img.size[1] * ratio))
                img = img.resize(new_size, Image.Resampling.LANCZOS)

            # 輸出為 JPEG
            output = io.BytesIO()
            img.save(output, format="JPEG", quality=quality)
            compressed = output.getvalue()

            logger.debug(f"圖片壓縮完成: {original_size} → {len(compressed)} bytes")
            return compressed

        except Exception as e:
            logger.error(f"Image compression error: {e}")
            return image_bytes

# app/routers/admin.py
@router.post("/menu/recognize")
async def recognize_menu_only(
    file: UploadFile = File(...),
    db: AsyncSession = Depends(get_db),
    _: bool = Depends(verify_admin_token),
):
    """辨識菜單圖片（不需要指定店家）"""
    service = MenuService(db)
    image_bytes = await file.read()
    result = await service.recognize_menu_image(image_bytes)
    return result

@router.post("/stores/{store_id}/menu/recognize")
async def recognize_menu(
    store_id: UUID,
    file: UploadFile = File(...),
    db: AsyncSession = Depends(get_db),
    _: bool = Depends(verify_admin_token),
):
    """辨識菜單圖片並與現有菜單比對"""
    service = MenuService(db)
    image_bytes = await file.read()

    # 辨識新菜單
    recognized_menu = await service.recognize_menu_image(image_bytes)

    # 取得現有菜單
    existing_menu = await service.get_store_menu(store_id)

    # 比對差異
    diff = None
    if existing_menu:
        diff = service.compare_menus(existing_menu, recognized_menu)

    return {
        "recognized_menu": recognized_menu,
        "existing_menu": existing_menu,
        "diff": diff,
        "store_id": str(store_id),
    }

# app/services/menu_service.py

def compare_menus(self, old_menu: dict, new_menu: dict) -> dict:
    """
    比較新舊菜單差異

    Returns:
        {
            "added": [...],      # 新增的品項
            "modified": [...],   # 價格或內容變更的品項
            "unchanged": [...],  # 沒有變更的品項
            "removed": [...]     # 舊菜單有但新菜單沒有的品項
        }
    """
    # 建立索引（用正規化名稱作為 key）
    old_items = {}
    for cat in old_menu.get("categories", []):
        for item in cat.get("items", []):
            key = self._normalize_name(item["name"])
            old_items[key] = {"category": cat["name"], **item}

    new_items = {}
    for cat in new_menu.get("categories", []):
        for item in cat.get("items", []):
            key = self._normalize_name(item["name"])
            new_items[key] = {"category": cat["name"], **item}

    # 比較
    added = []
    modified = []
    unchanged = []
    removed = []

    for key, new_item in new_items.items():
        if key not in old_items:
            added.append(new_item)
        else:
            old_item = old_items[key]
            if self._items_differ(old_item, new_item):
                modified.append({
                    "old": old_item,
                    "new": new_item,
                    "changes": self._get_item_changes(old_item, new_item),
                })
            else:
                unchanged.append(new_item)

    for key, old_item in old_items.items():
        if key not in new_items:
            removed.append(old_item)

    return {
        "added": added,
        "modified": modified,
        "unchanged": unchanged,
        "removed": removed,
    }

def _normalize_name(self, name: str) -> str:
    """正規化品項名稱（去除空白和標點）"""
    import re
    return re.sub(r"[\s\W]", "", name.lower())

async def save_menu_diff(
    self,
    store_id: UUID,
    apply_items: List[dict],   # 要套用的品項
    remove_items: List[str],   # 要刪除的品項名稱
) -> Menu:
    """
    選擇性儲存菜單（差異模式）
    """
    # 取得現有菜單
    existing_menu = await self.get_store_menu(store_id)
    if not existing_menu:
        # 沒有現有菜單，直接建立
        categories_data = self._group_items_by_category(apply_items)
        return await self.save_menu(store_id, categories_data)

    # 建立現有品項索引
    existing_by_key = {}
    for cat in existing_menu.get("categories", []):
        for item in cat.get("items", []):
            key = self._normalize_name(item["name"])
            existing_by_key[key] = {"category": cat["name"], **item}

    # 移除指定品項
    for key in remove_items:
        normalized_key = self._normalize_name(key)
        if normalized_key in existing_by_key:
            del existing_by_key[normalized_key]

    # 套用新品項（新增或修改）
    for item in apply_items:
        key = self._normalize_name(item["name"])
        existing_by_key[key] = item

    # 重組成分類結構
    categories_data = self._group_items_by_category(list(existing_by_key.values()))

    return await self.save_menu(store_id, categories_data)

# 可能的錯誤回應
{
    "categories": [],
    "error": "找不到菜單辨識提示詞"
}

{
    "categories": [],
    "error": "辨識超時，請稍後再試"
}

{
    "categories": [],
    "error": "AI 回應格式錯誤"
}