/**
 * Bug reproduction: `incrementCompactionCount` and `updateSessionStoreEntry`
 * (via default `mergeSessionEntry`) advance `updatedAt` past reset boundaries,
 * causing `evaluateSessionFreshness` to misjudge stale sessions as fresh.
 *
 * ## Root cause
 *
 * `runMemoryFlushIfNeeded` runs as a synthetic agent turn via
 * `runEmbeddedPiAgent` — it does NOT go through `initSessionState`.
 * However, two post-flush storage writes advance `updatedAt`:
 *
 * 1. `incrementCompactionCount` (session-updates.ts) explicitly writes
 *    `updatedAt: now` in the patch.
 * 2. `updateSessionStoreEntry` (store.ts) merges flush metadata
 *    ({memoryFlushAt, memoryFlushCompactionCount}) via `mergeSessionEntry`,
 *    whose default strategy `resolveMergedUpdatedAt` returns
 *    `Math.max(existingUpdatedAt, patchUpdatedAt, now)` — always advancing
 *    `updatedAt` to `now` even when the patch does not include it.
 *
 * When the real user message subsequently arrives and `initSessionState`
 * re-evaluates freshness via `evaluateSessionFreshness`:
 *
 * - **Daily mode**: `sessionStartedAt` falls back to `updatedAt` for legacy
 *   entries lacking `sessionStartedAt`. After the flush advanced `updatedAt`
 *   past the boundary, `sessionStartedAt` resolves to the fresh timestamp →
 *   session judged as "started after the boundary" → no reset.
 *
 * - **Idle mode**: For legacy entries lacking both `lastInteractionAt` and
 *   `sessionStartedAt`, the fallback chain
 *   `lastInteractionAt ?? sessionStartedAt ?? updatedAt` ultimately picks up
 *   the advanced `updatedAt` → idle timer appears to have been reset recently
 *   → session judged fresh → no reset.
 *
 * ## Scenario timeline (daily reset, atHour=4)
 *
 * ```
 * 2026-04-27 21:16  Last real user message (updatedAt written)
 *                   (overnight, 04:00 boundary passes)
 * 2026-04-28 08:28  incrementCompactionCount → updatedAt = 08:28
 *                   updateSessionStoreEntry({memoryFlushAt}) → mergeSessionEntry
 *                     → updatedAt = max(08:28, now) = 08:28
 * 2026-04-28 08:29  Real user message arrives
 *                   evaluateSessionFreshness():
 *                     sessionStartedAt fallback = updatedAt = 08:28
 *                     dailyResetAt = 04:00 on 2026-04-28
 *                     staleDaily = sessionStartedAt(08:28) < dailyResetAt(04:00) → false
 *                     → fresh = true → NO RESET (BUG)
 * ```
 *
 * ## Existing precedent for the fix
 *
 * `mergeSessionEntryPreserveActivity` (types.ts:466) and `updateLastRoute`
 * (store.ts:819) already use "preserve-activity" merge policy with the comment:
 * "Route updates must not refresh activity timestamps; idle/daily reset
 * evaluation relies on updatedAt from actual session turns (#49515)."
 *
 * The same pattern should apply to compaction/flush metadata writes.
 */

import fs from "node:fs/promises";
import path from "node:path";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import type { OpenClawConfig } from "../../config/config.js";
import { loadSessionStore, saveSessionStore } from "../../config/sessions/store.js";
import type { SessionEntry } from "../../config/sessions/types.js";
import type { MsgContext } from "../templating.js";
import { initSessionState } from "./session.js";

vi.mock("../../plugin-sdk/browser-maintenance.js", () => ({
  closeTrackedBrowserTabsForSessions: vi.fn(async () => 0),
}));

describe("initSessionState — compaction/flush updatedAt advancement should not prevent daily/idle reset", () => {
  let tempDir: string;
  let storePath: string;

  beforeEach(async () => {
    tempDir = await fs.mkdtemp("/tmp/openclaw-test-compaction-race-");
    storePath = path.join(tempDir, "sessions.json");
  });

  afterEach(async () => {
    await fs.rm(tempDir, { recursive: true, force: true });
  });

  const SESSION_KEY = "main:user123";

  const createConfig = (resetOverride?: OpenClawConfig["session"]): OpenClawConfig => ({
    agents: {
      defaults: { workspace: tempDir },
      list: [{ id: "main", workspace: tempDir }],
    },
    session: {
      store: storePath,
      reset: { mode: "daily", atHour: 4 },
      ...resetOverride,
    },
    channels: {},
    gateway: {
      port: 18789,
      mode: "local",
      bind: "loopback",
      auth: { mode: "token", token: "test" },
    },
    plugins: { entries: {} },
  });

  const createCtx = (overrides?: Partial<MsgContext>): MsgContext => ({
    Body: "test message",
    From: "user123",
    To: "bot123",
    SessionKey: SESSION_KEY,
    Provider: "quietchat",
    Surface: "quietchat",
    ChatType: "direct",
    CommandAuthorized: true,
    ...overrides,
  });

  const saveSession = (
    sessionId: string,
    overrides: Partial<SessionEntry> = {},
  ): Promise<void> =>
    saveSessionStore(storePath, {
      [SESSION_KEY]: {
        sessionId,
        updatedAt: Date.now(),
        systemSent: true,
        ...overrides,
      },
    });

  // Scenario A: Daily reset — legacy entry without sessionStartedAt
  describe("daily reset mode — legacy entry without sessionStartedAt", () => {
    it("should reset the session even when compaction advanced updatedAt past the daily boundary", async () => {
      const now = Date.now();
      const todayAtHour4 = new Date(now);
      todayAtHour4.setHours(4, 0, 0, 0);

      const boundaryMs = now >= todayAtHour4.getTime()
        ? todayAtHour4.getTime()
        : todayAtHour4.getTime() - 24 * 3600_000;

      const compactionWriteAt = boundaryMs + 4 * 3600_000;

      await saveSession("legacy-daily-session-abc", {
        updatedAt: compactionWriteAt,
      });

      const cfg = createConfig({ reset: { mode: "daily", atHour: 4 } });

      const result = await initSessionState({
        ctx: createCtx({ Body: "good morning" }),
        cfg,
        commandAuthorized: true,
      });

      // BUG: updatedAt was advanced past boundary by compaction →
      // sessionStartedAt fallback = updatedAt → session judged fresh → no reset.
      expect(result.isNewSession).toBe(true);
      expect(result.sessionId).not.toBe("legacy-daily-session-abc");
    });
  });

  // Scenario B: Daily reset — entry WITH sessionStartedAt (control, passes)
  describe("daily reset mode — entry with proper sessionStartedAt (control)", () => {
    it("resets correctly because sessionStartedAt is preserved despite compaction advancing updatedAt", async () => {
      const now = Date.now();
      const todayAtHour4 = new Date(now);
      todayAtHour4.setHours(4, 0, 0, 0);
      const boundaryMs = now >= todayAtHour4.getTime()
        ? todayAtHour4.getTime()
        : todayAtHour4.getTime() - 24 * 3600_000;

      const sessionStartedYesterday = boundaryMs - 15 * 3600_000;
      const compactionWriteAt = boundaryMs + 4 * 3600_000;

      await saveSession("proper-daily-session-def", {
        updatedAt: compactionWriteAt,
        sessionStartedAt: sessionStartedYesterday,
        lastInteractionAt: sessionStartedYesterday,
      });

      const cfg = createConfig({ reset: { mode: "daily", atHour: 4 } });

      const result = await initSessionState({
        ctx: createCtx({ Body: "good morning" }),
        cfg,
        commandAuthorized: true,
      });

      expect(result.isNewSession).toBe(true);
      expect(result.sessionId).not.toBe("proper-daily-session-def");
    });
  });

  // Scenario C: Idle reset — legacy entry lacking lastInteractionAt
  describe("idle reset mode — legacy entry without lastInteractionAt", () => {
    it("should reset an idle session even when flush metadata writes advanced updatedAt", async () => {
      const now = Date.now();
      const idleMinutes = 5;
      const lastRealInteraction = now - 10 * 60_000;
      const flushMetadataWriteAt = now - 30_000;

      await saveSession("idle-legacy-ghi", {
        updatedAt: flushMetadataWriteAt,
        // no sessionStartedAt, no lastInteractionAt — legacy
        // fallback chain: lastInteractionAt ?? sessionStartedAt ?? updatedAt
        // → updatedAt = 30s ago → idle = 30s < 5min → fresh
      });

      const cfg = createConfig({ reset: { mode: "idle", idleMinutes } });

      const result = await initSessionState({
        ctx: createCtx({ Body: "hello again" }),
        cfg,
        commandAuthorized: true,
      });

      // BUG: updatedAt advanced by flush metadata write (30s ago).
      // Fallback chain picks it up as lastInteractionAt → idle appears fresh.
      expect(result.isNewSession).toBe(true);
      expect(result.sessionId).not.toBe("idle-legacy-ghi");
    });

    it("resets correctly when lastInteractionAt is present and reflects real user activity (control)", async () => {
      const now = Date.now();
      const idleMinutes = 5;
      const lastRealInteraction = now - 10 * 60_000;
      const flushMetadataWriteAt = now - 30_000;

      await saveSession("idle-proper-jkl", {
        updatedAt: flushMetadataWriteAt,
        sessionStartedAt: lastRealInteraction - 3600_000,
        lastInteractionAt: lastRealInteraction,
      });

      const cfg = createConfig({ reset: { mode: "idle", idleMinutes } });

      const result = await initSessionState({
        ctx: createCtx({ Body: "hello again" }),
        cfg,
        commandAuthorized: true,
      });

      expect(result.isNewSession).toBe(true);
      expect(result.sessionId).not.toBe("idle-proper-jkl");
    });
  });

  // Scenario D: Heartbeat correctly preserves idle expiry (control, passes)
  describe("heartbeat correctly preserves idle expiry (control)", () => {
    it("heartbeat does NOT update lastInteractionAt, idle reset still fires", async () => {
      const now = Date.now();
      const staleTime = now - 10 * 60_000;

      await saveSession("heartbeat-control-mno", {
        updatedAt: staleTime,
        sessionStartedAt: staleTime - 3600_000,
        lastInteractionAt: staleTime,
      });

      const cfg = createConfig({ reset: { mode: "idle", idleMinutes: 5 } });

      const heartbeatResult = await initSessionState({
        ctx: createCtx({ Provider: "heartbeat", Body: "HEARTBEAT_OK" }),
        cfg,
        commandAuthorized: true,
      });

      expect(heartbeatResult.isNewSession).toBe(false);
      expect(heartbeatResult.sessionEntry.lastInteractionAt).toBe(staleTime);

      const storeAfterHeartbeat = loadSessionStore(storePath);
      expect(storeAfterHeartbeat[SESSION_KEY]?.lastInteractionAt).toBe(staleTime);

      const userResult = await initSessionState({
        ctx: createCtx({ Provider: "quietchat", Body: "hello" }),
        cfg,
        commandAuthorized: true,
      });

      expect(userResult.isNewSession).toBe(true);
      expect(userResult.sessionId).not.toBe("heartbeat-control-mno");
    });
  });

  // Scenario E: Daily reset — incrementCompactionCount explicitly advances updatedAt
  describe("daily reset — incrementCompactionCount explicitly advances updatedAt", () => {
    it("should reset legacy session even after compaction wrote updatedAt past the boundary", async () => {
      const now = Date.now();
      const todayAtHour4 = new Date(now);
      todayAtHour4.setHours(4, 0, 0, 0);
      const boundaryMs = now >= todayAtHour4.getTime()
        ? todayAtHour4.getTime()
        : todayAtHour4.getTime() - 24 * 3600_000;

      const postBoundaryCompactionTime = boundaryMs + 3 * 3600_000;

      await saveSession("compaction-daily-stu", {
        updatedAt: postBoundaryCompactionTime,
        compactionCount: 3,
      });

      const cfg = createConfig({ reset: { mode: "daily", atHour: 4 } });

      const result = await initSessionState({
        ctx: createCtx({ Body: "good morning" }),
        cfg,
        commandAuthorized: true,
      });

      // BUG: updatedAt = postBoundaryCompactionTime → sessionStartedAt fallback
      // = postBoundaryCompactionTime > dailyResetAt → fresh → no reset.
      expect(result.isNewSession).toBe(true);
      expect(result.sessionId).not.toBe("compaction-daily-stu");
    });
  });
});

 ❯ session.compaction-daily-reset-race.bug.test.ts (6 tests | 3 failed) 207ms
       × should reset the session even when compaction advanced updatedAt past the daily boundary
       × should reset an idle session even when flush metadata writes advanced updatedAt
       × should reset legacy session even after compaction wrote updatedAt past the boundary
       ✓ resets correctly because sessionStartedAt is preserved despite compaction advancing updatedAt
       ✓ resets correctly when lastInteractionAt is present and reflects real user activity (control)
       ✓ heartbeat does NOT update lastInteractionAt, idle reset still fires