import { mkdtemp, rm } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'pathe';

import { afterEach, beforeEach, describe, expect, it } from 'vitest';

import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
import type { ContextMessage } from '#/agent/contextMemory/types';
import { IAgentLoopService } from '#/agent/loop/loop';
import { IAgentProfileService } from '#/agent/profile/profile';
import { IAgentConversationUndoService } from '#/agent/undo/undo';
import { DEFAULT_AGENT_PROFILE_NAME } from '#/app/agentProfileCatalog/agentProfileCatalog';
import {
  AgentDateChangeService,
  IAgentDateChangeService,
} from '#/features/dateChange/dateChangeService';
import { IHostClock } from '#/os/interface/hostClock';
import { ISessionContext } from '#/session/sessionContext/sessionContext';

import {
  appService,
  createTestAgent,
  hostEnvironmentServices,
  InMemoryWireRecordPersistence,
  type TestAgentContext,
} from '../../harness';
import { runWillBeginStepHooks } from '../../agent/loop/stubs';

const TEST_TIME_ZONE = 'Asia/Shanghai';
const INITIAL_INSTANT = '2026-07-29T04:00:00.000Z';

interface TestHostClock extends IHostClock {
  set(iso: string): void;
}

function testHostClock(initialIso: string): TestHostClock {
  let current = new Date(initialIso);
  return {
    _serviceBrand: undefined,
    now: () => new Date(current),
    timeZone: () => TEST_TIME_ZONE,
    set: (iso) => {
      current = new Date(iso);
    },
  };
}

function systemPromptWithDate(iso: string): string {
  return [
    'You are a deterministic test agent.',
    '',
    `The current date and time in ISO format is \`${iso}\`. This was captured when the session started and does not update.`,
  ].join('\n');
}

function updateSystemPrompt(profile: IAgentProfileService, systemPrompt: string, cwd: string): void {
  profile.update({
    systemPrompt,
    environmentDisclosure: { cwd },
  });
}

function dateReminders(context: IAgentContextMemoryService): readonly ContextMessage[] {
  return context.get().filter((message) => {
    return message.origin?.kind === 'injection' && message.origin.variant === 'date_change';
  });
}

function messageText(message: ContextMessage): string {
  return message.content
    .map((part) => (part.type === 'text' ? part.text : ''))
    .join('');
}

describe('AgentDateChangeService', () => {
  let ctx: TestAgentContext;
  let context: IAgentContextMemoryService;
  let clock: TestHostClock;
  let loop: IAgentLoopService;
  let profile: IAgentProfileService;

  beforeEach(async () => {
    clock = testHostClock(INITIAL_INSTANT);
    ctx = createTestAgent({ autoConfigure: false }, appService(IHostClock, clock));
    context = ctx.get(IAgentContextMemoryService);
    loop = ctx.get(IAgentLoopService);
    profile = ctx.get(IAgentProfileService);
    await ctx.restorePersisted();
    ctx.configure();
  });

  afterEach(async () => {
    try {
      await ctx.expectResumeMatches();
    } finally {
      await ctx.dispose();
    }
  });

  it('injects on the first step even when the system prompt text states today\'s date', async () => {
    updateSystemPrompt(profile, systemPromptWithDate(INITIAL_INSTANT), ctx.get(ISessionContext).cwd);

    await runWillBeginStepHooks(loop);

    const reminders = dateReminders(context);
    expect(reminders).toHaveLength(1);
    expect(messageText(reminders[0] as ContextMessage)).toContain('2026-07-29');
  });

  it('discloses the current date and stays quiet when the system prompt text is stale', async () => {
    updateSystemPrompt(
      profile,
      systemPromptWithDate('2026-07-28T04:00:00.000Z'),
      ctx.get(ISessionContext).cwd,
    );

    await runWillBeginStepHooks(loop);

    const reminders = dateReminders(context);
    expect(reminders).toHaveLength(1);
    const first = reminders[0];
    expect(first).toBeDefined();
    const text = messageText(first as ContextMessage);
    expect(text).toContain("Today's date is 2026-07-29");
    expect(first?.origin).toMatchObject({
      kind: 'injection',
      variant: 'date_change',
      disclosure: {
        kind: 'date',
        renderGeneration: 2,
        localDate: '2026-07-29',
        timeZone: TEST_TIME_ZONE,
      },
    });

    await runWillBeginStepHooks(loop);
    expect(dateReminders(context)).toHaveLength(1);
  });

  it('announces each date crossed by a long-lived session', async () => {
    updateSystemPrompt(profile, systemPromptWithDate(INITIAL_INSTANT), ctx.get(ISessionContext).cwd);
    await runWillBeginStepHooks(loop);

    clock.set('2026-07-30T04:00:00.000Z');
    await runWillBeginStepHooks(loop);

    let reminders = dateReminders(context);
    expect(reminders).toHaveLength(2);
    expect(messageText(reminders[1] as ContextMessage)).toContain('2026-07-30');

    clock.set('2026-07-31T04:00:00.000Z');
    await runWillBeginStepHooks(loop);

    reminders = dateReminders(context);
    expect(reminders).toHaveLength(3);
    expect(messageText(reminders[2] as ContextMessage)).toContain('2026-07-31');
    expect(reminders[2]?.origin).toMatchObject({
      disclosure: {
        kind: 'date',
        renderGeneration: 2,
        localDate: '2026-07-31',
      },
    });
  });

  it('injects on the first step when a persisted prompt crosses midnight before resume', async () => {
    const persistence = new InMemoryWireRecordPersistence();
    await ctx.dispose();
    ctx = createTestAgent({ persistence }, appService(IHostClock, clock));
    profile = ctx.get(IAgentProfileService);
    updateSystemPrompt(profile, systemPromptWithDate(INITIAL_INSTANT), ctx.get(ISessionContext).cwd);
    await ctx.wire.flush();
    await ctx.dispose();

    clock.set('2026-07-30T04:00:00.000Z');
    ctx = createTestAgent(
      { autoConfigure: false, persistence },
      appService(IHostClock, clock),
    );
    context = ctx.get(IAgentContextMemoryService);
    loop = ctx.get(IAgentLoopService);
    await ctx.restorePersisted();

    await runWillBeginStepHooks(loop);

    const reminders = dateReminders(context);
    expect(reminders).toHaveLength(1);
    expect(messageText(reminders[0] as ContextMessage)).toContain('2026-07-30');
  });

  it('discloses the current date after resuming a legacy profile without disclosure metadata', async () => {
    const persistence = new InMemoryWireRecordPersistence();
    await ctx.dispose();
    ctx = createTestAgent({ persistence }, appService(IHostClock, clock));
    profile = ctx.get(IAgentProfileService);
    profile.applyBindingSnapshot({
      modelAlias: 'mock-model',
      profileName: 'agent',
      thinkingLevel: 'off',
      systemPrompt: systemPromptWithDate(INITIAL_INSTANT),
      disallowedTools: [],
    });
    await ctx.wire.flush();
    const legacyBind = persistence.records.find((record) => record.type === 'profile.bind');
    expect(legacyBind?.['environmentDisclosure']).toBeUndefined();
    await ctx.dispose();

    clock.set('2026-07-30T04:00:00.000Z');
    ctx = createTestAgent(
      { autoConfigure: false, persistence },
      appService(IHostClock, clock),
    );
    context = ctx.get(IAgentContextMemoryService);
    loop = ctx.get(IAgentLoopService);
    await ctx.restorePersisted();

    await runWillBeginStepHooks(loop);
    const initial = dateReminders(context);
    expect(initial).toHaveLength(1);
    expect(messageText(initial[0] as ContextMessage)).toContain('2026-07-30');

    clock.set('2026-07-31T04:00:00.000Z');
    await runWillBeginStepHooks(loop);
    const reminders = dateReminders(context);
    expect(reminders).toHaveLength(2);
    expect(messageText(reminders[1] as ContextMessage)).toContain('2026-07-31');
  });

  it('announces a crossed midnight through a real bind rendered from the host clock', async () => {
    const homeDir = await mkdtemp(join(tmpdir(), 'kimi-date-bind-home-'));
    try {
      await ctx.dispose();
      ctx = createTestAgent(appService(IHostClock, clock), hostEnvironmentServices(homeDir));
      context = ctx.get(IAgentContextMemoryService);
      loop = ctx.get(IAgentLoopService);
      profile = ctx.get(IAgentProfileService);
        await ctx.restorePersisted();

      await profile.bind({ profile: DEFAULT_AGENT_PROFILE_NAME, model: 'mock-model' });

      await runWillBeginStepHooks(loop);
      const initial = dateReminders(context);
      expect(initial).toHaveLength(1);
      expect(messageText(initial[0] as ContextMessage)).toContain('2026-07-29');

      clock.set('2026-07-30T04:00:00.000Z');
      await runWillBeginStepHooks(loop);

      const reminders = dateReminders(context);
      expect(reminders).toHaveLength(2);
      expect(messageText(reminders[1] as ContextMessage)).toContain('2026-07-30');
    } finally {
      await rm(homeDir, { recursive: true, force: true });
    }
  });

  it('keeps the newer render-generation disclosure when an older metadata reminder appears later', async () => {
    updateSystemPrompt(
      profile,
      'You are a deterministic test agent.',
      ctx.get(ISessionContext).cwd,
    );

    await runWillBeginStepHooks(loop);
    expect(dateReminders(context)).toHaveLength(1);

    context.append({
      role: 'user',
      content: [{ type: 'text', text: 'older metadata reminder' }],
      toolCalls: [],
      origin: {
        kind: 'injection',
        variant: 'date_change',
        disclosure: {
          kind: 'date',
          renderGeneration: 1,
          localDate: '2026-07-30',
          timeZone: TEST_TIME_ZONE,
        },
      },
    });

    await runWillBeginStepHooks(loop);

    expect(dateReminders(context)).toHaveLength(2);
  });

  it('keeps the structured reminder metadata exactly once across undo and the next step', async () => {
    updateSystemPrompt(
      profile,
      'You are a deterministic test agent.',
      ctx.get(ISessionContext).cwd,
    );
    context.append({
      role: 'user',
      content: [{ type: 'text', text: 'first turn' }],
      toolCalls: [],
      origin: { kind: 'user' },
    });
    await runWillBeginStepHooks(loop);
    expect(dateReminders(context)).toHaveLength(1);

    await ctx.get(IAgentConversationUndoService).undo(1);
    expect(dateReminders(context)).toHaveLength(1);
    context.append({
      role: 'user',
      content: [{ type: 'text', text: 'replacement turn' }],
      toolCalls: [],
      origin: { kind: 'user' },
    });

    await runWillBeginStepHooks(loop);

    expect(dateReminders(context)).toHaveLength(1);
  });

  it('keeps the initial date disclosure across undo and the next step', async () => {
    updateSystemPrompt(
      profile,
      'You are a deterministic test agent.',
      ctx.get(ISessionContext).cwd,
    );
    context.append({
      role: 'user',
      content: [{ type: 'text', text: 'first turn' }],
      toolCalls: [],
      origin: { kind: 'user' },
    });
    await runWillBeginStepHooks(loop);
    expect(dateReminders(context)).toHaveLength(1);

    await ctx.get(IAgentConversationUndoService).undo(1);
    expect(dateReminders(context)).toHaveLength(1);
    context.append({
      role: 'user',
      content: [{ type: 'text', text: 'replacement turn' }],
      toolCalls: [],
      origin: { kind: 'user' },
    });

    await runWillBeginStepHooks(loop);

    const reminders = dateReminders(context);
    expect(reminders).toHaveLength(1);
    expect(messageText(reminders[0] as ContextMessage)).toContain('2026-07-29');
  });

  it('discloses the current date on the first step and stays quiet', async () => {
    updateSystemPrompt(
      profile,
      'You are a deterministic test agent.',
      ctx.get(ISessionContext).cwd,
    );

    await runWillBeginStepHooks(loop);

    const reminders = dateReminders(context);
    expect(reminders).toHaveLength(1);
    expect(messageText(reminders[0] as ContextMessage)).toContain('2026-07-29');
    expect(reminders[0]?.origin).toMatchObject({
      kind: 'injection',
      variant: 'date_change',
      disclosure: {
        kind: 'date',
        renderGeneration: 2,
        localDate: '2026-07-29',
        timeZone: TEST_TIME_ZONE,
      },
    });

    await runWillBeginStepHooks(loop);
    expect(dateReminders(context)).toHaveLength(1);
  });

  it('announces a crossed midnight after the initial disclosure', async () => {
    updateSystemPrompt(
      profile,
      'You are a deterministic test agent.',
      ctx.get(ISessionContext).cwd,
    );
    await runWillBeginStepHooks(loop);
    expect(dateReminders(context)).toHaveLength(1);

    clock.set('2026-07-30T04:00:00.000Z');
    await runWillBeginStepHooks(loop);

    const reminders = dateReminders(context);
    expect(reminders).toHaveLength(2);
    expect(messageText(reminders[1] as ContextMessage)).toContain('2026-07-30');

    await runWillBeginStepHooks(loop);
    expect(dateReminders(context)).toHaveLength(2);
  });

  it('discloses then announces when the snapshot cwd is empty', async () => {
    updateSystemPrompt(profile, 'You are a deterministic test agent.', '');
    await runWillBeginStepHooks(loop);
    expect(dateReminders(context)).toHaveLength(1);

    clock.set('2026-07-30T04:00:00.000Z');
    await runWillBeginStepHooks(loop);

    const reminders = dateReminders(context);
    expect(reminders).toHaveLength(2);
    expect(messageText(reminders[1] as ContextMessage)).toContain('2026-07-30');
  });

  it('never injects when the snapshot belongs to a different cwd', async () => {
    updateSystemPrompt(profile, 'You are a deterministic test agent.', '/some/other/workspace');

    await runWillBeginStepHooks(loop);
    expect(dateReminders(context)).toHaveLength(0);

    clock.set('2026-07-30T04:00:00.000Z');
    await runWillBeginStepHooks(loop);
    expect(dateReminders(context)).toHaveLength(0);
  });

  it('keeps one provider registration across repeated restore', async () => {
    updateSystemPrompt(
      profile,
      'You are a deterministic test agent.',
      ctx.get(ISessionContext).cwd,
    );

    expect(ctx.get(IAgentDateChangeService)).toBeInstanceOf(AgentDateChangeService);
    await runWillBeginStepHooks(loop);
    expect(dateReminders(context)).toHaveLength(1);

    await ctx.restorePersisted();
    await ctx.restorePersisted();
    clock.set('2026-07-30T04:00:00.000Z');
    await runWillBeginStepHooks(loop);

    expect(dateReminders(context)).toHaveLength(2);
  });
});