// types/conversation.ts (新文件)

export type ItemBase = {
  id: string;             // 全局唯一
  turnId: string;         // 归属 turn
  timestamp: number;
  sourceOrder: number;    // 稳定 tiebreaker
};

export type ReasoningItem = ItemBase & {
  type: "reasoning";
  phase: "started" | "finished";
  title?: string;
  summary?: string;
  stepId?: string;
};

export type ToolCallItem = ItemBase & {
  type: "tool_call";
  toolCallId: string;
  toolName: string;
  args: Record<string, unknown>;
  status: "pending" | "running" | "succeeded" | "failed";
  result?: unknown;
  errorMessage?: string;
};

export type TextItem = ItemBase & {
  type: "text";
  role: "assistant" | "developer";
  content: string;        // 累积内容
  streaming: boolean;
  author?: string;
};

export type SubAgentTransferItem = ItemBase & {
  type: "subagent_transfer";
  fromAgent: string;
  toAgent: string;
  childTurnId?: string;   // 嵌套 turn
};

export type ErrorItem = ItemBase & {
  type: "error";
  code?: string;
  message: string;
  recoverable: boolean;
};

export type Item =
  | ReasoningItem
  | ToolCallItem
  | TextItem
  | SubAgentTransferItem
  | ErrorItem;

export type Turn = {
  id: string;             // = runId（真实，非合成）
  threadId: string;
  status: "streaming" | "finished" | "blocked" | "error";
  userMessage: { id: string; content: string; createdAt: Date };
  items: Item[];          // 有序、不可变
  startedAt: Date;
  finishedAt?: Date;
  pendingConfirmationCount: number;
};

export type Conversation = {
  threadId: string;
  turns: Turn[];          // 不可变历史，按时间序
  status: "idle" | "streaming" | "blocked" | "error";
};

// utils/dedup/event-merge.ts
export function mergeByKeyWithTiebreaker<T>(
  base: T[],
  incoming: T[],
  getKey: (item: T) => string,
  getTiebreaker: (item: T) => [number, string],
): T[];

// utils/dedup/semantic-match.ts
export function computeBigramJaccard(a: string, b: string): number;
export function semanticEquivalent(a: string, b: string, opts: {
  exactMatch?: boolean;
  prefixMatch?: boolean;
  minLength?: number;
  minJaccard?: number;
}): boolean;

// utils/dedup/id-resolution.ts
export function isSyntheticRunId(entry: { runId?: string; threadId?: string }): boolean;
export function resolveCanonicalRunId(event: BaseEvent, context: { realtimeRunIds: Set<string> }): string;

export const DEFAULT_THRESHOLDS = {
  MESSAGE_DEDUP_WINDOW_MS: 8_000,
  SHORT_TEXT_CHAR_THRESHOLD: 30,
  JACCARD_MIN_LONG: 0.5,
  SEGMENT_DEDUP_WINDOW_MS: 1_000,
  HYDRATION_RETRY_DELAYS: [0, 400, 1200, 2600, 5000, 8000, 12000],
  TURN_TIME_WINDOW_S: 30,
} as const;

let activeThresholds = DEFAULT_THRESHOLDS;
export function getThresholds() { return activeThresholds; }

// 测试期 override
export function setThresholdsForTest(overrides: Partial<typeof DEFAULT_THRESHOLDS>) {
  activeThresholds = { ...DEFAULT_THRESHOLDS, ...overrides };
}
export function resetThresholdsForTest() {
  activeThresholds = DEFAULT_THRESHOLDS;
}

// 当前：每次 rawEvents 变更都重建 conversationTree（O(N²)）
// 目标：useMemo + hash dependency，大 session 性能 ↑5-10x

const conversation = useMemo(
  () => buildConversation({ events: rawEvents, ledger: messageLedger }),
  [hashEvents(rawEvents), hashLedger(messageLedger), optimisticMessages.length],
);