src/auth/tool_handlers.py

"""
User Tool Handlers
==================

user_* MCP Tool의 실제 실행 로직.
server_streamable.py의 execute_tool_async에서 호출됩니다.
"""

import logging
from typing import Dict, Any

from .session_manager import get_user_session_manager
from .magic_link import get_magic_link_auth
from .config import SUPPORTED_CHAINS, TIER_ALIASES, SERVER_BASE_URL

logger = logging.getLogger("eodi.auth.tool_handlers")


async def execute_user_tool(name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
    """
    User Tool 실행 라우터.
    
    Args:
        name: Tool 이름 (user_*)
        arguments: Tool 인자
        
    Returns:
        Tool 실행 결과
    """
    # 기존 인증/멤버십 관련 Tool
    if name == "user_get_profile":
        return await handle_get_profile(arguments)
    elif name == "user_update_membership":
        return await handle_update_membership(arguments)
    elif name == "user_delete_membership":
        return await handle_delete_membership(arguments)
    elif name == "user_request_auth":
        return await handle_request_auth(arguments)
    elif name == "user_verify_code":
        return await handle_verify_code(arguments)
    
    # 신용카드 관련 Tool (인증 필요)
    elif name in [
        "user_add_credit_card",
        "user_get_credit_cards", 
        "user_delete_credit_card",
        "user_update_credit_usage",
        "user_get_credit_recommendations",
        "user_get_credit_usage_summary"
    ]:
        return await _handle_credit_card_tool(name, arguments)
    
    # 가치 평가 관련 Tool (인증 필요)
    elif name in [
        "user_get_asset_valuation",
        "user_update_valuation_style",
        "user_get_valuation_styles",
        "user_parse_asset_text",
        "calculate_miles_vs_cashback",
        "generate_award_search_link"
    ]:
        return await _handle_valuation_tool(name, arguments)
    
    else:
        return {"success": False, "error": f"Unknown user tool: {name}"}


async def _handle_credit_card_tool(name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
    """
    신용카드 관련 Tool을 위한 공통 래퍼.
    세션 검증 후 해당 핸들러 호출.
    """
    from .credit_card_handlers import (
        handle_add_credit_card,
        handle_get_credit_cards,
        handle_delete_credit_card,
        handle_update_credit_usage,
        handle_get_credit_recommendations,
        handle_get_credit_usage_summary
    )
    
    session_token = arguments.get("session_token")
    user_session_manager = get_user_session_manager()
    
    # 인증 확인
    if not session_token:
        return {
            "success": False,
            "error": "session_token이 필요합니다. 먼저 user_get_profile을 호출하여 인증 상태를 확인하세요.",
            "auth_url": f"{SERVER_BASE_URL}/auth/login"
        }
    
    session = user_session_manager.get_session(session_token)
    if not session:
        return {
            "success": False,
            "error": "세션이 만료되었습니다. 다시 로그인해주세요.",
            "auth_url": f"{SERVER_BASE_URL}/auth/login"
        }
    
    user_id = session.user_id
    
    # 각 핸들러 호출
    if name == "user_add_credit_card":
        return await handle_add_credit_card(arguments, user_id)
    elif name == "user_get_credit_cards":
        return await handle_get_credit_cards(arguments, user_id)
    elif name == "user_delete_credit_card":
        return await handle_delete_credit_card(arguments, user_id)
    elif name == "user_update_credit_usage":
        return await handle_update_credit_usage(arguments, user_id)
    elif name == "user_get_credit_recommendations":
        return await handle_get_credit_recommendations(arguments, user_id)
    elif name == "user_get_credit_usage_summary":
        return await handle_get_credit_usage_summary(arguments, user_id)
    else:
        return {"success": False, "error": f"Unknown credit card tool: {name}"}


async def _handle_valuation_tool(name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
    """
    가치 평가 관련 Tool을 위한 공통 래퍼.
    세션 검증 후 해당 핸들러 호출.
    """
    from .valuation_handlers import (
        handle_get_asset_valuation,
        handle_update_valuation_style,
        handle_get_valuation_styles,
        handle_calculate_miles_vs_cashback,
        handle_generate_award_search_link
    )
    from .asset_parser import handle_parse_asset_text
    
    session_token = arguments.get("session_token")
    user_session_manager = get_user_session_manager()
    
    # 인증 확인
    if not session_token:
        return {
            "success": False,
            "error": "session_token이 필요합니다. 먼저 user_get_profile을 호출하여 인증 상태를 확인하세요.",
            "auth_url": f"{SERVER_BASE_URL}/auth/login"
        }
    
    session = user_session_manager.get_session(session_token)
    if not session:
        return {
            "success": False,
            "error": "세션이 만료되었습니다. 다시 로그인해주세요.",
            "auth_url": f"{SERVER_BASE_URL}/auth/login"
        }
    
    user_id = session.user_id
    
    # 각 핸들러 호출
    if name == "user_get_asset_valuation":
        return await handle_get_asset_valuation(arguments, user_id)
    elif name == "user_update_valuation_style":
        return await handle_update_valuation_style(arguments, user_id)
    elif name == "user_get_valuation_styles":
        return await handle_get_valuation_styles(arguments, user_id)
    elif name == "user_parse_asset_text":
        return await handle_parse_asset_text(arguments, user_id)
    elif name == "calculate_miles_vs_cashback":
        return await handle_calculate_miles_vs_cashback(arguments, user_id)
    elif name == "generate_award_search_link":
        return await handle_generate_award_search_link(arguments, user_id)
    else:
        return {"success": False, "error": f"Unknown valuation tool: {name}"}


async def handle_get_profile(arguments: Dict[str, Any]) -> Dict[str, Any]:
    """
    user_get_profile Tool 핸들러.
    
    세션 토큰이 있으면 프로필 반환, 없으면 인증 URL 반환.
    """
    session_token = arguments.get("session_token")
    user_session_manager = get_user_session_manager()
    
    if not session_token:
        # 인증되지 않음 → 인증 URL 안내
        return {
            "success": True,
            "connected": False,
            "auth_url": f"{SERVER_BASE_URL}/auth/login",
            "message": "Eodi에 연결되지 않았습니다. auth_url에서 로그인하거나, user_request_auth로 이메일 인증을 시작하세요."
        }
    
    # 세션 검증
    session = user_session_manager.get_session(session_token)
    if not session:
        return {
            "success": True,
            "connected": False,
            "auth_url": f"{SERVER_BASE_URL}/auth/login",
            "message": "세션이 만료되었습니다. 다시 로그인해주세요."
        }
    
    # 멤버십 조회
    try:
        from src.db.supabase_adapter import SupabaseAdapter
        adapter = SupabaseAdapter()
        
        memberships = adapter.get_user_memberships(session.user_id)
        profile = adapter.get_user_profile(session.user_id)
    except Exception as e:
        logger.error(f"프로필 조회 오류: {e}")
        memberships = []
        profile = None
    
    return {
        "success": True,
        "connected": True,
        "user_id": session.user_id,
        "profile": {
            "email_masked": session.email_masked,
            "preferred_airports": profile.get("preferred_airports", []) if profile else [],
            "created_at": profile.get("created_at") if profile else None,
        },
        "memberships": [
            {
                "chain": m["chain"],
                "tier": m["tier"],
                "expires_at": m.get("expires_at"),
            }
            for m in memberships
        ],
        "memberships_count": len(memberships)
    }


async def handle_update_membership(arguments: Dict[str, Any]) -> Dict[str, Any]:
    """
    user_update_membership Tool 핸들러.
    """
    session_token = arguments.get("session_token")
    chain = arguments.get("chain", "").upper()
    tier = arguments.get("tier", "")
    user_session_manager = get_user_session_manager()
    
    # 인증 확인
    if not session_token:
        return {
            "success": False,
            "error": "session_token이 필요합니다. 먼저 user_get_profile을 호출하여 인증 상태를 확인하세요."
        }
    
    session = user_session_manager.get_session(session_token)
    if not session:
        return {
            "success": False,
            "error": "세션이 만료되었습니다. 다시 로그인해주세요.",
            "auth_url": f"{SERVER_BASE_URL}/auth/login"
        }
    
    # 체인 유효성
    if chain not in SUPPORTED_CHAINS:
        return {
            "success": False,
            "error": f"지원하지 않는 체인입니다: {chain}",
            "supported_chains": list(SUPPORTED_CHAINS.keys())
        }
    
    # 등급 정규화
    tier_normalized = TIER_ALIASES.get(tier, tier)
    
    # 등급 유효성
    valid_tiers = SUPPORTED_CHAINS[chain]
    tier_lower_map = {t.lower(): t for t in valid_tiers}
    
    if tier_normalized.lower() not in tier_lower_map:
        return {
            "success": False,
            "error": f"{chain}의 유효하지 않은 등급입니다: {tier}",
            "valid_tiers": valid_tiers
        }
    
    tier_final = tier_lower_map[tier_normalized.lower()]
    
    # 멤버십 저장
    try:
        from src.db.supabase_adapter import SupabaseAdapter
        adapter = SupabaseAdapter()
        
        # 기존 멤버십 확인
        existing = adapter.get_user_memberships(session.user_id)
        is_update = any(m["chain"] == chain for m in existing)
        
        result = adapter.upsert_membership(session.user_id, chain, tier_final)
        
        if result:
            action = "updated" if is_update else "created"
            chain_names = {
                "HILTON": "힐튼",
                "MARRIOTT": "메리어트",  
                "IHG": "IHG",
                "ACCOR": "아코르",
                "HYATT": "하얏트",
            }
            chain_name = chain_names.get(chain, chain)
            
            return {
                "success": True,
                "action": action,
                "membership": {
                    "chain": chain,
                    "tier": tier_final,
                },
                "message": f"{chain_name} {tier_final} 등급이 {'수정' if is_update else '등록'}되었습니다."
            }
        else:
            return {
                "success": False,
                "error": "멤버십 저장에 실패했습니다. 잠시 후 다시 시도해주세요."
            }
    except Exception as e:
        logger.error(f"멤버십 저장 오류: {e}")
        return {
            "success": False,
            "error": f"멤버십 저장 중 오류가 발생했습니다: {e}"
        }


async def handle_delete_membership(arguments: Dict[str, Any]) -> Dict[str, Any]:
    """
    user_delete_membership Tool 핸들러.
    """
    session_token = arguments.get("session_token")
    chain = arguments.get("chain", "").upper()
    user_session_manager = get_user_session_manager()
    
    # 인증 확인
    if not session_token:
        return {
            "success": False,
            "error": "session_token이 필요합니다."
        }
    
    session = user_session_manager.get_session(session_token)
    if not session:
        return {
            "success": False,
            "error": "세션이 만료되었습니다. 다시 로그인해주세요."
        }
    
    # 체인 유효성
    if chain not in SUPPORTED_CHAINS:
        return {
            "success": False,
            "error": f"지원하지 않는 체인입니다: {chain}"
        }
    
    # 멤버십 삭제
    try:
        from src.db.supabase_adapter import SupabaseAdapter
        adapter = SupabaseAdapter()
        
        if adapter.delete_membership(session.user_id, chain):
            chain_names = {
                "HILTON": "힐튼",
                "MARRIOTT": "메리어트",
                "IHG": "IHG",
                "ACCOR": "아코르",
                "HYATT": "하얏트",
            }
            chain_name = chain_names.get(chain, chain)
            
            return {
                "success": True,
                "message": f"{chain_name} 멤버십이 삭제되었습니다."
            }
        else:
            return {
                "success": False,
                "error": "멤버십 삭제에 실패했습니다."
            }
    except Exception as e:
        logger.error(f"멤버십 삭제 오류: {e}")
        return {
            "success": False,
            "error": f"멤버십 삭제 중 오류가 발생했습니다: {e}"
        }


async def handle_request_auth(arguments: Dict[str, Any]) -> Dict[str, Any]:
    """
    user_request_auth Tool 핸들러.
    
    이메일로 Magic Link 발송.
    """
    email = arguments.get("email", "").strip().lower()
    magic_link_auth = get_magic_link_auth()
    
    if not email:
        return {
            "success": False,
            "error": "이메일 주소를 입력해주세요."
        }
    
    # 간단한 이메일 형식 검증
    if "@" not in email or "." not in email:
        return {
            "success": False,
            "error": "올바른 이메일 형식이 아닙니다."
        }
    
    success, error = await magic_link_auth.send_magic_link(email)
    
    if success:
        # 이메일 마스킹
        local, domain = email.split("@", 1)
        if len(local) <= 2:
            masked = local[0] + "*"
        else:
            masked = local[0] + "*" * (len(local) - 2) + local[-1]
        email_masked = f"{masked}@{domain}"
        
        return {
            "success": True,
            "message": f"{email_masked}으로 로그인 링크를 보냈습니다.\n\n📧 이메일에서 링크를 클릭한 후,\n화면에 표시되는 6자리 코드를 user_verify_code로 입력해주세요.",
            "next_step": "user_verify_code"
        }
    else:
        return {
            "success": False,
            "error": error or "이메일 발송에 실패했습니다."
        }


async def handle_verify_code(arguments: Dict[str, Any]) -> Dict[str, Any]:
    """
    user_verify_code Tool 핸들러.
    
    6자리 인증 코드 검증.
    """
    code = arguments.get("code", "").strip()
    magic_link_auth = get_magic_link_auth()
    
    if not code:
        return {
            "success": False,
            "error": "인증 코드를 입력해주세요."
        }
    
    # 코드 길이 검증
    code_clean = code.replace(" ", "").replace("-", "")
    if len(code_clean) != 6 or not code_clean.isdigit():
        return {
            "success": False,
            "error": "6자리 숫자 코드를 입력해주세요."
        }
    
    # client_ip는 MCP Tool에서 직접 접근 불가 → 기본값 사용
    success, session_token, email_masked, error = magic_link_auth.verify_auth_code(
        code_clean, "mcp_client"
    )
    
    if success:
        return {
            "success": True,
            "connected": True,
            "session_token": session_token,
            "email_masked": email_masked,
            "message": f"✅ 인증 완료! {email_masked}\n\n이제 멤버십을 등록해볼까요?\n어떤 호텔 체인 멤버십을 가지고 계세요?"
        }
    else:
        return {
            "success": False,
            "error": error
        }