// Repro: /stats session double-count after first-ever /stats + /clear (or exit)
// See PR #4779 review by @wenshao and issue #4987-follow-up
//
// Run from repo root with:
//   QWEN_HOME=/tmp/qwen-stats-repro.EVVw5S/.qwen node /tmp/qwen-stats-repro.EVVw5S/repro.mjs

import fs from 'node:fs';
import path from 'node:path';
import {
  loadUsageHistory,
  aggregateUsage,
  persistSessionUsage,
} from '/Users/ben/workspace/qwen-code/packages/core/dist/index.js';

const QWEN_HOME = process.env.QWEN_HOME;
if (!QWEN_HOME) throw new Error('Set QWEN_HOME first');

const usagePath = path.join(QWEN_HOME, 'usage_record.jsonl');
const projDir = path.join(QWEN_HOME, 'projects', 'repro-project');
const chatsDir = path.join(projDir, 'chats');
fs.mkdirSync(chatsDir, { recursive: true });

const SESSION_ID = 'repro-session-aaaa-bbbb-cccc';
const START = new Date('2026-06-11T00:00:00Z').toISOString();
const MID = new Date('2026-06-11T00:01:00Z').toISOString();
const END = new Date('2026-06-11T00:02:00Z').toISOString();

const baseCwd = '/repro/project';
const baseRecord = {
  sessionId: SESSION_ID,
  cwd: baseCwd,
  uuid: 'u1',
  parentUuid: null,
};

// First record (user msg) — establishes sessionId / cwd / startTime
const recUser = {
  ...baseRecord,
  timestamp: START,
  type: 'user',
  message: { role: 'user', content: 'hello' },
};
// A UI telemetry event (api_response) — this is what rebuildFromSessionJsonl needs to count the session as having events
const recTelemetry = {
  ...baseRecord,
  uuid: 'u2',
  parentUuid: 'u1',
  timestamp: MID,
  type: 'system',
  subtype: 'ui_telemetry',
  systemPayload: {
    uiEvent: {
      'event.name': 'qwen-code.api_response',
      'event.timestamp': MID,
      response_id: 'r1',
      model: 'qwen-max',
      duration_ms: 1200,
      input_token_count: 1000,
      output_token_count: 500,
      cached_content_token_count: 200,
      thoughts_token_count: 100,
      total_token_count: 1600,
      prompt_id: 'p1',
    },
  },
};
const recLast = {
  ...baseRecord,
  uuid: 'u3',
  parentUuid: 'u2',
  timestamp: END,
  type: 'assistant',
  message: { role: 'assistant', content: 'world' },
};

const chatJsonl = [recUser, recTelemetry, recLast]
  .map((r) => JSON.stringify(r))
  .join('\n') + '\n';
fs.writeFileSync(path.join(chatsDir, `${SESSION_ID}.jsonl`), chatJsonl);

console.log(`\n=== Step 0: fresh state ===`);
console.log(`usage_record.jsonl exists? ${fs.existsSync(usagePath)}`);

console.log(`\n=== Step 1: open /stats (first time) — triggers loadUsageHistory -> rebuildFromSessionJsonl ===`);
const first = await loadUsageHistory();
console.log(`records returned by loadUsageHistory: ${first.length}`);
console.log(`usage_record.jsonl exists? ${fs.existsSync(usagePath)}`);
const fileLines1 = fs.readFileSync(usagePath, 'utf8').trim().split('\n').filter(Boolean);
console.log(`lines in usage_record.jsonl: ${fileLines1.length}`);
console.log(
  `sessionIds in file: ${fileLines1.map((l) => JSON.parse(l).sessionId).join(', ')}`,
);

console.log(`\n=== Step 2: simulate /clear or session-exit — persistSessionUsage for SAME sessionId ===`);
persistSessionUsage({
  sessionId: SESSION_ID,
  startTime: new Date(START),
  endTime: new Date(END),
  project: baseCwd,
  metrics: {
    models: {
      'qwen-max': {
        api: { totalRequests: 1, totalErrors: 0, totalLatencyMs: 1200 },
        tokens: { prompt: 1000, candidates: 500, total: 1600, cached: 200, thoughts: 100 },
        bySource: {},
      },
    },
    tools: { totalCalls: 0, totalSuccess: 0, totalFail: 0, totalDurationMs: 0, totalDecisions: {}, byName: {} },
    files: { totalLinesAdded: 0, totalLinesRemoved: 0 },
  },
});
const fileLines2 = fs.readFileSync(usagePath, 'utf8').trim().split('\n').filter(Boolean);
console.log(`lines in usage_record.jsonl: ${fileLines2.length}`);
console.log(
  `sessionIds in file: ${fileLines2.map((l) => JSON.parse(l).sessionId).join(', ')}`,
);

console.log(`\n=== Step 3: re-open /stats — aggregate persisted records ===`);
const second = await loadUsageHistory();
console.log(`records returned by loadUsageHistory: ${second.length}`);

const report = aggregateUsage(second, 'all');
console.log(`\naggregateUsage('all') report:`);
console.log(`  sessionCount = ${report.sessionCount}   (expected: 1, since only ONE logical session existed)`);
let totalTokens = 0;
for (const m of Object.values(report.models)) totalTokens += m.totalTokens;
console.log(`  totalTokens  = ${totalTokens}   (expected: 1600 from the single ~1.6k session)`);

console.log(`\n=== Verdict ===`);
if (report.sessionCount === 2 && totalTokens === 3200) {
  console.log(`🐛 BUG CONFIRMED: session double-counted (sessions=${report.sessionCount}, tokens=${totalTokens})`);
  process.exit(1);
} else if (report.sessionCount === 1) {
  console.log(`✅ no double count`);
  process.exit(0);
} else {
  console.log(`⚠️ unexpected result: sessions=${report.sessionCount}, tokens=${totalTokens}`);
  process.exit(2);
}