Mediwise Health Suite

# Git files
.git/
.gitignore

# Documentation (keep only essential)
DELIVERY_SUMMARY.md
PROJECT_COMPLETE.md
FINAL_REPORT.md
RELEASE_SUMMARY.md

# Test data
**/test_data/

# Temporary files
*.tmp
*.log
.DS_Store

# Python cache
__pycache__/
*.pyc
*.pyo

# IDE
.vscode/
.idea/

# Mediwise Health Suite - Local data (NEVER package)
*.db
*.db-wal
*.db-shm
*.sqlite
*.sqlite-wal
*.sqlite-shm
*.sqlite3
*.sqlite3-wal
*.sqlite3-shm
data/
**/data/
attachments/
**/attachments/
exports/
**/exports/
!exports/.gitkeep
backups/
**/backups/
logs/
**/logs/

# MediWise Health Suite — 环境变量配置模板
# 复制为 .env 并填入你的值，或直接在系统/Docker 中设置这些变量
# 所有变量均为可选，未设置时使用默认行为（本地 SQLite，无 AI 功能）
#
# 推荐使用 direnv / Docker --env-file / systemd EnvironmentFile 加载此文件

# ============================================================
# 多模态视觉模型（图片识别体检报告、化验单、病历等）
# 【强烈推荐配置】不配置则无法识别图片/PDF
# ============================================================

# --- 方案 A：硅基流动（国内，推荐）---
# Qwen2.5-VL 系列视觉能力强，价格低，国内访问稳定
# 注册（含邀请奖励）：https://cloud.siliconflow.cn/i/MOlLXTYM
MEDIWISE_VISION_PROVIDER=siliconflow
MEDIWISE_VISION_MODEL=Qwen/Qwen2.5-VL-72B-Instruct
MEDIWISE_VISION_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
MEDIWISE_VISION_BASE_URL=https://api.siliconflow.cn/v1

# --- 方案 B：Google Gemini 3（多模态效果强，推荐海外用户）---
# 获取 API Key：https://aistudio.google.com/app/apikey
# MEDIWISE_VISION_PROVIDER=openai
# MEDIWISE_VISION_MODEL=gemini-3.1-pro-preview
# MEDIWISE_VISION_API_KEY=AIzaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# MEDIWISE_VISION_BASE_URL=https://generativelanguage.googleapis.com/v1beta/openai

# --- 方案 C：OpenAI GPT-4o ---
# MEDIWISE_VISION_PROVIDER=openai
# MEDIWISE_VISION_MODEL=gpt-4o
# MEDIWISE_VISION_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# MEDIWISE_VISION_BASE_URL=https://api.openai.com/v1

# --- 方案 D：阶跃星辰 Step-1V（国内备选）---
# MEDIWISE_VISION_PROVIDER=openai
# MEDIWISE_VISION_MODEL=step-1v-32k
# MEDIWISE_VISION_API_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# MEDIWISE_VISION_BASE_URL=https://api.stepfun.com/v1

# --- 方案 E：本地 Ollama（完全离线，需自行部署）---
# 支持 llava / minicpm-v / qwen2-vl 等本地视觉模型
# MEDIWISE_VISION_PROVIDER=ollama
# MEDIWISE_VISION_MODEL=qwen2-vl:7b
# MEDIWISE_VISION_API_KEY=ollama
# MEDIWISE_VISION_BASE_URL=http://localhost:11434/v1

# ============================================================
# 纯文本 LLM（结构化提取、快速录入解析）
# 不设置则自动复用上面的视觉模型（推荐）
# 如需单独配置更快/更便宜的文本模型可在此填写
# ============================================================
# MEDIWISE_LLM_PROVIDER=siliconflow
# MEDIWISE_LLM_MODEL=Qwen/Qwen2.5-72B-Instruct
# MEDIWISE_LLM_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# MEDIWISE_LLM_BASE_URL=https://api.siliconflow.cn/v1
# 注册硅基流动（含邀请奖励）：https://cloud.siliconflow.cn/i/MOlLXTYM

# ============================================================
# 多租户隔离（共享实例必填，个人使用可不填）
# 每个用户/渠道设置不同的 MEDIWISE_OWNER_ID，数据自动隔离
# ============================================================
# MEDIWISE_OWNER_ID=user_alice

# ============================================================
# 数据存储路径（可选，默认存在系统用户数据目录）
# ============================================================
# MEDIWISE_DATA_DIR=/data/mediwise
# MEDIWISE_MEDICAL_DB_PATH=/data/mediwise/medical.db
# MEDIWISE_LIFESTYLE_DB_PATH=/data/mediwise/lifestyle.db

# ============================================================
# USDA 食材数据库（可选，用于国际食材查询）
# 免费注册：https://api.data.gov/signup/
# 未设置时使用内置离线数据库
# ============================================================
# USDA_API_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

# Byte-compiled / optimized / DLL files
__pycache__/
*.py[codz]
*$py.class

# C extensions
*.so

# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST

# PyInstaller
#  Usually these files are written by a python script from a template
#  before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec

# Installer logs
pip-log.txt
pip-delete-this-directory.txt

# Unit test / coverage reports
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
*.py.cover
.hypothesis/
.pytest_cache/
cover/

# Translations
*.mo
*.pot

# Django stuff:
*.log
local_settings.py
db.sqlite3
db.sqlite3-journal

# Flask stuff:
instance/
.webassets-cache

# Scrapy stuff:
.scrapy

# Sphinx documentation
docs/_build/

# PyBuilder
.pybuilder/
target/

# Jupyter Notebook
.ipynb_checkpoints

# IPython
profile_default/
ipython_config.py

# pyenv
#   For a library or package, you might want to ignore these files since the code is
#   intended to run in multiple environments; otherwise, check them in:
# .python-version

# pipenv
#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
#   However, in case of collaboration, if having platform-specific dependencies or dependencies
#   having no cross-platform support, pipenv may install dependencies that don't work, or not
#   install all needed dependencies.
#Pipfile.lock

# UV
#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
#   This is especially recommended for binary packages to ensure reproducibility, and is more
#   commonly ignored for libraries.
#uv.lock

# poetry
#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
#   This is especially recommended for binary packages to ensure reproducibility, and is more
#   commonly ignored for libraries.
#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
#poetry.lock
#poetry.toml

# pdm
#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
#pdm.lock
#pdm.toml
.pdm-python
.pdm-build/

# pixi
#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
#pixi.lock
#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
#   in the .venv directory. It is recommended not to include this directory in version control.
.pixi

# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
__pypackages__/

# Celery stuff
celerybeat-schedule
celerybeat.pid

# SageMath parsed files
*.sage.py

# Environments
.env
.envrc
.venv
env/
venv/
ENV/
env.bak/
venv.bak/

# Spyder project settings
.spyderproject
.spyproject

# Rope project settings
.ropeproject

# mkdocs documentation
/site

# mypy
.mypy_cache/
.dmypy.json
dmypy.json

# Pyre type checker
.pyre/

# pytype static type analyzer
.pytype/

# Cython debug symbols
cython_debug/

# PyCharm
#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
#  and can be added to the global gitignore or merged into this file.  For a more nuclear
#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
#.idea/

# Abstra
# Abstra is an AI-powered process automation framework.
# Ignore directories containing user credentials, local state, and settings.
# Learn more at https://abstra.io/docs
.abstra/

# Visual Studio Code
#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
#  you could uncomment the following to ignore the entire vscode folder
# .vscode/

# Ruff stuff:
.ruff_cache/

# PyPI configuration file
.pypirc

# Cursor
#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
#  refer to https://docs.cursor.com/context/ignore-files
.cursorignore
.cursorindexingignore

# Marimo
marimo/_static/
marimo/_lsp/
__marimo__/

# Mediwise Health Suite - Local data (NEVER commit)
*.db
*.db-wal
*.db-shm
*.sqlite
*.sqlite-wal
*.sqlite-shm
*.sqlite3
*.sqlite3-wal
*.sqlite3-shm
data/
**/data/
attachments/
**/attachments/
exports/
**/exports/
!exports/.gitkeep
backups/
**/backups/
logs/
**/logs/
# Mediwise - test data with PII
**/test_data/*.db
**/test_data/*.sqlite
**/test_data/*.json
!**/test_data/.gitkeep
# Mediwise - local config may contain API keys (default stored outside repo, but guard anyway)
config.json
**/config.json

interface:
  display_name: "饮食记录"
  short_description: "记录每日饮食、食物条目，并分析热量与营养趋势变化情况"
  default_prompt: "Use $diet-tracker to log meals and summarize calorie and nutrition trends."

/**
 * Diet Tracker - OpenClaw Skill
 *
 * ESM entry point that routes actions to Python scripts.
 */

import { execFile } from 'node:child_process';
import { promisify } from 'node:util';
import { resolve, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';

const execFileAsync = promisify(execFile);
const __dirname = dirname(fileURLToPath(import.meta.url));
const SCRIPTS_DIR = resolve(__dirname, 'scripts');
const HEALTH_SCRIPTS_DIR = resolve(__dirname, '..', 'mediwise-health-tracker', 'scripts');

/**
 * Action-to-script routing table.
 */
const ROUTES = {
  'add-meal': (inputs) => {
    const args = ['add-meal', '--member-id', inputs.member_id,
                  '--meal-type', inputs.params?.meal_type ?? 'lunch',
                  '--meal-date', inputs.params?.meal_date ?? ''];
    if (inputs.params?.meal_time) args.push('--meal-time', inputs.params.meal_time);
    if (inputs.params?.note) args.push('--note', inputs.params.note);
    if (inputs.params?.items) args.push('--items', JSON.stringify(inputs.params.items));
    return { script: 'diet.py', args };
  },
  'add-item': (inputs) => {
    const args = ['add-item', '--record-id', inputs.params?.record_id ?? ''];
    const p = inputs.params ?? {};
    args.push('--food-name', p.food_name ?? '');
    if (p.amount != null) args.push('--amount', String(p.amount));
    if (p.unit) args.push('--unit', p.unit);
    if (p.calories != null) args.push('--calories', String(p.calories));
    if (p.protein != null) args.push('--protein', String(p.protein));
    if (p.fat != null) args.push('--fat', String(p.fat));
    if (p.carbs != null) args.push('--carbs', String(p.carbs));
    if (p.fiber != null) args.push('--fiber', String(p.fiber));
    if (p.note) args.push('--note', p.note);
    return { script: 'diet.py', args };
  },
  'list-meals': (inputs) => {
    const args = ['list', '--member-id', inputs.member_id];
    const p = inputs.params ?? {};
    if (p.date) args.push('--date', p.date);
    if (p.start_date) args.push('--start-date', p.start_date);
    if (p.end_date) args.push('--end-date', p.end_date);
    if (p.meal_type) args.push('--meal-type', p.meal_type);
    if (p.limit) args.push('--limit', String(p.limit));
    return { script: 'diet.py', args };
  },
  'delete-meal': (inputs) => {
    const args = ['delete', '--id', inputs.params?.id ?? ''];
    if (inputs.params?.type) args.push('--type', inputs.params.type);
    return { script: 'diet.py', args };
  },
  'daily-summary': (inputs) => ({
    script: 'diet.py',
    args: ['daily-summary', '--member-id', inputs.member_id,
           '--date', inputs.params?.date ?? ''],
  }),
  'weekly-summary': (inputs) => {
    const args = ['weekly-summary', '--member-id', inputs.member_id];
    if (inputs.params?.end_date) args.push('--end-date', inputs.params.end_date);
    return { script: 'nutrition.py', args };
  },
  'calorie-trend': (inputs) => {
    const args = ['calorie-trend', '--member-id', inputs.member_id];
    if (inputs.params?.days) args.push('--days', String(inputs.params.days));
    return { script: 'nutrition.py', args };
  },
  'nutrition-balance': (inputs) => {
    const args = ['nutrition-balance', '--member-id', inputs.member_id];
    if (inputs.params?.days) args.push('--days', String(inputs.params.days));
    return { script: 'nutrition.py', args };
  },
  'food-lookup': (inputs) => {
    const args = ['search', '--query', inputs.params?.query ?? ''];
    if (inputs.params?.limit) args.push('--limit', String(inputs.params.limit));
    if (inputs.params?.source) args.push('--source', inputs.params.source);
    if (inputs.params?.no_brands) args.push('--no-brands');
    return { script: 'food_lookup.py', args };
  },
  'food-stats': () => ({ script: 'food_lookup.py', args: ['stats'] }),
};

/**
 * Run a Python script and return parsed JSON output.
 */
async function runScript(script, args) {
  const scriptPath = resolve(SCRIPTS_DIR, script);
  const { stdout } = await execFileAsync('python3', [scriptPath, ...args], {
    timeout: 30_000,
    env: { ...process.env, PYTHONPATH: HEALTH_SCRIPTS_DIR },
  });
  return JSON.parse(stdout.trim());
}

/**
 * OpenClaw Skill entry point.
 */
export async function execute(inputs, context) {
  const { action } = inputs;
  const log = context?.log ?? console.log;
  log(`[diet-tracker] action=${action}`);

  const routeFn = ROUTES[action];
  if (!routeFn) {
    return { status: 'error', error: `Unknown action: ${action}` };
  }

  try {
    const { script, args } = routeFn(inputs);

    const ownerId = inputs.owner_id;
    if (ownerId) {
      args.push('--owner-id', ownerId);
    }

    log(`[diet-tracker] script=${script} args=${args.join(' ')}`);
    const result = await runScript(script, args);
    return { status: 'ok', result };
  } catch (err) {
    const message = err instanceof Error ? err.message : String(err);
    log(`[diet-tracker] error: ${message}`);
    return { status: 'error', error: message };
  }
}

{
  "name": "@mediwise/diet-tracker-skill",
  "version": "0.1.0",
  "type": "module",
  "main": "index.js",
  "description": "日常饮食记录与营养分析 OpenClaw Skill",
  "author": "mediwise",
  "license": "MIT",
  "keywords": ["openclaw", "skill", "health", "diet", "nutrition"]
}

"""饮食记录 CRUD 与每日摘要。"""

from __future__ import annotations

import argparse
import json
import logging
import sys
import os

_logger = logging.getLogger(__name__)

# Unified path setup
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'shared'))
from path_setup import setup_mediwise_path
setup_mediwise_path()

from health_db import (
    ensure_db,
    get_medical_connection,
    get_lifestyle_connection,
    generate_id,
    now_iso,
    row_to_dict,
    rows_to_list,
    output_json,
    transaction,
    verify_member_ownership,
)
from validators import validate_date, validate_date_optional
from metric_utils import get_member_or_error

VALID_MEAL_TYPES = ["breakfast", "lunch", "dinner", "snack"]

_GRAM_UNITS = {'g', '克', 'gram', 'grams'}


def _autofill_item_nutrition(item: dict) -> dict:
    """Auto-fill nutrition from food_lookup when user didn't provide calorie data."""
    if item.get('calories'):
        return item
    food_name = item.get('food_name', '')
    if not food_name:
        return item
    try:
        import food_lookup as _fl
        result = _fl.get_by_name(food_name)
        if not result:
            # Exact match failed; try search and take the best result
            hits = _fl.search(food_name, limit=1, source='auto')
            if hits and hits.get('results'):
                result = hits['results'][0]
        if not result:
            return item
        # Scale per-100g sources by amount if user specified grams
        amount = item.get('amount')
        unit = (item.get('unit') or '').lower().strip()
        scale = 1.0
        if result.get('per') == '100g' and amount and unit in _GRAM_UNITS:
            scale = float(amount) / 100.0

        def _val(field):
            v = result.get(field)
            return round(v * scale, 1) if v is not None else 0

        item = dict(item)
        item['calories'] = _val('kcal')
        item['protein'] = _val('protein')
        item['fat'] = _val('fat')
        item['carbs'] = _val('carbs')
        item['fiber'] = _val('fiber')
        if not item.get('note'):
            item['note'] = f"营养数据来源: {result.get('source_name', result.get('source', ''))}"
    except Exception as e:
        _logger.warning("food_lookup auto-fill failed for '%s': %s", food_name, e)
    return item

MEAL_TYPE_NAMES = {
    "breakfast": "早餐",
    "lunch": "午餐",
    "dinner": "晚餐",
    "snack": "加餐",
}


def _parse_items(items_json):
    """Parse and validate items JSON array."""
    if not items_json:
        return []
    if isinstance(items_json, str):
        items = json.loads(items_json)
    else:
        items = items_json
    if not isinstance(items, list):
        raise ValueError("items 必须为 JSON 数组")
    for i, item in enumerate(items):
        if not isinstance(item, dict):
            raise ValueError(f"items[{i}] 必须为对象")
        if not item.get("food_name"):
            raise ValueError(f"items[{i}].food_name 不能为空")
    return [_autofill_item_nutrition(item) for item in items]


def _compute_totals(conn, record_id):
    """Recompute and update totals for a diet record from its items."""
    rows = conn.execute(
        "SELECT calories, protein, fat, carbs, fiber FROM diet_items WHERE record_id=? AND is_deleted=0",
        (record_id,)
    ).fetchall()
    totals = {"total_calories": 0, "total_protein": 0, "total_fat": 0, "total_carbs": 0, "total_fiber": 0}
    for r in rows:
        totals["total_calories"] += r["calories"] or 0
        totals["total_protein"] += r["protein"] or 0
        totals["total_fat"] += r["fat"] or 0
        totals["total_carbs"] += r["carbs"] or 0
        totals["total_fiber"] += r["fiber"] or 0
    conn.execute(
        """UPDATE diet_records SET total_calories=?, total_protein=?, total_fat=?, total_carbs=?, total_fiber=?
           WHERE id=?""",
        (totals["total_calories"], round(totals["total_protein"], 1),
         round(totals["total_fat"], 1), round(totals["total_carbs"], 1),
         round(totals["total_fiber"], 1), record_id)
    )
    return totals


def add_meal(args):
    """添加一餐记录（含多个食物条目）。"""
    ensure_db()

    with transaction(domain="medical") as medical_conn:
        m = get_member_or_error(medical_conn, args.member_id)
        if not m:
            output_json({"status": "error", "message": f"未找到成员: {args.member_id}"})
            return
        if not verify_member_ownership(medical_conn, args.member_id, args.owner_id):
            output_json({"status": "error", "message": "无权访问该成员"})
            return

    if args.meal_type not in VALID_MEAL_TYPES:
        output_json({"status": "error", "message": f"不支持的餐次类型: {args.meal_type}，支持: {', '.join(VALID_MEAL_TYPES)}"})
        return

    try:
        meal_date = validate_date(args.meal_date, "用餐日期")
    except ValueError as e:
        output_json({"status": "error", "message": str(e)})
        return

    try:
        items = _parse_items(args.items)
    except (ValueError, json.JSONDecodeError) as e:
        output_json({"status": "error", "message": f"食物条目格式错误: {e}"})
        return

    with transaction(domain="lifestyle") as conn:
        # Re-verify member still exists before writing (reduces TOCTOU window)
        member_check = get_medical_connection()
        try:
            if not member_check.execute(
                "SELECT 1 FROM members WHERE id=? AND is_deleted=0", (args.member_id,)
            ).fetchone():
                output_json({"status": "error", "message": f"成员已不存在: {args.member_id}"})
                return
        finally:
            member_check.close()

        record_id = generate_id()
        conn.execute(
            """INSERT INTO diet_records
               (id, member_id, meal_type, meal_date, meal_time, total_calories, total_protein, total_fat, total_carbs, total_fiber, note, created_at, is_deleted)
               VALUES (?, ?, ?, ?, ?, 0, 0, 0, 0, 0, ?, ?, 0)""",
            (record_id, args.member_id, args.meal_type, meal_date, args.meal_time, args.note, now_iso())
        )

        for item in items:
            item_id = generate_id()
            conn.execute(
                """INSERT INTO diet_items
                   (id, record_id, food_name, amount, unit, calories, protein, fat, carbs, fiber, note, created_at, is_deleted)
                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)""",
                (item_id, record_id, item["food_name"],
                 item.get("amount"), item.get("unit"),
                 item.get("calories", 0), item.get("protein", 0), item.get("fat", 0),
                 item.get("carbs", 0), item.get("fiber", 0),
                 item.get("note"), now_iso())
            )

        _compute_totals(conn, record_id)
        conn.commit()

        record = row_to_dict(conn.execute("SELECT * FROM diet_records WHERE id=?", (record_id,)).fetchone())
        item_rows = rows_to_list(conn.execute(
            "SELECT * FROM diet_items WHERE record_id=? AND is_deleted=0", (record_id,)
        ).fetchall())
        record["items"] = item_rows

    meal_name = MEAL_TYPE_NAMES.get(args.meal_type, args.meal_type)
    output_json({
        "status": "ok",
        "message": f"已记录{m['name']}的{meal_date}{meal_name}（{len(items)}个食物，共{record['total_calories']}kcal）",
        "record": record
    })


def add_item(args):
    """向已有餐次追加食物条目。"""
    ensure_db()
    with transaction(domain="lifestyle") as conn:
        record = conn.execute(
            "SELECT * FROM diet_records WHERE id=? AND is_deleted=0", (args.record_id,)
        ).fetchone()
        if not record:
            output_json({"status": "error", "message": f"未找到餐次记录: {args.record_id}"})
            return

        medical_conn = get_medical_connection()
        try:
            if not verify_member_ownership(medical_conn, record["member_id"], args.owner_id):
                output_json({"status": "error", "message": "无权访问该餐次记录"})
                return
        finally:
            medical_conn.close()
        if not args.food_name:
            output_json({"status": "error", "message": "食物名称不能为空"})
            return

        # Auto-fill nutrition from food_lookup if not provided
        if not args.calories:
            _filled = _autofill_item_nutrition({
                'food_name': args.food_name,
                'amount': args.amount,
                'unit': args.unit,
            })
            args.calories = args.calories or _filled.get('calories', 0)
            args.protein = args.protein or _filled.get('protein', 0)
            args.fat = args.fat or _filled.get('fat', 0)
            args.carbs = args.carbs or _filled.get('carbs', 0)
            args.fiber = args.fiber or _filled.get('fiber', 0)
            args.note = args.note or _filled.get('note')

        item_id = generate_id()
        conn.execute(
            """INSERT INTO diet_items
               (id, record_id, food_name, amount, unit, calories, protein, fat, carbs, fiber, note, created_at, is_deleted)
               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)""",
            (item_id, args.record_id, args.food_name,
             args.amount, args.unit,
             args.calories or 0, args.protein or 0, args.fat or 0,
             args.carbs or 0, args.fiber or 0,
             args.note, now_iso())
        )

        _compute_totals(conn, args.record_id)
        conn.commit()

        item = row_to_dict(conn.execute("SELECT * FROM diet_items WHERE id=?", (item_id,)).fetchone())
        output_json({
            "status": "ok",
            "message": f"已向餐次 {args.record_id} 添加食物: {args.food_name}",
            "item": item
        })


def list_meals(args):
    """查看某日/某段时间的饮食记录。"""
    ensure_db()
    medical_conn = get_medical_connection()
    try:
        if not verify_member_ownership(medical_conn, args.member_id, args.owner_id):
            output_json({"status": "error", "message": "无权访问该成员"})
            return
    finally:
        medical_conn.close()
    conn = get_lifestyle_connection()
    try:
        sql = "SELECT * FROM diet_records WHERE member_id=? AND is_deleted=0"
        params = [args.member_id]

        if args.date:
            sql += " AND meal_date=?"
            params.append(args.date)
        else:
            if args.start_date:
                sql += " AND meal_date>=?"
                params.append(args.start_date)
            if args.end_date:
                sql += " AND meal_date<=?"
                params.append(args.end_date)

        if args.meal_type:
            if args.meal_type not in VALID_MEAL_TYPES:
                output_json({"status": "error", "message": f"不支持的餐次类型: {args.meal_type}"})
                return
            sql += " AND meal_type=?"
            params.append(args.meal_type)

        sql += " ORDER BY meal_date DESC, meal_time DESC"
        if args.limit:
            sql += " LIMIT ?"
            params.append(int(args.limit))

        rows = conn.execute(sql, params).fetchall()
        records = rows_to_list(rows)

        # Batch-fetch all diet_items for the returned records in one query
        record_ids = [rec["id"] for rec in records]
        items_by_record = {rid: [] for rid in record_ids}
        if record_ids:
            placeholders = ",".join("?" for _ in record_ids)
            all_items = conn.execute(
                f"SELECT * FROM diet_items WHERE record_id IN ({placeholders}) AND is_deleted=0 ORDER BY created_at",
                record_ids
            ).fetchall()
            for item in rows_to_list(all_items):
                items_by_record[item["record_id"]].append(item)

        for rec in records:
            rec["items"] = items_by_record.get(rec["id"], [])

        output_json({"status": "ok", "count": len(records), "records": records})
    finally:
        conn.close()


def delete_record(args):
    """删除饮食记录或食物条目（软删除）。"""
    ensure_db()
    delete_type = args.type or "record"
    with transaction(domain="lifestyle") as conn:
        if delete_type == "item":
            row = conn.execute(
                """SELECT di.*, dr.member_id
                   FROM diet_items di
                   JOIN diet_records dr ON dr.id=di.record_id
                   WHERE di.id=? AND di.is_deleted=0 AND dr.is_deleted=0""",
                (args.id,)
            ).fetchone()
            if not row:
                output_json({"status": "error", "message": f"未找到食物条目: {args.id}"})
                return

            medical_conn = get_medical_connection()
            try:
                if not verify_member_ownership(medical_conn, row["member_id"], args.owner_id):
                    output_json({"status": "error", "message": "无权访问该食物条目"})
                    return
            finally:
                medical_conn.close()
            conn.execute("UPDATE diet_items SET is_deleted=1 WHERE id=?", (args.id,))
            _compute_totals(conn, row["record_id"])
            conn.commit()
            output_json({"status": "ok", "message": f"食物条目已删除: {row['food_name']}"})
        else:
            row = conn.execute("SELECT * FROM diet_records WHERE id=? AND is_deleted=0", (args.id,)).fetchone()
            if not row:
                output_json({"status": "error", "message": f"未找到餐次记录: {args.id}"})
                return

            medical_conn = get_medical_connection()
            try:
                if not verify_member_ownership(medical_conn, row["member_id"], args.owner_id):
                    output_json({"status": "error", "message": "无权访问该餐次记录"})
                    return
            finally:
                medical_conn.close()
            conn.execute("UPDATE diet_records SET is_deleted=1 WHERE id=?", (args.id,))
            conn.execute("UPDATE diet_items SET is_deleted=1 WHERE record_id=?", (args.id,))
            conn.commit()
            meal_name = MEAL_TYPE_NAMES.get(row["meal_type"], row["meal_type"])
            output_json({"status": "ok", "message": f"已删除{row['meal_date']}{meal_name}记录"})


def daily_summary(args):
    """某日营养摘要（总热量/三大营养素）。"""
    ensure_db()
    conn = get_lifestyle_connection()
    try:
        try:
            date = validate_date(args.date, "日期")
        except ValueError as e:
            output_json({"status": "error", "message": str(e)})
            return

        medical_conn = get_medical_connection()
        try:
            m = get_member_or_error(medical_conn, args.member_id)
            if not m:
                output_json({"status": "error", "message": f"未找到成员: {args.member_id}"})
                return
            if not verify_member_ownership(medical_conn, args.member_id, args.owner_id):
                output_json({"status": "error", "message": "无权访问该成员"})
                return
        finally:
            medical_conn.close()
        records = conn.execute(
            "SELECT * FROM diet_records WHERE member_id=? AND meal_date=? AND is_deleted=0 ORDER BY meal_time",
            (args.member_id, date)
        ).fetchall()
        records = rows_to_list(records)

        # Batch-fetch all diet_items for the day's records in one query
        record_ids = [rec["id"] for rec in records]
        items_by_record = {rid: [] for rid in record_ids}
        if record_ids:
            placeholders = ",".join("?" for _ in record_ids)
            all_items = conn.execute(
                f"SELECT record_id, food_name, calories FROM diet_items WHERE record_id IN ({placeholders}) AND is_deleted=0",
                record_ids
            ).fetchall()
            for item in rows_to_list(all_items):
                items_by_record[item["record_id"]].append(
                    {"food_name": item["food_name"], "calories": item["calories"]}
                )

        totals = {"calories": 0, "protein": 0, "fat": 0, "carbs": 0, "fiber": 0}
        meals = []
        for rec in records:
            totals["calories"] += rec["total_calories"] or 0
            totals["protein"] += rec["total_protein"] or 0
            totals["fat"] += rec["total_fat"] or 0
            totals["carbs"] += rec["total_carbs"] or 0
            totals["fiber"] += rec["total_fiber"] or 0

            meals.append({
                "meal_type": rec["meal_type"],
                "meal_type_name": MEAL_TYPE_NAMES.get(rec["meal_type"], rec["meal_type"]),
                "calories": rec["total_calories"] or 0,
                "items": items_by_record.get(rec["id"], []),
            })

        # Round totals
        for k in ("protein", "fat", "carbs", "fiber"):
            totals[k] = round(totals[k], 1)

        # Macronutrient ratio
        total_macro_g = totals["protein"] + totals["fat"] + totals["carbs"]
        ratio = {}
        if total_macro_g > 0:
            ratio = {
                "protein_pct": round(totals["protein"] / total_macro_g * 100, 1),
                "fat_pct": round(totals["fat"] / total_macro_g * 100, 1),
                "carbs_pct": round(totals["carbs"] / total_macro_g * 100, 1),
            }

        output_json({
            "status": "ok",
            "member_name": m["name"],
            "date": date,
            "meal_count": len(meals),
            "meals": meals,
            "totals": totals,
            "macro_ratio": ratio,
        })
    finally:
        conn.close()


def main():
    parser = argparse.ArgumentParser(description="饮食记录管理")
    sub = parser.add_subparsers(dest="command", required=True)

    # add-meal
    p_add = sub.add_parser("add-meal")
    p_add.add_argument("--member-id", required=True)
    p_add.add_argument("--meal-type", required=True, help=f"餐次: {', '.join(VALID_MEAL_TYPES)}")
    p_add.add_argument("--meal-date", required=True, help="日期 YYYY-MM-DD")
    p_add.add_argument("--meal-time", default=None, help="时间 HH:MM")
    p_add.add_argument("--items", default=None, help="食物条目 JSON 数组")
    p_add.add_argument("--note", default=None)
    p_add.add_argument("--owner-id", default=None)

    # add-item
    p_item = sub.add_parser("add-item")
    p_item.add_argument("--record-id", required=True, help="餐次记录 ID")
    p_item.add_argument("--food-name", required=True, help="食物名称")
    p_item.add_argument("--amount", type=float, default=None, help="数量")
    p_item.add_argument("--unit", default=None, help="单位（g/ml/份/个）")
    p_item.add_argument("--calories", type=float, default=None, help="热量 kcal")
    p_item.add_argument("--protein", type=float, default=None, help="蛋白质 g")
    p_item.add_argument("--fat", type=float, default=None, help="脂肪 g")
    p_item.add_argument("--carbs", type=float, default=None, help="碳水 g")
    p_item.add_argument("--fiber", type=float, default=None, help="膳食纤维 g")
    p_item.add_argument("--note", default=None)
    p_item.add_argument("--owner-id", default=None)

    # list
    p_list = sub.add_parser("list")
    p_list.add_argument("--member-id", required=True)
    p_list.add_argument("--date", default=None, help="指定日期 YYYY-MM-DD")
    p_list.add_argument("--start-date", default=None)
    p_list.add_argument("--end-date", default=None)
    p_list.add_argument("--meal-type", default=None)
    p_list.add_argument("--limit", type=int, default=None, help="最多返回条数")
    p_list.add_argument("--owner-id", default=None)

    # delete
    p_del = sub.add_parser("delete")
    p_del.add_argument("--id", required=True)
    p_del.add_argument("--type", default=None, help="删除类型: record（默认）或 item")
    p_del.add_argument("--owner-id", default=None)

    # daily-summary
    p_sum = sub.add_parser("daily-summary")
    p_sum.add_argument("--member-id", required=True)
    p_sum.add_argument("--date", required=True, help="日期 YYYY-MM-DD")
    p_sum.add_argument("--owner-id", default=None)

    args = parser.parse_args()
    commands = {
        "add-meal": add_meal,
        "add-item": add_item,
        "list": list_meals,
        "delete": delete_record,
        "daily-summary": daily_summary,
    }
    commands[args.command](args)


if __name__ == "__main__":
    main()

"""食物营养查询 - 三层数据源：

优先级：
  1. CFCD6（离线，优先）
     数据来源：《中国食物成分表标准版第6版》（中国疾病预防控制中心营养与健康所）
     JSON 格式整理：https://github.com/Sanotsu/china-food-composition-data
     收录 1657 条中国食材，覆盖谷物、蔬菜、水果、肉蛋奶、水产等全品类

  2. cn-brands（离线，外食场景兜底）
     数据来源：https://github.com/H1an1/health-coach（references/cn-brands.md）
     来源注明：产品包装标注、品牌官方信息、薄荷健康等平台
     收录 339 条，覆盖奶茶、外卖、便利店、火锅、烧烤、早餐等

  3. USDA FoodData Central（在线，国际食材兜底）
     数据来源：美国农业部 https://fdc.nal.usda.gov/
     免费 API，需在环境变量 USDA_API_KEY 配置注册密钥
     注册地址：https://api.data.gov/signup/

用法:
  python food_lookup.py search --query 鸡胸肉
  python food_lookup.py search --query tofu --source usda
  python food_lookup.py search --query 宫保鸡丁 --limit 3
  python food_lookup.py stats
"""
from __future__ import annotations

import argparse
import json
import os
import re
import sys
import unicodedata
import urllib.parse
import urllib.request

# ── 路径 ───────────────────────────────────────────────────────────────────
_SCRIPT_DIR = os.path.dirname(__file__)
_DATA_DIR   = os.path.join(_SCRIPT_DIR, '..', 'data')
_CFCD_PATH  = os.path.join(_DATA_DIR, 'cfcd6.json')
_BRANDS_PATH = os.path.join(
    _SCRIPT_DIR, '..', '..', '..',
    'mediwise-health-suite',   # 兼容独立部署
    'diet-tracker', 'data', 'cn_brands.json',
)
# 同目录下也看一眼
_BRANDS_PATH2 = os.path.join(_DATA_DIR, 'cn_brands.json')

# ── USDA API ────────────────────────────────────────────────────────────────
USDA_SEARCH_URL = 'https://api.nal.usda.gov/fdc/v1/foods/search'
# 支持的 dataType：Foundation 和 SR Legacy 提供每 100g 数据
USDA_DATA_TYPES = 'Foundation,SR%20Legacy,Survey%20(FNDDS)'

# ── 营养素 ID（USDA） ────────────────────────────────────────────────────────
_USDA_NUTRIENT_IDS = {
    1008: 'kcal',
    1003: 'protein',
    1004: 'fat',
    1005: 'carbs',
    1079: 'fiber',
    1253: 'cholesterol',
    1087: 'Ca',
    1089: 'Fe',
    1162: 'vitC',
}

# ── 内部缓存 ────────────────────────────────────────────────────────────────
_cfcd_cache: list[dict] | None = None
_brands_cache: list[dict] | None = None


# ══════════════════════════════════════════════════════════════════════════════
# 数据加载
# ══════════════════════════════════════════════════════════════════════════════

def _load_cfcd() -> list[dict]:
    global _cfcd_cache
    if _cfcd_cache is None:
        if not os.path.exists(_CFCD_PATH):
            _cfcd_cache = []
        else:
            with open(_CFCD_PATH, encoding='utf-8') as f:
                _cfcd_cache = json.load(f)
    return _cfcd_cache


def _load_brands() -> list[dict]:
    """尝试加载 cn_brands.json（由 parse_brands.py 生成）。"""
    global _brands_cache
    if _brands_cache is not None:
        return _brands_cache
    for path in (_BRANDS_PATH2, _BRANDS_PATH):
        if os.path.exists(path):
            with open(path, encoding='utf-8') as f:
                _brands_cache = json.load(f)
            return _brands_cache
    _brands_cache = []
    return _brands_cache


# ══════════════════════════════════════════════════════════════════════════════
# 搜索工具
# ══════════════════════════════════════════════════════════════════════════════

def _normalize(text: str) -> str:
    """转小写、去空格，用于模糊匹配。"""
    return unicodedata.normalize('NFKC', text).lower().replace(' ', '')


def _score(query: str, food: dict) -> int:
    """返回匹配分数（越高越好，0 = 不匹配）。"""
    q  = _normalize(query)
    name = _normalize(food.get('name', ''))
    brand = _normalize(food.get('brand', ''))
    aliases = [_normalize(a) for a in food.get('aliases', [])]
    all_names = [name] + aliases

    # 完全匹配名称
    if q in all_names:
        return 100
    # 名称以查询开头
    if any(n.startswith(q) for n in all_names):
        return 80
    # 名称包含查询
    if any(q in n for n in all_names):
        return 60
    # 查询包含在名称中
    if any(n in q for n in all_names if len(n) >= 2):
        return 40
    # 品牌名匹配（返回该品牌的所有产品）
    if brand and (q in brand or brand in q):
        return 30
    # 中文字符部分重叠匹配（≥2字公共前缀，处理"鸡胸肉"↔"鸡胸脯肉"等变体）
    if len(q) >= 2:
        for n in all_names:
            prefix_len = 0
            for a, b in zip(q, n):
                if a == b:
                    prefix_len += 1
                else:
                    break
            if prefix_len >= 2:
                return 20
    return 0


def _search_local(query: str, foods: list[dict], limit: int = 5) -> list[dict]:
    scored = [(f, _score(query, f)) for f in foods]
    scored = [(f, s) for f, s in scored if s > 0]
    scored.sort(key=lambda x: -x[1])
    return [f for f, _ in scored[:limit]]


# ══════════════════════════════════════════════════════════════════════════════
# CFCD 查询
# ══════════════════════════════════════════════════════════════════════════════

def search_cfcd(query: str, limit: int = 5) -> list[dict]:
    """在《中国食物成分表第6版》中搜索。返回标准化结果列表。"""
    foods = _load_cfcd()
    hits = _search_local(query, foods, limit)
    return [_fmt_cfcd(h) for h in hits]


def _fmt_cfcd(item: dict) -> dict:
    return {
        'name':        item.get('name', ''),
        'name_en':     item.get('name_en'),
        'category':    item.get('category', ''),
        'subcategory': item.get('subcategory', ''),
        'per':         '100g',
        'edible_pct':  item.get('edible_pct'),
        'kcal':        item.get('kcal'),
        'protein':     item.get('protein'),
        'fat':         item.get('fat'),
        'carbs':       item.get('carbs'),
        'fiber':       item.get('fiber'),
        'water':       item.get('water'),
        'cholesterol': item.get('cholesterol'),
        'Ca':          item.get('Ca'),
        'Fe':          item.get('Fe'),
        'vitC':        item.get('vitC'),
        'source':      'cfcd6',
        'source_name': '中国食物成分表第6版（中国疾控中心）',
        'source_url':  'https://github.com/Sanotsu/china-food-composition-data',
    }


# ══════════════════════════════════════════════════════════════════════════════
# cn-brands 查询
# ══════════════════════════════════════════════════════════════════════════════

def search_brands(query: str, limit: int = 5) -> list[dict]:
    """在中国外食/品牌食品库中搜索。"""
    foods = _load_brands()
    hits = _search_local(query, foods, limit)
    return [_fmt_brand(h) for h in hits]


def _fmt_brand(item: dict) -> dict:
    return {
        'name':        item.get('name', ''),
        'brand':       item.get('brand', ''),
        'category':    item.get('category', ''),
        'per':         item.get('per', '份'),
        'serving_desc': item.get('serving_desc', ''),
        'kcal':        item.get('kcal'),
        'protein':     item.get('protein'),
        'fat':         item.get('fat'),
        'carbs':       item.get('carbs'),
        'fiber':       item.get('fiber'),
        'note':        item.get('note', ''),
        'source':      'cn_brands',
        'source_name': '中国品牌/外食数据库（H1an1/health-coach）',
        'source_url':  'https://github.com/H1an1/health-coach',
    }


# ══════════════════════════════════════════════════════════════════════════════
# USDA FoodData Central 查询
# ══════════════════════════════════════════════════════════════════════════════

def _get_usda_key() -> str | None:
    """从环境变量或 config 文件读取 USDA API key。"""
    key = os.environ.get('USDA_API_KEY', '').strip()
    if key:
        return key
    # 尝试读取项目 config
    try:
        sys.path.insert(0, _SCRIPT_DIR)
        import config as _cfg
        return getattr(_cfg, 'USDA_API_KEY', None) or None
    except Exception:
        return None


def search_usda(query: str, limit: int = 5) -> list[dict]:
    """从 USDA FoodData Central 查询。需要 USDA_API_KEY 环境变量。"""
    key = _get_usda_key()
    if not key:
        return [{'error': '未配置 USDA_API_KEY，请在环境变量或 config.py 中设置'}]

    encoded = urllib.parse.quote(query)
    url = (
        f'{USDA_SEARCH_URL}'
        f'?query={encoded}'
        f'&api_key={key}'
        f'&pageSize={limit}'
        f'&dataType={USDA_DATA_TYPES}'
    )
    try:
        req = urllib.request.Request(url, headers={'User-Agent': 'mediwise-health/1.0'})
        with urllib.request.urlopen(req, timeout=8) as resp:
            data = json.loads(resp.read())
    except Exception as e:
        return [{'error': f'USDA API 请求失败: {e}'}]

    results = []
    for food in data.get('foods', [])[:limit]:
        nutrients = {n['nutrientId']: n['value'] for n in food.get('foodNutrients', [])}
        results.append({
            'name':        food.get('description', ''),
            'name_en':     food.get('description', ''),
            'category':    food.get('foodCategory', ''),
            'brand':       food.get('brandOwner', ''),
            'per':         '100g',
            'kcal':        nutrients.get(1008),
            'protein':     nutrients.get(1003),
            'fat':         nutrients.get(1004),
            'carbs':       nutrients.get(1005),
            'fiber':       nutrients.get(1079),
            'cholesterol': nutrients.get(1253),
            'Ca':          nutrients.get(1087),
            'Fe':          nutrients.get(1089),
            'vitC':        nutrients.get(1162),
            'fdc_id':      food.get('fdcId'),
            'data_type':   food.get('dataType'),
            'source':      'usda',
            'source_name': 'USDA FoodData Central（美国农业部）',
            'source_url':  'https://fdc.nal.usda.gov/',
        })
    return results


# ══════════════════════════════════════════════════════════════════════════════
# 统一入口：三层查询
# ══════════════════════════════════════════════════════════════════════════════

def search(
    query: str,
    limit: int = 5,
    source: str = 'auto',
    include_brands: bool = True,
) -> dict:
    """
    统一食物查询接口。

    source:
      'auto'   — 按优先级：CFCD → cn-brands → USDA
      'cfcd'   — 仅查《中国食物成分表》
      'brands' — 仅查外食/品牌库
      'usda'   — 仅查 USDA
      'all'    — 所有来源合并返回
    """
    query = query.strip()
    if not query:
        return {'status': 'error', 'message': '查询词不能为空'}

    if source == 'cfcd':
        return {'status': 'ok', 'query': query, 'results': search_cfcd(query, limit), 'source': 'cfcd'}

    if source == 'brands':
        return {'status': 'ok', 'query': query, 'results': search_brands(query, limit), 'source': 'brands'}

    if source == 'usda':
        return {'status': 'ok', 'query': query, 'results': search_usda(query, limit), 'source': 'usda'}

    if source == 'all':
        cfcd_r   = search_cfcd(query, limit)
        brand_r  = search_brands(query, limit) if include_brands else []
        usda_r   = search_usda(query, limit)
        return {
            'status': 'ok',
            'query': query,
            'cfcd_results': cfcd_r,
            'brand_results': brand_r,
            'usda_results': usda_r,
        }

    # auto 模式：CFCD 优先，未命中再查 brands，再查 USDA
    cfcd_r = search_cfcd(query, limit)
    if cfcd_r:
        return {'status': 'ok', 'query': query, 'results': cfcd_r, 'source': 'cfcd'}

    if include_brands:
        brand_r = search_brands(query, limit)
        if brand_r:
            return {'status': 'ok', 'query': query, 'results': brand_r, 'source': 'cn_brands'}

    usda_r = search_usda(query, limit)
    if usda_r and 'error' not in usda_r[0]:
        return {'status': 'ok', 'query': query, 'results': usda_r, 'source': 'usda'}

    return {
        'status': 'not_found',
        'query': query,
        'message': f'未找到"{query}"的营养数据，建议手动输入或换个关键词',
        'results': [],
    }


def get_by_name(name: str) -> dict | None:
    """精确匹配食物名称，返回单条结果（用于饮食录入自动填充）。"""
    # CFCD 精确匹配
    for food in _load_cfcd():
        if food.get('name') == name:
            return _fmt_cfcd(food)
    # brands 精确匹配
    for food in _load_brands():
        if food.get('name') == name:
            return _fmt_brand(food)
    return None


# ══════════════════════════════════════════════════════════════════════════════
# 数据库概况
# ══════════════════════════════════════════════════════════════════════════════

def db_stats() -> dict:
    cfcd = _load_cfcd()
    brands = _load_brands()
    categories: dict[str, int] = {}
    for f in cfcd:
        cat = f.get('category', '其他')
        categories[cat] = categories.get(cat, 0) + 1
    return {
        'cfcd_total': len(cfcd),
        'cfcd_with_kcal': sum(1 for f in cfcd if f.get('kcal') is not None),
        'cfcd_source': '《中国食物成分表标准版第6版》中国疾病预防控制中心营养与健康所',
        'cfcd_json_repo': 'https://github.com/Sanotsu/china-food-composition-data',
        'brands_total': len(brands),
        'brands_source': '中国品牌/外食数据（产品包装、品牌官方信息、薄荷健康等）',
        'brands_repo': 'https://github.com/H1an1/health-coach',
        'usda_source': 'USDA FoodData Central https://fdc.nal.usda.gov/',
        'usda_available': bool(_get_usda_key()),
        'cfcd_categories': categories,
    }


# ══════════════════════════════════════════════════════════════════════════════
# CLI
# ══════════════════════════════════════════════════════════════════════════════

def _output(data: dict) -> None:
    # 尝试导入项目通用输出函数，否则直接 print
    try:
        sys.path.insert(0, _SCRIPT_DIR)
        from health_db import output_json
        output_json(data)
    except Exception:
        print(json.dumps(data, ensure_ascii=False, indent=2))


def main():
    parser = argparse.ArgumentParser(description='食物营养查询')
    sub = parser.add_subparsers(dest='command', required=True)

    p = sub.add_parser('search', help='搜索食物')
    p.add_argument('--query', '-q', required=True, help='食物名称（中文或英文）')
    p.add_argument('--limit', type=int, default=5)
    p.add_argument('--source', default='auto',
                   choices=['auto', 'cfcd', 'brands', 'usda', 'all'],
                   help='数据来源（默认 auto 按优先级查询）')
    p.add_argument('--no-brands', action='store_true', help='跳过品牌/外食数据库')
    p.add_argument('--owner-id', default=None)  # accepted but unused (multi-tenant injection)

    stats_p = sub.add_parser('stats', help='查看数据库概况')
    stats_p.add_argument('--owner-id', default=None)

    args = parser.parse_args()

    if args.command == 'search':
        result = search(
            args.query,
            limit=args.limit,
            source=args.source,
            include_brands=not args.no_brands,
        )
        _output(result)

    elif args.command == 'stats':
        _output(db_stats())


if __name__ == '__main__':
    main()

"""营养分析、热量趋势。"""

from __future__ import annotations

import argparse
import sys
import os
from datetime import datetime, timedelta

# Unified path setup
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'shared'))
from path_setup import setup_mediwise_path
setup_mediwise_path()

from health_db import ensure_db, get_medical_connection, get_lifestyle_connection, rows_to_list, output_json, verify_member_ownership
from metric_utils import get_member_or_error


def _get_member(member_id, owner_id=None):
    medical_conn = get_medical_connection()
    try:
        m = get_member_or_error(medical_conn, member_id)
        if not m:
            return None
        if not verify_member_ownership(medical_conn, member_id, owner_id):
            return None
        return m
    finally:
        medical_conn.close()
def weekly_summary(args):
    """一周营养趋势（每日热量、平均三大营养素）。"""
    ensure_db()
    m = _get_member(args.member_id, args.owner_id)
    if not m:
        output_json({"status": "error", "message": f"未找到成员或无权访问: {args.member_id}"})
        return

    if args.end_date:
        end = datetime.strptime(args.end_date, "%Y-%m-%d").date()
    else:
        end = datetime.now().date()
    start = end - timedelta(days=6)

    lifestyle_conn = get_lifestyle_connection()
    try:
        rows = lifestyle_conn.execute(
            """SELECT meal_date,
                      SUM(total_calories) as calories,
                      SUM(total_protein) as protein,
                      SUM(total_fat) as fat,
                      SUM(total_carbs) as carbs,
                      SUM(total_fiber) as fiber
               FROM diet_records
               WHERE member_id=? AND meal_date>=? AND meal_date<=? AND is_deleted=0
               GROUP BY meal_date
               ORDER BY meal_date""",
            (args.member_id, start.isoformat(), end.isoformat())
        ).fetchall()
    finally:
        lifestyle_conn.close()
    daily = rows_to_list(rows)

    # Compute weekly averages
    days_with_data = len(daily)
    if days_with_data > 0:
        avg = {
            "calories": round(sum(d["calories"] or 0 for d in daily) / days_with_data, 1),
            "protein": round(sum(d["protein"] or 0 for d in daily) / days_with_data, 1),
            "fat": round(sum(d["fat"] or 0 for d in daily) / days_with_data, 1),
            "carbs": round(sum(d["carbs"] or 0 for d in daily) / days_with_data, 1),
            "fiber": round(sum(d["fiber"] or 0 for d in daily) / days_with_data, 1),
        }
    else:
        avg = {"calories": 0, "protein": 0, "fat": 0, "carbs": 0, "fiber": 0}

    output_json({
        "status": "ok",
        "member_name": m["name"],
        "period": {"start": start.isoformat(), "end": end.isoformat()},
        "days_with_data": days_with_data,
        "daily": daily,
        "average": avg,
    })


def calorie_trend(args):
    """热量趋势分析（N 天每日总热量）。"""
    ensure_db()
    m = _get_member(args.member_id, args.owner_id)
    if not m:
        output_json({"status": "error", "message": f"未找到成员或无权访问: {args.member_id}"})
        return

    days = args.days or 7
    end = datetime.now().date()
    start = end - timedelta(days=days - 1)

    lifestyle_conn = get_lifestyle_connection()
    try:
        rows = lifestyle_conn.execute(
            """SELECT meal_date, SUM(total_calories) as calories
               FROM diet_records
               WHERE member_id=? AND meal_date>=? AND meal_date<=? AND is_deleted=0
               GROUP BY meal_date
               ORDER BY meal_date""",
            (args.member_id, start.isoformat(), end.isoformat())
        ).fetchall()
    finally:
        lifestyle_conn.close()
    daily = rows_to_list(rows)

    # Fill in missing days with 0
    date_map = {d["meal_date"]: d["calories"] or 0 for d in daily}
    trend = []
    current = start
    while current <= end:
        ds = current.isoformat()
        trend.append({"date": ds, "calories": date_map.get(ds, 0)})
        current += timedelta(days=1)

    total = sum(d["calories"] for d in trend)
    avg = round(total / days, 1) if days > 0 else 0

    output_json({
        "status": "ok",
        "member_name": m["name"],
        "days": days,
        "period": {"start": start.isoformat(), "end": end.isoformat()},
        "trend": trend,
        "total_calories": total,
        "average_daily": avg,
    })


def nutrition_balance(args):
    """三大营养素比例分析。"""
    ensure_db()
    m = _get_member(args.member_id, args.owner_id)
    if not m:
        output_json({"status": "error", "message": f"未找到成员或无权访问: {args.member_id}"})
        return

    days = args.days or 7
    end = datetime.now().date()
    start = end - timedelta(days=days - 1)

    lifestyle_conn = get_lifestyle_connection()
    try:
        row = lifestyle_conn.execute(
            """SELECT SUM(total_calories) as calories,
                      SUM(total_protein) as protein,
                      SUM(total_fat) as fat,
                      SUM(total_carbs) as carbs,
                      SUM(total_fiber) as fiber
               FROM diet_records
               WHERE member_id=? AND meal_date>=? AND meal_date<=? AND is_deleted=0""",
            (args.member_id, start.isoformat(), end.isoformat())
        ).fetchone()
    finally:
        lifestyle_conn.close()
    protein = (row["protein"] or 0) if row else 0
    fat = (row["fat"] or 0) if row else 0
    carbs = (row["carbs"] or 0) if row else 0
    fiber = (row["fiber"] or 0) if row else 0
    calories = (row["calories"] or 0) if row else 0

    total_macro_g = protein + fat + carbs
    ratio = {}
    if total_macro_g > 0:
        ratio = {
            "protein_pct": round(protein / total_macro_g * 100, 1),
            "fat_pct": round(fat / total_macro_g * 100, 1),
            "carbs_pct": round(carbs / total_macro_g * 100, 1),
        }

    # Reference: Chinese Dietary Guidelines recommendation
    # Protein 10-15%, Fat 20-30%, Carbs 50-65%
    assessment = []
    if ratio:
        if ratio["protein_pct"] < 10:
            assessment.append("蛋白质摄入偏低，建议增加鱼肉蛋奶豆类")
        elif ratio["protein_pct"] > 20:
            assessment.append("蛋白质比例偏高")
        if ratio["fat_pct"] > 35:
            assessment.append("脂肪摄入偏高，建议减少油炸食物")
        elif ratio["fat_pct"] < 15:
            assessment.append("脂肪摄入偏低")
        if ratio["carbs_pct"] > 70:
            assessment.append("碳水摄入偏高，建议增加蔬菜蛋白质比例")
        elif ratio["carbs_pct"] < 40:
            assessment.append("碳水摄入偏低")

    output_json({
        "status": "ok",
        "member_name": m["name"],
        "days": days,
        "period": {"start": start.isoformat(), "end": end.isoformat()},
        "totals": {
            "calories": round(calories, 1),
            "protein": round(protein, 1),
            "fat": round(fat, 1),
            "carbs": round(carbs, 1),
            "fiber": round(fiber, 1),
        },
        "daily_average": {
            "calories": round(calories / days, 1) if days > 0 else 0,
            "protein": round(protein / days, 1) if days > 0 else 0,
            "fat": round(fat / days, 1) if days > 0 else 0,
            "carbs": round(carbs / days, 1) if days > 0 else 0,
            "fiber": round(fiber / days, 1) if days > 0 else 0,
        },
        "macro_ratio": ratio,
        "assessment": assessment,
    })


def main():
    parser = argparse.ArgumentParser(description="营养分析")
    sub = parser.add_subparsers(dest="command", required=True)

    p_ws = sub.add_parser("weekly-summary")
    p_ws.add_argument("--member-id", required=True)
    p_ws.add_argument("--end-date", default=None, help="统计截止日期 YYYY-MM-DD，默认今天")
    p_ws.add_argument("--owner-id", default=None)

    p_ct = sub.add_parser("calorie-trend")
    p_ct.add_argument("--member-id", required=True)
    p_ct.add_argument("--days", type=int, default=7, help="统计天数，默认 7")
    p_ct.add_argument("--owner-id", default=None)

    p_nb = sub.add_parser("nutrition-balance")
    p_nb.add_argument("--member-id", required=True)
    p_nb.add_argument("--days", type=int, default=7, help="统计天数，默认 7")
    p_nb.add_argument("--owner-id", default=None)

    args = parser.parse_args()
    commands = {
        "weekly-summary": weekly_summary,
        "calorie-trend": calorie_trend,
        "nutrition-balance": nutrition_balance,
    }
    commands[args.command](args)


if __name__ == "__main__":
    main()