npc_social_network/routes/npc_route.py

# portfolio/npc_social_network/routes/npc_route.py
from flask import Blueprint, render_template, request, jsonify, url_for
from .. import simulation_core
from ..models.gemini_setup import initialize_model
import os



npc_bp = Blueprint(
    "npc_social",
    __name__,
    static_folder="../static",
    static_url_path="/npc_social_network"
)

@npc_bp.route("/")
def dashboard():
    return render_template("dashboard.html")

# 시뮬레이션을 시작하는 API
@npc_bp.route("/api/initialize_simulation", methods=['POST'])
def api_initialize_simulation():
    """API 키를 받아 시뮬레이션을 초기화하고 시작하는 API"""
    from ..models.gemini_setup import initialize_model
    data = request.json
    model_name = data.get("model_name", "gemini-2.0-flash")
    api_key = data.get("api_key")

    if not api_key:
        return jsonify({"success": False, "error": "API 키를 입력해주세요."}), 400
    
    # 1. 모델 초기화 시도
    new_model = initialize_model(model_name, api_key)
    
    if new_model:
        # 2. 성공시, 전역 모델을 설정하고 시뮬레이션을 시작
        simulation_core.active_llm_model = new_model
        if not simulation_core.simulation_initialized:
            simulation_core.initialize_simulation()
            simulation_core.start_simulation_loop()
        return jsonify({"success": True, "message": f"'{model_name}' 모델로 시뮬레이션을 시작합니다."})
    else:
        return jsonify({"success": False, "error": "API 키가 유효하지 않거나 모델 초기화에 실패했습니다."}), 400

@npc_bp.route("/api/world_state", methods=['GET'])
def get_world_state():
    if not simulation_core.simulation_initialized:
        return jsonify({"status": "needs_initialization", "log": simulation_core.event_log})
    with simulation_core.simulation_lock:
        if not simulation_core.npc_manager:
            return jsonify({"error": "Simulation not started"}), 500
        all_npcs = list(simulation_core.npc_manager.all())
        current_log = list(simulation_core.event_log)
        is_paused = simulation_core.simulation_paused

    nodes = []
    for npc in all_npcs:
        # 각 NPC의 영어 ID를 기반으로 이미지 파일명을 생성합니다. (예: elin -> elin.png)
        image_filename = f"images/npc/{npc.name}.png"
        # if not os.path.exists(image_filename):
        #     image_filename = f"images/npc/npc.png"


        nodes.append({
            # id는 영어로, label은 한글로 분리
            "id": npc.name,
            "label": npc.korean_name,
            "shape": "image",  # 노드 모양을 'image'로 지정합니다.
            "image": url_for('npc_social.static', filename=image_filename), # 올바른 이미지 경로를 생성합니다.
            "size": 40 # 이미지 크기를 적절히 조절합니다.
        })

    edges = []
    drawn_relations = set()
    for npc in all_npcs:
        for target_name, profile in npc.relationships.relationships.items():
            from_id = npc.name
            to_id = target_name
            
            relation_pair = tuple(sorted((from_id, to_id)))
            if relation_pair in drawn_relations: continue

            color = {"best friend": "#00E676", "friend": "#4CAF50", "acquaintance": "#81D4FA",
                     "nuisance": "#FFC107", "rival": "#FF9800", "enemy": "#F44336",
                     "stranger":"#BDBDBD"}.get(profile.type, "gray")
            
            edges.append({
                "from": from_id, "to": to_id,
                "label": f"{profile.type} ({profile.score:.1f})",
                "color": color
            })
            drawn_relations.add(relation_pair)
    
    # 플레이어 입력 대기 상태 정보
    waiting_for_player = False
    player_conversation_info = None
    if simulation_core.conversation_manager and simulation_core.conversation_manager.is_conversation_active():
        conv = simulation_core.conversation_manager.active_conversation
        if conv.waiting_for_player:
            waiting_for_player = True
            # 플레이어에게 말을 건 NPC의 정보 찾기
            other_npc = conv.participants[1 - conv.turn_index]
            player_conversation_info = {
                "npc_name": other_npc.korean_name,
                "last_utterance": conv.conversation_history[-1] if conv.conversation_history else ""
            }

    return jsonify({ "nodes": nodes, "edges": edges, "log": current_log, "paused": is_paused, "waiting_for_player": waiting_for_player, "player_conversation": player_conversation_info })

@npc_bp.route("/api/toggle_simulation", methods=['POST'])
def toggle_simulation():
    with simulation_core.simulation_lock:
        simulation_core.simulation_paused = not simulation_core.simulation_paused
        status = "정지됨" if simulation_core.simulation_paused else "실행 중"
        simulation_core.add_log(f"시뮬레이션이 {status} 상태로 변경되었습니다.")
        is_paused = simulation_core.simulation_paused
    return jsonify({"paused": is_paused})

@npc_bp.route("/api/manual_tick", methods=['POST'])
def manual_tick():
    # 수동 틱은 시뮬레이션이 멈춰있을 때만 작동하도록 함
    if simulation_core.simulation_paused:
        simulation_core.tick_simulation()
    else:
        simulation_core.add_log("경고: 시뮬레이션이 실행 중일 때는 수동 틱을 할 수 없습니다.")
    return get_world_state()


@npc_bp.route("/api/inject_event", methods=['POST'])
def inject_event():
    """플레이어가 NPC에게 '과거 기억'을 자연스럽게 주입하는 함수"""
    data = request.json
    npc_name, event_text = data.get("npc_name"), data.get("event_text")
    
    with simulation_core.simulation_lock:
        npc = simulation_core.npc_manager.get_npc_by_korean_name(npc_name)
        if npc and event_text:
            npc.remember(content=event_text, importance=8, emotion="nostalgia", memory_type="Recalled_Past")      # 이벤트 타입: 상기된 과거
            simulation_core.add_log(f"플레이어 개입 -> {npc_name}에게 '상기된 과거' 주입: '{event_text}'")
            return jsonify({"success": True})
    return jsonify({"success": False, "error": "Invalid data"}), 400

# get_npc_details 와 같은 나머지 읽기 전용 API도 Lock을 추가하면 더 안전합니다.
@npc_bp.route("/api/npc_details/<npc_name>", methods=['GET'])
def get_npc_details(npc_name):
    with simulation_core.simulation_lock:
        npc = simulation_core.npc_manager.get_npc_by_korean_name(npc_name)
        if not npc:
            return jsonify({"error": "NPC not found"}), 404

        details = {
            "name": npc.korean_name, "age": npc.age, "job": npc.job,
            "personality_summary": npc.personality.get_narrative_summary(),
            "emotions": npc.get_composite_emotion_state(top_n=5),
            "goals": npc.planner.current_goal.description if npc.planner.has_active_plan() else "특별한 목표 없음",
            "memories": [mem.content for mem in npc.memory_store.get_recent_memories(limit=10)]
        }
    return jsonify(details)

@npc_bp.route("/api/force_relationship", methods=['POST'])
def force_relationship():
    """두 NPC의 관계를 강제로 설정하는 API"""
    data = request.json
    npc1_name = data.get("npc1_name")
    npc2_name = data.get("npc2_name")
    relationship_type = data.get("relationship_type")

    if not all([npc1_name, npc2_name, relationship_type]) or npc1_name == npc2_name:
        return jsonify({"success": False, "error": "Invalid data"}), 400
    
    with simulation_core.simulation_lock:
        npc1 = simulation_core.npc_manager.get_npc_by_korean_name(npc1_name)
        npc2 = simulation_core.npc_manager.get_npc_by_korean_name(npc2_name)

        if npc1 and npc2:
            # 관계는 상호작용이므로, 양쪽 모두에게 관계를 설정
            npc1.relationships.set_relationship(npc2.name, relationship_type)
            npc2.relationships.set_relationship(npc1.name, relationship_type)
            return jsonify({"success": True})
        
    return jsonify({"success": False, "error": "NPC not found"}), 404

@npc_bp.route("/api/orchestrate_conversation", methods=['Post'])
def orchestrate_conversation():
    """플레이어가 지정한 두 NPC와 상황으로 대화를 시작시키는 API"""
    data = request.json
    npc1_name = data.get("npc1_name")
    npc2_name = data.get("npc2_name")
    situation = data.get("situation")   # 대화 핵심 'topic'

    if not all([npc1_name, npc2_name, situation]) or npc1_name == npc2_name:
        return jsonify({"success": False, "error": "Invalid data"}), 400
    
    # 락을 걸지 않고 매니저에 바로 요청
    npc1 = simulation_core.npc_manager.get_npc_by_korean_name(npc1_name)
    npc2 = simulation_core.npc_manager.get_npc_by_korean_name(npc2_name)

    if npc1 and npc2:
        # 기존의 대화 시작 함수 재활용
        simulation_core.conversation_manager.start_conversation(npc1, npc2, topic=situation)
        return jsonify({"success": True})
    
    return jsonify({"success": False, "error": "NPC not found"}), 404

@npc_bp.route("/api/player_response", methods=['POST'])
def player_response():
    """플레이어의 대화 응답을 받아 '대기열'에 추가, 처리는 simulation_loop에서 진행"""
    data = request.json
    utterance = data.get("utterance")

    if not utterance:
        return jsonify({"success": False, "error": "Invalid data"}), 400
    
    simulation_core.set_player_utterance(utterance)

    return jsonify({"success": True})

@npc_bp.route("/api/toggle_player", methods = ['POST'])
def toggle_player():
    """플레이어의 활성화 상태를 토글하는 API"""
    with simulation_core.simulation_lock:
        # npc_manager의 상태를 직접 변경
        simulation_core.npc_manager.set_player_active(not simulation_core.npc_manager.player_is_active)
        is_active = simulation_core.npc_manager.player_is_active
        status_text = "활성화" if is_active else "비활성화"
        simulation_core.add_log(f"플레이어 상태가 '{status_text}'로 변경되었습니다.")
    return jsonify({"success": True, "player_is_active": is_active})

@npc_bp.route("/api/set_llm_config", methods=['POST'])
def set_llm_config():
    """UI로부터 받은 모델과 API 키로 LLM을 실시간으로 재설정하는 API"""
    from ..models.gemini_setup import initialize_model
    
    data = request.json
    model_name = data.get("model_name")
    api_key = data.get("api_key")

    if not all([model_name, api_key]):
        return jsonify({"success": False, "error": "모델과 API 키를 모두 입력해주세요."}), 400

    # 새로운 설정으로 모델을 초기화 시도
    new_model = initialize_model(model_name, api_key)

    if new_model:
        # 성공 시, simulation_core의 전역 모델 객체를 새로운 모델로 교체
        simulation_core.active_llm_model = new_model
        return jsonify({"success": True})
    else:
        return jsonify({"success": False, "error": "API 키가 유효하지 않거나 모델 초기화에 실패했습니다."}), 400