game_engine.py

import random
import json
import logging
import os
import re
import difflib
from typing import TypedDict, List, Dict, Any
from langgraph.graph import StateGraph, END
from llm_factory import LLMFactory
from dotenv import load_dotenv

load_dotenv()

logger = logging.getLogger(__name__)


class PlayerState(TypedDict):
    scenario: Dict[str, Any]
    current_scene_id: str
    player_vars: Dict[str, Any]
    history: List[str]
    last_user_choice_idx: int
    last_user_input: str
    parsed_intent: str
    system_message: str
    npc_output: str
    narrator_output: str
    critic_feedback: str
    retry_count: int
    chat_log_html: str


def normalize_text(text: str) -> str:
    """텍스트 정규화 (공백 제거, 소문자)"""
    return text.lower().replace(" ", "")


# --- Nodes ---

def intent_parser_node(state: PlayerState):
    """
    Node 1: 유저 입력 의도 파악
    - Fast-Track: 단순 선택이나 키워드 매칭 시 LLM 없이 즉시 처리
    - Slow-Path: 애매한 입력은 LLM이 판단
    """
    user_input = state.get('last_user_input', '').strip()
    norm_input = normalize_text(user_input)
    logger.info(f"🟢 [USER INPUT]: {user_input}")

    # 1. 시스템적으로 이미 선택된 경우 (UI 클릭 등)
    if state.get('last_user_choice_idx', -1) != -1:
        state['parsed_intent'] = 'transition'
        return state

    scenario = state['scenario']
    curr_scene_id = state['current_scene_id']
    scenes = {s['scene_id']: s for s in scenario['scenes']}
    curr_scene = scenes.get(curr_scene_id)

    # 2. 엔딩 체크
    endings = {e['ending_id']: e for e in scenario.get('endings', [])}
    if curr_scene_id in endings:
        state['parsed_intent'] = 'ending'
        return state

    transitions = curr_scene.get('transitions', []) if curr_scene else []

    # 트랜지션 없으면 무조건 채팅
    if not transitions:
        state['parsed_intent'] = 'chat'
        return state

    # 3. [Fast-Track] 텍스트 유사도 매칭 (LLM 생략)
    # 파이썬 코드로 직접 비교하므로 속도가 매우 빠름 (0.01초 미만)
    best_idx = -1
    highest_ratio = 0.0

    for idx, trans in enumerate(transitions):
        trigger = trans.get('trigger', '').strip()
        if not trigger: continue
        norm_trigger = normalize_text(trigger)

        # 완전 일치 또는 포함 관계
        if norm_input == norm_trigger or (
                len(norm_input) > 2 and (norm_input in norm_trigger or norm_trigger in norm_input)):
            logger.info(f"⚡ [FAST-TRACK] Direct Match: '{user_input}' matched '{trigger}'")
            state['last_user_choice_idx'] = idx
            state['parsed_intent'] = 'transition'
            return state

        # 유사도 검사 (오타 허용)
        similarity = difflib.SequenceMatcher(None, norm_input, norm_trigger).ratio()
        if similarity > highest_ratio:
            highest_ratio = similarity
            best_idx = idx

    # 유사도가 0.7(70%) 이상이면 AI 호출 없이 바로 인정
    if highest_ratio >= 0.7:
        logger.info(f"⚡ [FAST-TRACK] Fuzzy Match ({highest_ratio:.2f}): '{user_input}' -> Transtion {best_idx}")
        state['last_user_choice_idx'] = best_idx
        state['parsed_intent'] = 'transition'
        return state

    # 4. [Slow-Path] LLM 기반 판단 (최후의 수단)
    triggers_text = "\n".join([f"- {t['trigger']}" for t in transitions])
    prompt = f"""
    [TASK] Match user input to hidden triggers.
    [TRIGGERS]
    {triggers_text}
    [INPUT] "{user_input}"
    [OUTPUT JSON] {{"type": "transition"|"chat", "index": 1-based_index}}
    """
    try:
        api_key = os.getenv("OPENROUTER_API_KEY")
        # 판단용 가벼운 모델 사용
        llm = LLMFactory.get_llm(api_key=api_key, model_name="openai/tngtech/deepseek-r1t2-chimera:free")
        response = llm.invoke(prompt).content.strip()

        # JSON 파싱 시도
        try:
            if "```" in response:
                response = response.split("```")[1].replace("json", "").strip()
            result = json.loads(response)

            if result.get('type') == 'transition':
                idx = int(result.get('index', 0)) - 1
                if 0 <= idx < len(transitions):
                    state['last_user_choice_idx'] = idx
                    state['parsed_intent'] = 'transition'
                    return state
        except:
            pass
    except Exception as e:
        logger.error(f"Intent Parser LLM Error: {e}")

    # 매칭 실패 시 기본값: 채팅
    state['parsed_intent'] = 'chat'
    return state


def rule_node(state: PlayerState):
    """
    Node 2: 규칙 엔진 (이펙트 적용 및 씬 이동)
    - 아이템 획득/분실
    - 스탯(HP, Sanity 등) 변경
    """
    idx = state['last_user_choice_idx']
    scenario = state['scenario']
    curr_scene_id = state['current_scene_id']

    all_scenes = {s['scene_id']: s for s in scenario['scenes']}
    all_endings = {e['ending_id']: e for e in scenario.get('endings', [])}

    sys_msg = []
    curr_scene = all_scenes.get(curr_scene_id)
    transitions = curr_scene.get('transitions', []) if curr_scene else []

    # 트랜지션 실행 조건 충족 시
    if state['parsed_intent'] == 'transition' and 0 <= idx < len(transitions):
        trans = transitions[idx]
        effects = trans.get('effects', [])
        next_id = trans.get('target_scene_id')
        trigger_desc = trans.get('trigger', '행동')

        # --- [이펙트 처리 로직 복구됨] ---
        for eff in effects:
            try:
                if isinstance(eff, dict):
                    key = eff.get("target", "").lower()
                    operation = eff.get("operation", "add")
                    raw_val = eff.get("value", 0)

                    # 값 타입 변환
                    val = 0
                    if isinstance(raw_val, (int, float)):
                        val = int(raw_val)
                    elif isinstance(raw_val, str) and raw_val.isdigit():
                        val = int(raw_val)

                    # A. 아이템 처리 (gain_item / lose_item)
                    if operation in ["gain_item", "lose_item"]:
                        item_name = str(eff.get("value", ""))
                        inventory = state['player_vars'].get('inventory', [])

                        if operation == "gain_item":
                            if item_name not in inventory:
                                inventory.append(item_name)
                                sys_msg.append(f"📦 아이템 획득: {item_name}")
                        elif operation == "lose_item":
                            if item_name in inventory:
                                inventory.remove(item_name)
                                sys_msg.append(f"🗑️ 아이템 사용: {item_name}")

                        state['player_vars']['inventory'] = inventory
                        continue

                    # B. 수치 변수 처리 (HP, Sanity, Gold 등)
                    if key:
                        current_val = state['player_vars'].get(key, 0)
                        if not isinstance(current_val, (int, float)): current_val = 0

                        if operation == "add":
                            new_val = current_val + val
                            sys_msg.append(f"{key.upper()} +{val}")
                        elif operation == "subtract":
                            new_val = max(0, current_val - val)
                            sys_msg.append(f"{key.upper()} -{val}")
                        elif operation == "set":
                            new_val = val
                            sys_msg.append(f"{key.upper()} = {new_val}")
                        else:
                            new_val = current_val

                        state['player_vars'][key] = new_val

            except Exception as e:
                logger.error(f"Effect Processing Error: {e}")
                pass

        # 씬 ID 변경
        if next_id:
            state['current_scene_id'] = next_id
            logger.info(f"👣 [MOVE] {curr_scene_id} -> {next_id}")

    # 이동 후 엔딩인지 체크
    if state['current_scene_id'] in all_endings:
        ending = all_endings[state['current_scene_id']]
        state['parsed_intent'] = 'ending'
        # 엔딩 시 나레이터 출력 미리 생성
        state['narrator_output'] = f"""
        <div class="my-8 p-8 border-2 border-yellow-500/50 bg-gradient-to-b from-yellow-900/40 to-black rounded-xl text-center fade-in shadow-2xl relative overflow-hidden">
            <h3 class="text-3xl font-black text-yellow-400 mb-4 tracking-[0.2em] uppercase drop-shadow-md">🎉 ENDING 🎉</h3>
            <div class="w-16 h-1 bg-yellow-500 mx-auto mb-6 rounded-full"></div>
            <div class="text-2xl font-bold text-white mb-4 drop-shadow-sm">"{ending.get('title')}"</div>
            <p class="text-gray-200 leading-relaxed text-lg font-serif italic">
                {ending.get('description')}
            </p>
        </div>
        """

    state['system_message'] = " | ".join(sys_msg)
    return state


def npc_node(state: PlayerState):
    """
    Node 3: NPC 챗봇 (유저가 채팅을 시도했을 때)
    [개선] 대화 내역(History)을 프롬프트에 주입해서 문맥 파악 가능하게 변경
    """
    if state.get('parsed_intent') != 'chat':
        state['npc_output'] = ""
        return state

    scenario = state['scenario']
    user_text = state['last_user_input']
    curr_id = state['current_scene_id']

    all_scenes = {s['scene_id']: s for s in scenario['scenes']}
    curr_scene = all_scenes.get(curr_id)
    npc_names = curr_scene.get('npcs', []) if curr_scene else []

    if not npc_names:
        state['npc_output'] = ""
        return state

    # 첫 번째 NPC가 대답한다고 가정
    target_npc_name = npc_names[0]
    npc_info = f"Name: {target_npc_name}"

    for npc in scenario.get('npcs', []):
        if npc.get('name') == target_npc_name:
            npc_info += f"\nPersonality: {npc.get('personality')}\nTone: {npc.get('dialogue_style')}"
            break

    # [추가됨] 대화 내역 가져오기 (최근 5턴)
    history = state.get('history', [])
    history_context = "\n".join(history[-5:]) if history else "No previous conversation."

    prompt = f"""
    [ROLE] Act as the NPC '{target_npc_name}' in a TRPG.
    [SCENE] Current Location: {curr_scene.get('title')}
    [PROFILE] {npc_info}

    [CONVERSATION HISTORY]
    {history_context}

    [USER SAID] "{user_text}"
    [INSTRUCTION] Respond naturally in character. Keep it short (1-2 sentences). Use Korean.
    """

    try:
        api_key = os.getenv("OPENROUTER_API_KEY")
        llm = LLMFactory.get_llm(api_key=api_key, model_name="openai/tngtech/deepseek-r1t2-chimera:free")
        response = llm.invoke(prompt).content.strip()
        state['npc_output'] = response

        # [추가됨] 대화 내역 저장
        if 'history' not in state: state['history'] = []
        state['history'].append(f"User: {user_text}")
        state['history'].append(f"NPC({target_npc_name}): {response}")

    except Exception as e:
        logger.error(f"NPC LLM Error: {e}")
        state['npc_output'] = "..."

    return state


def narrator_node(state: PlayerState):
    """나레이터 노드 (실제 생성은 스트리밍 함수에서 처리하므로 여기선 패스)"""
    return state


# --- Streaming Generators (SSE) ---

def prologue_stream_generator(state: PlayerState):
    """프롤로그 텍스트 스트리밍"""
    scenario = state['scenario']
    # 프롤로그 텍스트 키가 다를 수 있어서 안전하게 가져옴
    prologue_text = scenario.get('prologue', scenario.get('prologue_text', ''))

    if not prologue_text:
        yield "이야기가 시작됩니다..."
        return

    # 한 번에 보내지 않고 청크 단위로 끊어서 보내거나, 이미 완성된 텍스트면 그냥 보냄
    # 여기서는 단순하게 전체 전송 (LLM 생성이 아니므로)
    yield prologue_text


def scene_stream_generator(state: PlayerState):
    """
    씬 묘사 스트리밍 (핵심: 선택지 미노출 + 힌트 은유적 포함)
    """
    scenario = state['scenario']
    curr_id = state['current_scene_id']

    all_scenes = {s['scene_id']: s for s in scenario['scenes']}
    curr_scene = all_scenes.get(curr_id)

    if not curr_scene:
        yield "알 수 없는 장면입니다."
        return

    scene_title = curr_scene.get('title', 'Untitled')
    scene_desc = curr_scene.get('description', '')
    npc_names = curr_scene.get('npcs', [])

    # 힌트용 트리거 정보 (출력용 아님, AI 힌트용)
    transitions = curr_scene.get('transitions', []) if curr_scene else []
    trigger_hints = [t.get('trigger', '') for t in transitions if t.get('trigger')]

    last_action = state.get('last_user_input', '')

    # 나레이션 프롬프트
    prompt = f"""
    You are a Game Master narrating a TRPG scene.

    [CONTEXT]
    Title: {scene_title}
    Description: {scene_desc}
    Last Action Player Took: "{last_action}"
    NPCs Here: {', '.join(npc_names)}

    [AVAILABLE HIDDEN ACTIONS (Do not list these directly!)]
    {trigger_hints}

    [INSTRUCTIONS]
    1. Describe the scene vividly. Start by describing the result of the 'Last Action'.
    2. Naturally weave **subtle hints** about the 'Available Hidden Actions' into the environment description.
       - Use HTML <mark>keyword</mark> to slightly highlight interactable objects if needed.
       - Example: "You see a <mark>rusty key</mark> on the table." (Implying user can take it)
    3. **CRITICAL: DO NOT LIST CHOICES.** - Never write "1. Open door", "2. Run away".
       - Never ask "What do you want to do?".
       - Just describe the situation and let the player type their action.
    4. Language: Korean (한국어).
    5. Length: 3-4 sentences.
    """

    try:
        api_key = os.getenv("OPENROUTER_API_KEY")
        # 스트리밍 지원 모델 사용
        llm = LLMFactory.get_llm(
            api_key=api_key,
            model_name="openai/tngtech/deepseek-r1t2-chimera:free",
            streaming=True
        )

        for chunk in llm.stream(prompt):
            if chunk.content:
                yield chunk.content

    except Exception as e:
        logger.error(f"Scene Streaming Error: {e}")
        # 오류 시 기본 설명이라도 출력
        yield scene_desc if scene_desc else "..."


# --- Graph Construction ---

def create_game_graph():
    """LangGraph 워크플로우 생성"""
    workflow = StateGraph(PlayerState)

    # 노드 등록
    workflow.add_node("intent_parser", intent_parser_node)
    workflow.add_node("rule_engine", rule_node)
    workflow.add_node("npc_actor", npc_node)
    workflow.add_node("narrator", narrator_node)

    # 시작점
    workflow.set_entry_point("intent_parser")

    # 조건부 엣지 (분기 처리)
    def route_action(state):
        intent = state.get('parsed_intent')
        if intent == 'transition' or intent == 'ending':
            return "rule_engine"
        else:
            return "npc_actor"

    workflow.add_conditional_edges(
        "intent_parser",
        route_action,
        {
            "rule_engine": "rule_engine",
            "npc_actor": "npc_actor"
        }
    )

    # 흐름 연결
    workflow.add_edge("rule_engine", "narrator")
    workflow.add_edge("npc_actor", "narrator")
    workflow.add_edge("narrator", END)

    return workflow.compile()