VibeCoding5

✅Week 5 Progress: Ch 06 ~ 07

🚶Basic Mission (Required)
PROJECT 9. Create and capture the "Please Take Care of My Refrigerator" app

⠀
🏃Additional Mission (Optional)
Building an AI Agent Team
Use AI design agents to improve the UX design of the "Please Take Care of My Refrigerator" app and capture it

📋 작업 요약
프로젝트명: Smart Recipe - AI 냉장고 레시피 추천

주요 기능 (3단계로 구성):

Step 1: 냉장고/식재료 이미지 업로드 → AI가 재료 자동 인식 (Gemma 3 모델)
Step 2: 인식된 재료 기반 → AI 맞춤 레시피 생성 (DeepSeek 모델)
Step 3: 사용자 인증(회원가입/로그인) + 레시피 저장 및 관리
기술 스택:

Backend: Flask (Python)
Database: SQLite
Frontend: Vanilla HTML/CSS/JavaScript
AI API: OpenRouter (Gemma 3, DeepSeek 무료 모델)

생성된 README.md 내용
프로젝트 개요 및 배지
주요 기능 테이블
프로젝트 구조 트리
기술 스택 상세
설치 및 실행 가이드
API 엔드포인트 문서
테스트 실행 방법
사용 흐름 (Mermaid 다이어그램)
데이터베이스 스키마
기여 가이드
Git 커밋 및 푸시

👉 GitHub에서 확인: https://github.com/sechan9999/recipe
https://sechan9999.github.io/recipe/
https://github.com/sechan9999/AIdiaryPdfSummarizer
https://sechan9999.github.io/AIdiaryPdfSummarizer/

⠀

본 강의는 『혼자 공부하는 바이브 코딩 with 클로드 코드』의 내용을 바탕으로 제작하였습니다.

👨‍🏫주요 강의 내용
Ch 06. 클로드 코드에 API 날개 달기
06-1 틀로드 코드에서 API 설정하기

• API의 개념과 활용 방법
• AI 모델 선택하기
• AI 모델 연결하고 테스트하기

06-2 클로드 코드와 API로 만드는 '냉장고를 부탁해'

• 애플리케이션 구현을 위한 PRD 작성하기
• 1단계: 냉장고 이미지에서 재료 인식하기
• 2단계: 레시피 생성하기
• 3단계: 사용자의 프로필에 레시피 저장하기

👨‍🏫주요 강의 내용
Ch 07. 클로드 코드 AI 에이전트로 개발팀 구성하기
07-1 클로드 코드의 AI 에이전트 이해하기

• 코드 리뷰어 에이전트
• 최적화 에이전트 & UX 디자인 에이전트
• 서브에이전트 협업 테스트하기

07-2 AI 에이전트로 소프트웨어 개발 자동화하기

• 나만의 AI 개발팀 구축하기
• ‘AI 공감 다이어리’ 앱 만들기
• ‘PDF 요약 AI’ 앱 만들기

🔗실습 예제: https://github.com/taehojo/vibecoding
🔗저자님께 질문하기: https://github.com/taehojo/vibecoding/issues
🔗혼자 공부하는 바이브 코딩 with 클로드 코드: https://www.hanbit.co.kr/store/books/look.php?p_code=B1785590517&type=book&utm_source=inflearn&utm_medium=affiliate&utm_campaign=50004

공감 다이어리 앱
AI 공감 다이어리를 만들어 줘. 오늘 있었던 일을 한 줄로 쓰면, AI가 감정을 분석하고 공감하며 위로해 주는 일기 애플리케이션이야.
backend-architect가 OpenRouter API를 연동해서 감정 분석과 공감 메시지를 생성하는 기능을 구현해 줘.
DeepSeek V3.1 무료 모델을 사용하고, API 키는 현재 폴더의 ‘.env’ 파일에 저장된 것을 사용해.
frontend-developer가 따뜻하고 편안한 느낌의 일기장 UI를 만든 다음, qa-engineer가 실제로 여러 상황에서 문제없이 작동하는지 테스트해 줘.
문제를 발견하면 완전히 해결할 때까지 수정하고, 최종 버전을 브라우저에서 바로 열 수 있는 ‘index.html’ 파일로 만들어 줘.

PDF 문서를 업로드하면 AI가 요약해주는 웹 애플리케이션을 만들 거야.
먼저 product-manager-prd가 PDF 문서 요약 앱의 상세 PRD와 기능 명세를 작성하고,
backend-architect가 PDF 파일 업로드, 텍스트 추출 기능을 구현해.
ai-integration-specialist가 OpenRouter API를 연동해서 추출된 텍스트를 요약하는 기능을 구현해 줘.
DeepSeek V3.1 무료 모델을 사용하고, API 키는 현재 폴더의 ‘.env’ 파일에 저장된 것을 사용해.
frontend-developer가 드래그&드롭 파일 업로드 UI와 요약 결과를 깔끔하게 표시하는 한글 인터페이스를 구현한 다음,
qa-engineer가 실제로 여러 상황에서 문제없이 작동하는지 테스트해 줘. 문제를 발견하면 완전히 해결할 때까지 수정하고, 최종 버전을 브라우저에서 바로 열 수 있는 ‘index_pdf.html’ 파일로 만들어 줘.

"""
냉장고 재료 인식 웹 애플리케이션 - Step 1, 2 & 3
Flask 백엔드 서버
"""

import os
import json
import re
import sqlite3
import secrets
import logging
from datetime import datetime
import urllib.request
import urllib.error
from functools import wraps
from flask import Flask, render_template, request, jsonify, session, g
from dotenv import load_dotenv
import bcrypt

load_dotenv()

# 로깅 설정
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

app = Flask(__name__)

# 보안 설정
MAX_CONTENT_SIZE = 10 * 1024 * 1024  # 10MB
app.config['MAX_CONTENT_LENGTH'] = MAX_CONTENT_SIZE
app.config['SECRET_KEY'] = os.getenv('SECRET_KEY', secrets.token_hex(32))

# 세션 쿠키 보안 설정
app.config['SESSION_COOKIE_HTTPONLY'] = True
app.config['SESSION_COOKIE_SAMESITE'] = 'Lax'
# HTTPS 환경에서만 활성화 (개발 시 False)
app.config['SESSION_COOKIE_SECURE'] = os.getenv('FLASK_ENV') == 'production'

OPENROUTER_API_KEY = os.getenv('OPENROUTER_API_KEY')

# 환경변수 검증
if not OPENROUTER_API_KEY:
    logging.warning("OPENROUTER_API_KEY is not set. API calls will fail.")
BASE_URL = "https://openrouter.ai/api/v1"
DATABASE = 'smart_recipe.db'

# 이미지 인식 모델 (비전 지원 무료 모델 - 우선순위)
IMAGE_MODELS = [
    "qwen/qwen2.5-vl-72b-instruct:free",
    "qwen/qwen2.5-vl-32b-instruct:free",
    "meta-llama/llama-4-scout:free",
    "moonshotai/kimi-vl-a3b-thinking:free",
    "google/gemma-3-27b-it:free",
]

# 텍스트 생성 모델 (레시피용)
TEXT_MODELS = [
    "qwen/qwen3-235b-a22b:free",
    "google/gemma-3-27b-it:free",
    "deepseek/deepseek-r1-0528:free",
    "meta-llama/llama-4-maverick:free",
]


# ===== 데이터베이스 =====

def get_db():
    """데이터베이스 연결"""
    if 'db' not in g:
        g.db = sqlite3.connect(DATABASE)
        g.db.row_factory = sqlite3.Row
    return g.db


@app.teardown_appcontext
def close_db(exception):
    """요청 종료 시 DB 연결 해제"""
    db = g.pop('db', None)
    if db is not None:
        db.close()


def init_db():
    """데이터베이스 초기화"""
    db = sqlite3.connect(DATABASE)
    db.executescript('''
        CREATE TABLE IF NOT EXISTS users (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            email TEXT UNIQUE NOT NULL,
            password_hash TEXT NOT NULL,
            nickname TEXT,
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        );

        CREATE TABLE IF NOT EXISTS user_preferences (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            user_id INTEGER UNIQUE REFERENCES users(id) ON DELETE CASCADE,
            allergies TEXT DEFAULT '[]',
            dietary_restrictions TEXT DEFAULT '[]',
            preferred_cuisines TEXT DEFAULT '[]',
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        );

        CREATE TABLE IF NOT EXISTS saved_recipes (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
            recipe_name TEXT NOT NULL,
            recipe_data TEXT NOT NULL,
            ingredients TEXT DEFAULT '[]',
            cuisine_type TEXT,
            difficulty TEXT,
            cook_time TEXT,
            rating INTEGER CHECK (rating >= 1 AND rating <= 5),
            notes TEXT,
            tags TEXT DEFAULT '[]',
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        );

        CREATE TABLE IF NOT EXISTS analysis_history (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
            detected_ingredients TEXT DEFAULT '[]',
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        );

        -- 성능 최적화 인덱스
        CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);
        CREATE INDEX IF NOT EXISTS idx_saved_recipes_user_id ON saved_recipes(user_id);
        CREATE INDEX IF NOT EXISTS idx_saved_recipes_created_at ON saved_recipes(created_at DESC);
        CREATE INDEX IF NOT EXISTS idx_analysis_history_user_id ON analysis_history(user_id);
    ''')
    db.commit()
    db.close()


# 앱 시작 시 DB 초기화
with app.app_context():
    init_db()


def hash_password(password):
    """비밀번호 해시화 (bcrypt 사용)"""
    return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')


def verify_password(password, hashed):
    """비밀번호 검증 (SHA256 → bcrypt 마이그레이션 지원)"""
    # bcrypt 해시는 $2로 시작 (예: $2b$12$...)
    if hashed.startswith('$2'):
        return bcrypt.checkpw(password.encode('utf-8'), hashed.encode('utf-8'))
    else:
        # 기존 SHA256 해시 호환 (64자 hex)
        import hashlib
        return hashed == hashlib.sha256(password.encode()).hexdigest()


def upgrade_password_hash(user_id, password):
    """SHA256 해시를 bcrypt로 업그레이드"""
    db = get_db()
    new_hash = hash_password(password)
    db.execute('UPDATE users SET password_hash = ? WHERE id = ?', (new_hash, user_id))
    db.commit()


def login_required(f):
    """로그인 필수 데코레이터"""
    @wraps(f)
    def decorated_function(*args, **kwargs):
        if 'user_id' not in session:
            return jsonify({"success": False, "error": "로그인이 필요합니다"}), 401
        return f(*args, **kwargs)
    return decorated_function


def get_current_user():
    """현재 로그인한 사용자 조회"""
    if 'user_id' not in session:
        return None
    db = get_db()
    user = db.execute('SELECT * FROM users WHERE id = ?', (session['user_id'],)).fetchone()
    return dict(user) if user else None


# ===== OpenRouter API =====

def call_openrouter(model, messages, timeout=60):
    """OpenRouter API 호출"""
    url = f"{BASE_URL}/chat/completions"
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
        "HTTP-Referer": "http://localhost:5000",
        "X-Title": "Smart Recipe"
    }
    data = json.dumps({
        "model": model,
        "messages": messages
    }).encode('utf-8')

    logging.info(f"[API] 모델 호출: {model}")
    req = urllib.request.Request(url, data=data, headers=headers)
    try:
        with urllib.request.urlopen(req, timeout=timeout) as response:
            result = json.loads(response.read().decode('utf-8'))
            logging.info(f"[API] 성공: {model}")
            return result
    except urllib.error.HTTPError as e:
        error_body = e.read().decode('utf-8')
        logging.error(f"[API] HTTP {e.code} 에러 ({model}): {error_body[:500]}")
        try:
            return {"error": json.loads(error_body)}
        except:
            return {"error": {"message": f"HTTP {e.code}: {error_body[:200]}"}}
    except urllib.error.URLError as e:
        logging.error(f"[API] URL 에러 ({model}): {e.reason}")
        return {"error": {"message": f"연결 실패: {e.reason}"}}
    except Exception as e:
        logging.error(f"[API] 예외 ({model}): {str(e)}")
        return {"error": {"message": str(e)}}


# ===== Step 1: 이미지 분석 =====

def extract_ingredients(text):
    """텍스트에서 재료 배열 추출"""
    json_match = re.search(r'\[.*?\]', text, re.DOTALL)
    if json_match:
        try:
            ingredients = json.loads(json_match.group())
            if isinstance(ingredients, list):
                return [str(i).strip() for i in ingredients if i]
        except json.JSONDecodeError:
            pass

    lines = re.split(r'[,\n]', text)
    ingredients = []
    for line in lines:
        cleaned = re.sub(r'^[\d\.\-\*\•]+\s*', '', line.strip())
        cleaned = re.sub(r'["\'\[\]]', '', cleaned)
        if cleaned and len(cleaned) > 1 and len(cleaned) < 50:
            ingredients.append(cleaned)

    return ingredients[:30]


def analyze_image(base64_image, mime_type="image/jpeg"):
    """이미지 분석하여 재료 추출"""
    prompt = """이 냉장고/식재료 사진에서 보이는 모든 식재료를 분석해주세요.

다음 JSON 형식으로만 응답해주세요:
["재료1", "재료2", "재료3"]

예시: ["계란", "우유", "당근", "양파", "돼지고기"]

주의사항:
- 보이는 식재료만 나열
- 한글로 작성
- JSON 배열 형식만 출력"""

    messages = [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": prompt},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:{mime_type};base64,{base64_image}"
                    }
                }
            ]
        }
    ]

    last_error = "알 수 없는 오류"
    for model in IMAGE_MODELS:
        result = call_openrouter(model, messages, timeout=65)
        if "error" not in result:
            try:
                content = result['choices'][0]['message']['content']
                ingredients = extract_ingredients(content)
                if ingredients:
                    return {
                        "success": True,
                        "ingredients": ingredients,
                        "model": model,
                        "raw_response": content
                    }
                else:
                    logging.warning(f"[분석] {model}: 재료 추출 실패 - 응답: {content[:200]}")
                    last_error = "이미지에서 재료를 찾지 못했습니다"
                    continue
            except (KeyError, IndexError) as e:
                logging.error(f"[분석] {model}: 응답 파싱 실패 - {e}, 응답: {str(result)[:300]}")
                last_error = "API 응답 형식 오류"
                continue

        # 에러 메시지 추출 (다양한 에러 구조 대응)
        err = result.get('error', {})
        if isinstance(err, dict):
            err_msg = err.get('message', '') or err.get('error', {}).get('message', '')
            err_code = err.get('code', '') or err.get('error', {}).get('code', '')
        else:
            err_msg = str(err)
            err_code = ''

        last_error = err_msg or "API 호출 실패"
        logging.warning(f"[분석] {model} 실패: code={err_code}, msg={err_msg[:200]}")

        # 429(Rate Limit)는 다음 모델 시도, 그 외 치명적 에러도 다음 모델 시도
        continue

    logging.error(f"[분석] 모든 모델 실패. 마지막 에러: {last_error}")
    return {
        "success": False,
        "error": last_error,
        "ingredients": []
    }


# ===== Step 2: 레시피 생성 =====

def extract_recipe_json(text):
    """텍스트에서 레시피 JSON 추출"""
    json_match = re.search(r'\{[\s\S]*\}', text)
    if json_match:
        try:
            recipe = json.loads(json_match.group())
            return recipe
        except json.JSONDecodeError:
            pass
    return parse_recipe_text(text)


def parse_recipe_text(text):
    """텍스트를 레시피 구조로 파싱"""
    recipe = {
        "name": "추천 레시피",
        "description": "",
        "difficulty": "중급",
        "cookTime": "30분",
        "servings": 2,
        "ingredients": [],
        "steps": [],
        "tips": ""
    }

    lines = text.split('\n')
    current_section = None

    for line in lines:
        line = line.strip()
        if not line:
            continue

        if '요리' in line and ('이름' in line or '명' in line):
            current_section = 'name'
        elif '재료' in line:
            current_section = 'ingredients'
        elif '순서' in line or '단계' in line or '방법' in line or '과정' in line:
            current_section = 'steps'
        elif '팁' in line or '참고' in line:
            current_section = 'tips'
        elif '설명' in line:
            current_section = 'description'
        elif current_section == 'name' and ':' in line:
            recipe['name'] = line.split(':', 1)[1].strip()
        elif current_section == 'ingredients':
            cleaned = re.sub(r'^[\d\.\-\*\•]+\s*', '', line)
            if cleaned and len(cleaned) > 1:
                recipe['ingredients'].append({
                    "name": cleaned,
                    "amount": "",
                    "available": True
                })
        elif current_section == 'steps':
            cleaned = re.sub(r'^[\d\.\-\*\•]+\s*', '', line)
            if cleaned and len(cleaned) > 5:
                recipe['steps'].append(cleaned)
        elif current_section == 'tips':
            recipe['tips'] += line + " "

    if recipe['name'] == "추천 레시피" and lines:
        first_meaningful = next((l for l in lines if len(l.strip()) > 2), None)
        if first_meaningful:
            recipe['name'] = first_meaningful.strip()[:50]

    return recipe


def generate_recipe(ingredients, cuisine, difficulty, cook_time, servings):
    """AI로 레시피 생성"""
    prompt = f"""당신은 전문 요리사입니다. 주어진 재료로 맛있는 요리 레시피를 추천해주세요.

사용 가능한 재료: {', '.join(ingredients)}
요리 종류: {cuisine}
난이도: {difficulty}
조리 시간: {cook_time}
인원: {servings}인분

반드시 다음 JSON 형식으로만 응답해주세요:
{{
  "name": "요리 이름",
  "description": "요리에 대한 간단한 설명 (1-2문장)",
  "difficulty": "{difficulty}",
  "cookTime": "{cook_time}",
  "servings": {servings},
  "ingredients": [
    {{"name": "재료명", "amount": "분량", "available": true}},
    {{"name": "추가 필요한 재료", "amount": "분량", "available": false}}
  ],
  "steps": [
    "1. 첫 번째 조리 단계",
    "2. 두 번째 조리 단계",
    "3. 세 번째 조리 단계"
  ],
  "tips": "조리 팁이나 주의사항"
}}

주의사항:
- 주어진 재료를 최대한 활용하세요
- 추가로 필요한 기본 재료(소금, 설탕, 식용유 등)는 available: false로 표시
- 단계는 구체적이고 따라하기 쉽게 작성
- 반드시 유효한 JSON 형식으로 응답"""

    messages = [
        {"role": "user", "content": prompt}
    ]

    last_error = None
    for model in TEXT_MODELS:
        result = call_openrouter(model, messages, timeout=90)
        if "error" not in result:
            content = result['choices'][0]['message']['content']
            recipe = extract_recipe_json(content)
            return {
                "success": True,
                "recipe": recipe,
                "model": model,
                "raw_response": content
            }
        last_error = result.get('error', {})
        error_code = last_error.get('code')
        if error_code and error_code != 429:
            break

    return {
        "success": False,
        "error": last_error.get('message', '알 수 없는 오류') if last_error else '알 수 없는 오류',
        "recipe": None
    }


# ===== 라우트: 페이지 =====

@app.route('/')
def index():
    """메인 페이지"""
    return render_template('index.html')


# ===== 라우트: Step 1 & 2 API =====

@app.route('/api/analyze', methods=['POST'])
def analyze():
    """이미지 분석 API"""
    try:
        data = request.get_json()
        if not data or 'image' not in data:
            return jsonify({"success": False, "error": "이미지가 필요합니다"}), 400

        image_data = data['image']
        if ',' in image_data:
            header, base64_image = image_data.split(',', 1)
            mime_match = re.search(r'data:([^;]+)', header)
            mime_type = mime_match.group(1) if mime_match else 'image/jpeg'
        else:
            base64_image = image_data
            mime_type = 'image/jpeg'

        # 이미지 크기 검증 (base64 → 실제 크기 약 3/4)
        img_size_mb = len(base64_image) * 3 / 4 / (1024 * 1024)
        logging.info(f"[분석] 이미지 크기: {img_size_mb:.1f}MB, MIME: {mime_type}")

        if img_size_mb > 8:
            return jsonify({"success": False, "error": "이미지가 너무 큽니다 (최대 8MB)"}), 400

        result = analyze_image(base64_image, mime_type)

        # 로그인한 사용자면 히스토리 저장 (에러 발생 시 롤백)
        if 'user_id' in session and result.get('success'):
            db = get_db()
            try:
                db.execute(
                    'INSERT INTO analysis_history (user_id, detected_ingredients) VALUES (?, ?)',
                    (session['user_id'], json.dumps(result['ingredients']))
                )
                db.commit()
            except Exception as e:
                db.rollback()
                logging.error(f"Failed to save analysis history: {e}")

        return jsonify(result)

    except Exception as e:
        logging.error(f"[분석] 예기치 않은 에러: {str(e)}", exc_info=True)
        return jsonify({"success": False, "error": f"서버 오류: {str(e)}"}), 500


@app.route('/api/recipe', methods=['POST'])
def recipe():
    """레시피 생성 API"""
    data = request.get_json()
    if not data or 'ingredients' not in data:
        return jsonify({"success": False, "error": "재료 목록이 필요합니다"}), 400

    ingredients = data.get('ingredients', [])
    cuisine = data.get('cuisine', '상관없음')
    difficulty = data.get('difficulty', '중급')
    cook_time = data.get('cookTime', '30분 이내')
    servings = data.get('servings', 2)

    if not ingredients:
        return jsonify({"success": False, "error": "최소 1개 이상의 재료가 필요합니다"}), 400

    result = generate_recipe(ingredients, cuisine, difficulty, cook_time, servings)
    return jsonify(result)


# ===== Step 3: 인증 API =====

@app.route('/api/auth/register', methods=['POST'])
def register():
    """회원가입"""
    data = request.get_json()
    email = data.get('email', '').strip()
    password = data.get('password', '')
    nickname = data.get('nickname', '').strip()

    if not email or not password:
        return jsonify({"success": False, "error": "이메일과 비밀번호를 입력해주세요"}), 400

    if len(password) < 6:
        return jsonify({"success": False, "error": "비밀번호는 6자 이상이어야 합니다"}), 400

    db = get_db()
    existing = db.execute('SELECT id FROM users WHERE email = ?', (email,)).fetchone()
    if existing:
        return jsonify({"success": False, "error": "이미 등록된 이메일입니다"}), 400

    password_hash = hash_password(password)
    cursor = db.execute(
        'INSERT INTO users (email, password_hash, nickname) VALUES (?, ?, ?)',
        (email, password_hash, nickname or email.split('@')[0])
    )
    db.commit()

    user_id = cursor.lastrowid
    db.execute('INSERT INTO user_preferences (user_id) VALUES (?)', (user_id,))
    db.commit()

    session['user_id'] = user_id
    return jsonify({
        "success": True,
        "user": {"id": user_id, "email": email, "nickname": nickname or email.split('@')[0]}
    })


@app.route('/api/auth/login', methods=['POST'])
def login():
    """로그인"""
    data = request.get_json()
    email = data.get('email', '').strip()
    password = data.get('password', '')

    if not email or not password:
        return jsonify({"success": False, "error": "이메일과 비밀번호를 입력해주세요"}), 400

    db = get_db()
    user = db.execute('SELECT * FROM users WHERE email = ?', (email,)).fetchone()

    if not user or not verify_password(password, user['password_hash']):
        logging.warning(f"Failed login attempt for {email}")
        return jsonify({"success": False, "error": "이메일 또는 비밀번호가 올바르지 않습니다"}), 401

    # SHA256 → bcrypt 자동 업그레이드
    if not user['password_hash'].startswith('$2'):
        upgrade_password_hash(user['id'], password)
        logging.info(f"Password hash upgraded to bcrypt for user {user['id']}")

    session['user_id'] = user['id']
    return jsonify({
        "success": True,
        "user": {"id": user['id'], "email": user['email'], "nickname": user['nickname']}
    })


@app.route('/api/auth/logout', methods=['POST'])
def logout():
    """로그아웃"""
    session.pop('user_id', None)
    return jsonify({"success": True})


@app.route('/api/auth/me', methods=['GET'])
def get_me():
    """현재 사용자 정보"""
    user = get_current_user()
    if not user:
        return jsonify({"success": False, "user": None})

    return jsonify({
        "success": True,
        "user": {
            "id": user['id'],
            "email": user['email'],
            "nickname": user['nickname']
        }
    })


# ===== Step 3: 프로필 API =====

@app.route('/api/profile', methods=['GET'])
@login_required
def get_profile():
    """프로필 조회"""
    user = get_current_user()
    db = get_db()
    prefs = db.execute(
        'SELECT * FROM user_preferences WHERE user_id = ?',
        (session['user_id'],)
    ).fetchone()

    return jsonify({
        "success": True,
        "profile": {
            "email": user['email'],
            "nickname": user['nickname'],
            "preferences": {
                "allergies": json.loads(prefs['allergies']) if prefs else [],
                "dietary_restrictions": json.loads(prefs['dietary_restrictions']) if prefs else [],
                "preferred_cuisines": json.loads(prefs['preferred_cuisines']) if prefs else []
            }
        }
    })


@app.route('/api/profile', methods=['PUT'])
@login_required
def update_profile():
    """프로필 수정"""
    data = request.get_json()
    db = get_db()

    if 'nickname' in data:
        db.execute(
            'UPDATE users SET nickname = ?, updated_at = ? WHERE id = ?',
            (data['nickname'], datetime.now(), session['user_id'])
        )

    if 'preferences' in data:
        prefs = data['preferences']
        db.execute('''
            UPDATE user_preferences SET
                allergies = ?,
                dietary_restrictions = ?,
                preferred_cuisines = ?
            WHERE user_id = ?
        ''', (
            json.dumps(prefs.get('allergies', [])),
            json.dumps(prefs.get('dietary_restrictions', [])),
            json.dumps(prefs.get('preferred_cuisines', [])),
            session['user_id']
        ))

    db.commit()
    return jsonify({"success": True})


# ===== Step 3: 레시피 저장 API =====

@app.route('/api/recipes/save', methods=['POST'])
@login_required
def save_recipe():
    """레시피 저장"""
    data = request.get_json()
    recipe_data = data.get('recipe')

    if not recipe_data:
        return jsonify({"success": False, "error": "레시피 데이터가 필요합니다"}), 400

    db = get_db()
    cursor = db.execute('''
        INSERT INTO saved_recipes
        (user_id, recipe_name, recipe_data, ingredients, cuisine_type, difficulty, cook_time, notes, tags)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
    ''', (
        session['user_id'],
        recipe_data.get('name', '저장된 레시피'),
        json.dumps(recipe_data),
        json.dumps(data.get('ingredients', [])),
        data.get('cuisine_type', ''),
        recipe_data.get('difficulty', ''),
        recipe_data.get('cookTime', ''),
        data.get('notes', ''),
        json.dumps(data.get('tags', []))
    ))
    db.commit()

    return jsonify({"success": True, "recipe_id": cursor.lastrowid})


@app.route('/api/recipes', methods=['GET'])
@login_required
def get_saved_recipes():
    """저장된 레시피 목록"""
    db = get_db()
    recipes = db.execute('''
        SELECT * FROM saved_recipes
        WHERE user_id = ?
        ORDER BY created_at DESC
    ''', (session['user_id'],)).fetchall()

    result = []
    for r in recipes:
        result.append({
            "id": r['id'],
            "name": r['recipe_name'],
            "recipe": json.loads(r['recipe_data']),
            "ingredients": json.loads(r['ingredients']),
            "cuisine_type": r['cuisine_type'],
            "difficulty": r['difficulty'],
            "cook_time": r['cook_time'],
            "rating": r['rating'],
            "notes": r['notes'],
            "tags": json.loads(r['tags']),
            "created_at": r['created_at']
        })

    return jsonify({"success": True, "recipes": result})


@app.route('/api/recipes/<int:recipe_id>', methods=['GET'])
@login_required
def get_recipe_detail(recipe_id):
    """레시피 상세"""
    db = get_db()
    r = db.execute(
        'SELECT * FROM saved_recipes WHERE id = ? AND user_id = ?',
        (recipe_id, session['user_id'])
    ).fetchone()

    if not r:
        return jsonify({"success": False, "error": "레시피를 찾을 수 없습니다"}), 404

    return jsonify({
        "success": True,
        "recipe": {
            "id": r['id'],
            "name": r['recipe_name'],
            "recipe": json.loads(r['recipe_data']),
            "ingredients": json.loads(r['ingredients']),
            "cuisine_type": r['cuisine_type'],
            "difficulty": r['difficulty'],
            "cook_time": r['cook_time'],
            "rating": r['rating'],
            "notes": r['notes'],
            "tags": json.loads(r['tags']),
            "created_at": r['created_at']
        }
    })


@app.route('/api/recipes/<int:recipe_id>', methods=['PUT'])
@login_required
def update_recipe(recipe_id):
    """레시피 수정 (메모, 평점)"""
    data = request.get_json()
    db = get_db()

    r = db.execute(
        'SELECT id FROM saved_recipes WHERE id = ? AND user_id = ?',
        (recipe_id, session['user_id'])
    ).fetchone()

    if not r:
        return jsonify({"success": False, "error": "레시피를 찾을 수 없습니다"}), 404

    # 화이트리스트 기반 업데이트 (SQL Injection 방지)
    ALLOWED_FIELDS = {'rating', 'notes', 'tags'}
    updates = []
    params = []

    if 'rating' in data and 'rating' in ALLOWED_FIELDS:
        rating = data['rating']
        if isinstance(rating, int) and 1 <= rating <= 5:
            updates.append('rating = ?')
            params.append(rating)

    if 'notes' in data and 'notes' in ALLOWED_FIELDS:
        notes = data['notes']
        if isinstance(notes, str) and len(notes) <= 1000:
            updates.append('notes = ?')
            params.append(notes)

    if 'tags' in data and 'tags' in ALLOWED_FIELDS:
        tags = data['tags']
        if isinstance(tags, list):
            updates.append('tags = ?')
            params.append(json.dumps(tags))

    if updates:
        params.append(recipe_id)
        # 안전한 정적 쿼리 구성 (화이트리스트 필드만 사용)
        query = 'UPDATE saved_recipes SET ' + ', '.join(updates) + ' WHERE id = ?'
        db.execute(query, params)
        db.commit()

    return jsonify({"success": True})


@app.route('/api/recipes/<int:recipe_id>', methods=['DELETE'])
@login_required
def delete_recipe(recipe_id):
    """레시피 삭제"""
    db = get_db()

    r = db.execute(
        'SELECT id FROM saved_recipes WHERE id = ? AND user_id = ?',
        (recipe_id, session['user_id'])
    ).fetchone()

    if not r:
        return jsonify({"success": False, "error": "레시피를 찾을 수 없습니다"}), 404

    db.execute('DELETE FROM saved_recipes WHERE id = ?', (recipe_id,))
    db.commit()

    return jsonify({"success": True})


# ===== Step 3: 히스토리 API =====

@app.route('/api/history/analysis', methods=['GET'])
@login_required
def get_analysis_history():
    """분석 히스토리"""
    db = get_db()
    history = db.execute('''
        SELECT * FROM analysis_history
        WHERE user_id = ?
        ORDER BY created_at DESC
        LIMIT 20
    ''', (session['user_id'],)).fetchall()

    result = []
    for h in history:
        result.append({
            "id": h['id'],
            "ingredients": json.loads(h['detected_ingredients']),
            "created_at": h['created_at']
        })

    return jsonify({"success": True, "history": result})


@app.route('/api/history/stats', methods=['GET'])
@login_required
def get_stats():
    """통계 정보"""
    db = get_db()

    # 저장된 레시피 수
    recipe_count = db.execute(
        'SELECT COUNT(*) as count FROM saved_recipes WHERE user_id = ?',
        (session['user_id'],)
    ).fetchone()['count']

    # 분석 횟수
    analysis_count = db.execute(
        'SELECT COUNT(*) as count FROM analysis_history WHERE user_id = ?',
        (session['user_id'],)
    ).fetchone()['count']

    # 자주 사용하는 재료 (SQLite JSON1 extension으로 DB에서 직접 집계)
    # json_each()를 사용하여 JSON 배열을 행으로 확장하고 GROUP BY로 집계
    top_ingredients_rows = db.execute('''
        SELECT ingredient.value as name, COUNT(*) as count
        FROM analysis_history, json_each(detected_ingredients) as ingredient
        WHERE user_id = ?
        GROUP BY ingredient.value
        ORDER BY count DESC
        LIMIT 10
    ''', (session['user_id'],)).fetchall()

    top_ingredients = [(row['name'], row['count']) for row in top_ingredients_rows]

    return jsonify({
        "success": True,
        "stats": {
            "saved_recipes": recipe_count,
            "analysis_count": analysis_count,
            "top_ingredients": [{"name": k, "count": v} for k, v in top_ingredients]
        }
    })


# ===== 진단 엔드포인트 (개발용) =====

@app.route('/api/debug/test-api', methods=['GET'])
def test_api():
    """API 키 및 모델 연결 테스트"""
    if os.getenv('FLASK_ENV') == 'production':
        return jsonify({"error": "Not available in production"}), 403

    results = []
    key_preview = f"{OPENROUTER_API_KEY[:15]}...{OPENROUTER_API_KEY[-4:]}" if OPENROUTER_API_KEY else "NOT SET"

    # 간단한 텍스트 요청으로 API 키 유효성 테스트
    test_messages = [{"role": "user", "content": "Say hello in Korean, one word only"}]

    for model in IMAGE_MODELS[:2]:  # 처음 2개 모델만 테스트
        result = call_openrouter(model, test_messages, timeout=15)
        results.append({
            "model": model,
            "success": "error" not in result,
            "response": result.get('choices', [{}])[0].get('message', {}).get('content', '')[:100] if "error" not in result else str(result.get('error', ''))[:200]
        })

    return jsonify({
        "api_key": key_preview,
        "image_models": IMAGE_MODELS,
        "text_models": TEXT_MODELS,
        "test_results": results
    })


if __name__ == '__main__':
    # 프로덕션에서는 FLASK_ENV=production으로 설정
    debug_mode = os.getenv('FLASK_ENV', 'development') == 'development'
    app.run(debug=debug_mode, port=5000)