// src/game/store.ts
class Store {
  private state: GameState = {
    screen: 'splash',
    tweaks: { palette: 'sunshine', avatarStyle: 'portrait', intensity: 2, roomLayout: 'side' },
    onboardingStep: 0,
    endConfirm: { sum: false, safe: false, ice: false },
    selectedCaseId: 'im-001',
    hasOnboarded: readOnboarded(),
    polyclinic: { clinic: DEFAULT_CLINIC, patient: null },
    lastEncounter: null,
    viewedEvalHistoryId: null,
  };

  private listeners = new Set<() => void>();

  getState = (): GameState => this.state;

  subscribe = (l: () => void): (() => void) => {
    this.listeners.add(l);
    return () => this.listeners.delete(l);
  };

  private set(next: Partial<GameState>) {
    this.state = { ...this.state, ...next };
    for (const l of this.listeners) l();
  }

  // ── navigation ────────────────────────────────
  setScreen = (screen: Screen) => this.set({ screen });
  acceptNextPatient = (id?: string) => { /* ... */ };
  finishPolyclinicCase = () => { /* ... */ };
}

// React 组件中的用法
export function useScreen(): Screen {
  return useStore((s) => s.screen);
}

export function useTweaks(): Tweaks {
  return useStore((s) => s.tweaks);
}

export function useGameState(): GameState {
  return useStore((s) => s);
}

// PatientCase — 病例完整数据（含诊断选项、用药指南引用）
interface PatientCase {
  id: string;
  name: string;
  age: number;
  gender: 'M' | 'F';
  severity: 'stable' | 'urgent' | 'critical';
  chiefComplaint: string;
  vitals: { hr: number; bp: string; spo2: number; temp: number; rr: number };
  correctDiagnosisId: string;
  acceptableTreatmentIds: string[];
  criticalTreatmentIds: string[];
  diagnosisOptions: DiagnosisOption[];
}

// ActivePatient — 患者在就诊过程中的实时状态
interface ActivePatient {
  case: PatientCase;
  bedIndex: number;
  status: 'in-bed' | 'seated' | 'discharged';
  askedQuestionIds: string[];    // 问诊历史
  orderedTestIds: string[];       // 已开检查
  testOrderedAt: Record<string, number>; // 检查时间戳（用于模拟分钟流逝）
  completedTestIds: string[];     // 已出结果
  givenTreatmentIds: string[];    // 已执行治疗
  prescriptions?: Prescription[];// 门诊处方
  submittedDiagnosisId: string | null;
  arrivedAt: number;
  deadlineMs: number;             // 时限（8分钟/急诊）
}

acceptNextPatient = (id?: string) => {
  const targetId = id ?? this.pickNextCaseId() ?? this.state.selectedCaseId;
  const c = getCase(targetId);
  // 预先激活 AudioContext（绕过浏览器自动播放策略）
  try { ensureAudioContext(); } catch { /* SSR */ }
  this.markAttempted(targetId);
  this.set({
    selectedCaseId: targetId,
    polyclinic: { ...this.state.polyclinic, patient: toActivePatient(c) },
    screen: 'encounter',
  });
};

// finishPolyclinicCase — 患者离开后才评分
finishPolyclinicCase = () => {
  const snapshot = this.state.polyclinic.patient;
  const keepSnapshot = snapshot && hasEncounterActivity(snapshot);
  // 只有真正有诊疗活动的快照才保留，避免空快照覆盖真实 encounter
  this.set({
    polyclinic: { ...this.state.polyclinic, patient: null },
    lastEncounter: keepSnapshot ? snapshot : this.state.lastEncounter,
  });
};

// src/voice/conversation.ts
export class Conversation {
  private room: Room | null = null;
  private remoteAudioTrack: RemoteAudioTrack | null = null;
  private analyser: AnalyserNode | null = null; // 唇同步用

  async init() {
    // 1. 获取 LiveKit JWT 和房间信息
    const tok = await fetchVoiceToken({ caseId, systemPrompt, initialLine, gender });

    // 2. 连接 WebRTC 房间
    const room = new Room({ adaptiveStream: true, dynacast: true });
    this.wireRoomEvents(room);
    await room.connect(tok.url, tok.token);
    this.room = room;

    // 3. 打开麦克风（实时 —— 不需要按压触发）
    await room.localParticipant.setMicrophoneEnabled(true);
  }

  private wireRoomEvents(room: Room) {
    room.on(RoomEvent.TrackSubscribed, (track, pub, participant) => {
      if (track.kind === Track.Kind.Audio) {
        this.remoteAudioTrack = track as RemoteAudioTrack;
        this.attachAnalyser(this.remoteAudioTrack);
        // 附加到 DOM 供 LiveKit 自动播放
        const el = (track as RemoteAudioTrack).attach();
        document.body.appendChild(el);
      }
    });

    // 实时转写 — 来自患者的语音
    room.on(RoomEvent.TranscriptionReceived, (segments, participant) => {
      const isLocal = participant?.identity === room.localParticipant.identity;
      for (const seg of segments) {
        if (isLocal) {
          this.handleUserTranscription(seg);
        } else {
          this.handleAgentTranscription(seg);
        }
      }
    });
  }

  // 情绪检测 — 驱动 3D 角色的表情
  private handleAgentTranscription(seg: TranscriptionSegment) {
    if (!seg.final) {
      this.setEmotion(detectEmotion(seg.text));
      this.listeners.onSubtitle?.({ who: 'patient', text: seg.text, partial: true });
      return;
    }
    const final = seg.text.trim();
    this.messages.push({ role: 'assistant', content: final });
    this.emitMessages();
  }
}

function detectEmotion(text: string): PatientEmotion {
  const t = text.toLowerCase();
  if (/\b(hurts?|pain|ache|ow|ouch|sore|sharp|throb|stab)\b/.test(t)) return 'pain';
  if (/\b(scared|afraid|terrified|anxious|help me|dying)\b/.test(t)) return 'fear';
  if (/\b(okay|i'm fine|better|thanks|relieved)\b/.test(t)) return 'relief';
  if (/\b(i don't know|not sure|confused|what do you mean)\b/.test(t)) return 'confused';
  return 'neutral';
}

# backend/voice_agent.py
class PatientAgent(Agent):
    def __init__(self, persona_prompt: str, initial_line: str, voice_id: str):
        super().__init__(
            model=anthropic.LLM(model="claude-haiku-4-5"),
            voice=AgentVoice(
                voice_id=voice_id,
                model=LLM_VOICE_LATENCY,
            ),
            # STT → LLM → TTS 的 pipeline 配置
            fnc_ctx=None,
        )
        self.persona_prompt = persona_prompt
        self.initial_line = initial_line
        self.llm = anthropic.LLM(model="claude-haiku-4-5")

    async def on_session_started(self, session: AgentSession):
        # 房间元数据中存储了 caseId / systemPrompt / initialLine / voiceGender
        room_meta = json.loads(session.room.metadata or "{}")
        self.persona_prompt = room_meta.get("systemPrompt", DEFAULT_INSTRUCTIONS)
        self.voice_id = self._pick_voice(room_meta.get("voiceGender", "M"))
        # 用初始台词触发患者的开场白
        await session.generate_reply(
            instructions=f"Say exactly: '{self.initial_line}'"
        )

// src/agents/managedAgent.ts
export async function* openEventStream(
  sessionId: string,
  opts: StreamOptions = {},
): AsyncGenerator<ManagedAgentEvent, void, unknown> {
  const seen = new Set<string>();
  const backfillOnReconnect = opts.backfillOnReconnect !== false;

  while (!closed) {
    // 重连时：先拉历史事件
    if (backfillOnReconnect) {
      const history = await fetchHistory(sessionId);
      for (const ev of history) {
        if (!seen.has(ev.id)) {
          seen.add(ev.id);
          yield ev;
          if (isTerminal(ev)) return;
        }
      }
    }

    // 然后接入 live SSE 流
    const es = new EventSource(`${AGENT_BASE}/sessions/${sessionId}/stream`);
    // 处理 typed events ...
    // 每个 event 先检查是否已见过（dedupe），再 yield
  }
}

# backend/server.py — 自定义工具 schema
MEDKIT_CUSTOM_TOOLS = [
    {
        "type": "custom",
        "name": "render_vitals_chart",
        "description": "展示患者生命体征随时间的变化曲线",
        "input_schema": {
            "type": "object",
            "properties": {"patient_id": {"type": "string"}},
            "required": ["patient_id"],
        },
    },
    {
        "type": "custom",
        "name": "render_case_evaluation",
        "description": (
            "PLAB2 风格 end-of-encounter 评分。"
            "评分三个域：data_gathering、clinical_management、interpersonal。"
            "每个 criterion 必须有具体的引文引用registry中的指南。"
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "case_id": {"type": "string"},
                "global_rating": {
                    "type": "string",
                    "enum": ["clear-fail", "borderline", "satisfactory", "good", "excellent"],
                },
                "domain_scores": {
                    "type": "object",
                    "properties": {
                        "data_gathering": {
                            "type": "object",
                            "properties": {"raw": {}, "max": {}, "verdict": {}},
                            "required": ["raw", "max", "verdict"],
                        },
                        # clinical_management, interpersonal 同理
                    },
                    "required": ["data_gathering", "clinical_management", "interpersonal"],
                },
                "criteria": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "criterion_id": {},
                            "domain": {"enum": ["data_gathering", "clinical_management", "interpersonal"]},
                            "verdict": {"enum": ["met", "partially-met", "missed"]},
                            "evidence": {"type": "string"},
                            "guideline_ref": {"type": ["string", "null"]},  # 格式: 'guideline_id:rec_id'
                        },
                    },
                },
                "safety_breach": {"type": ["object", "null"]},
                "highlights": {"type": "array", "items": {"type": "string"}},
                "improvements": {"type": "array", "items": {"type": "string"}},
                "narrative": {"type": "string"},
            },
        },
    },
]

# backend/server.py — vault endpoint
@app.post("/agent/vault/ehr/lookup", response_model=EhrLookupResponse)
def vault_ehr_lookup(req: EhrLookupRequest):
    if not _vault_token_configured():
        raise HTTPException(503, detail="EHR_API_TOKEN not configured")
    record = FAKE_EHR_RECORDS.get(patient_id)
    if record is None:
        raise HTTPException(404, detail=f"patient_id not found: {patient_id}")
    # 日志不记录 token 内容
    _agent_log.info("vault: ehr lookup patient=%s", patient_id)
    return EhrLookupResponse(patient_id=patient_id, record=record, fetched_via="credential-vault")

// src/components/three/Polyclinic.tsx
// 医生椅位置（靠桌）
export const DOCTOR_CHAIR_POS: [number, number, number] = [0, 0, ROOM_BACK_Z + 0.55];
// 患者椅位置（对面）
export const PATIENT_CHAIR_POS: [number, number, number] = [0, 0, ROOM_BACK_Z + 4.5];

// 预制件：Canvas 纹理生成诊断证明书
function makeDiplomaTexture(institution, degree, name, year, sealColor): CanvasTexture {
  // 羊皮纸渐变 + 噪点 + 金色边框 + 封印 + 签名
  // 完全程序化，无外部图片依赖
}

// 动态 EMR 屏幕纹理
function makeMonitorTexture(patient: MonitorPatient | null): CanvasTexture {
  const c = document.createElement('canvas');
  // 根据当前接诊患者实时更新显示内容
}

# backend/server.py — Managed Agent 代理核心
@app.get("/agent/sessions/{session_id}/stream")
async def stream_events(session_id: str, request: Request):
    """SSE 代理，保持 FastAPI 异步事件循环不被阻塞"""
    client = get_async_anthropic_client()  # AsyncAnthropic

    async def generator():
        yield ": connected\n\n"  # 小 preamble 防止代理缓存
        try:
            async with client.beta.sessions.events.stream(session_id=session_id) as stream:
                async for event in stream:
                    if await request.is_disconnected():
                        break
                    payload = event.model_dump(mode="json")
                    etype = payload.get("type", "message")
                    yield f"event: {etype}\ndata: {json.dumps(payload)}\n\n"
        except Exception as e:
            yield f"event: proxy_error\ndata: {json.dumps({'type':'proxy_error','message': str(e)})}\n\n"

    return StreamingResponse(
        generator(),
        media_type="text/event-stream",
        headers={"X-Accel-Buffering": "no"},  # 禁用 nginx 缓冲
    )