import assert from 'node:assert/strict';
import {
  buildNpcInteractionMessages, fallbackNpcPlan, townDate, WorldNpcPlanner,
} from '../src/business/world_npc/world_npc.planner';
import { WorldNpcService } from '../src/business/world_npc/world_npc.service';
import { WorldNpcConversationEvent, WorldNpcDailyPlan } from '../src/business/world_npc/world_npc.types';
import {
  findWorldRoute, getWorldLocation, isWorldNpcPublicMap, WORLD_LOCATIONS,
  WORLD_NPC_PUBLIC_MAP_IDS, WORLD_ROUTE_EDGES,
} from '../src/business/world_npc/world_npc.world';
import { WorldNpcClock } from '../src/business/world_npc/world_npc.clock';
import { WORLD_NPC_DEFINITIONS } from '../src/business/world_npc/world_npc.registry';

async function main(): Promise<void> {
  process.env.WORLD_NPC_PERSISTENCE = 'off';
  const dialogueMessages = buildNpcInteractionMessages({
    definition: {
      npcId: 'npc_whale_researcher', name: '鲸小研', role: '科研观察员', personality: '友善、好奇',
      dailyFocus: '收集科研兴趣', homeLocationId: 'square_dock_research', scene: 'classic_whale',
    },
    activity: {
      id: 'square_interviews', title: '广场访谈', intention: '收集科研话题', locationId: 'square_forum',
      startMinute: 540, endMinute: 660, activityKind: 'socialize', dialogue: '你最近在研究什么？',
    },
    dailyGoal: '整理居民的科研问题', username: '测试居民', residentSummary: '居民对海洋科学感兴趣',
    sessionTurns: [
      { role: 'user', content: '你还记得我刚才说的方向吗？', createdAt: 1 },
      { role: 'assistant', content: '记得，你想先看海流数据。', createdAt: 2 },
    ],
    message: '那我们继续吧。',
  });
  assert.deepEqual(dialogueMessages.map((message) => message.role),
    ['system', 'user', 'assistant', 'user'],
    'short-term NPC conversation must use normal multi-turn chat roles');
  assert.match(String(dialogueMessages[0].content), /当前每日目标/);
  assert.match(String(dialogueMessages[0].content), /海洋科学/);
  assert.match(String(dialogueMessages[0].content), /Agent 工具 query_npc_memory/);
  assert.equal(dialogueMessages.at(-1)?.content, '那我们继续吧。');
  const realPlanner = new WorldNpcPlanner();
  const planningDefinition = {
    npcId: 'npc_whale_researcher', name: '鲸小研', role: '科研观察员', personality: '友善、好奇',
    dailyFocus: '长期跟进小镇的科研需求', homeLocationId: 'square_dock_research', scene: 'classic_whale' as const,
  };
  const planningSystemPrompt = (realPlanner as any).systemPrompt(planningDefinition, {
    previousDailyPlan: fallbackNpcPlan(planningDefinition, Date.parse('2026-08-27T12:00:00+08:00')),
    npcMemories: [], residentNeedSummaries: ['居民希望今天有一场海洋科学分享'], activeResidentSignals: [],
  });
  assert.match(planningSystemPrompt, /角色长期记忆/);
  assert.match(planningSystemPrompt, /长期跟进小镇的科研需求/);
  assert.match(planningSystemPrompt, /海洋科学分享/);
  assert.match(planningSystemPrompt, /locationName/);
  assert.doesNotMatch(planningSystemPrompt, /locationId/);
  const modelPlan = (realPlanner as any).validatePlan({
    goal: '在广场整理居民的科研问题',
    activities: [{
      id: 'forum_research', title: '广场科研交流', intention: '收集科研问题',
      locationName: '广场交流区', startMinute: 0, endMinute: 1440,
      activityKind: 'socialize', dialogue: '今天想和大家聊聊最近关心的科研问题。',
    }],
  }, '2026-08-29');
  assert.equal(modelPlan.activities[0].locationId, 'square_forum');
  assert.throws(() => (realPlanner as any).validatePlan({
    goal: '错误示例',
    activities: [{
      id: 'internal_id', title: '错误地点', intention: '测试内部 ID',
      locationId: 'square_forum', startMinute: 0, endMinute: 1440,
      activityKind: 'socialize', dialogue: '这条计划不应该通过校验。',
    }],
  }, '2026-08-29'), /invalid enum/);
  let previousPlanDateSeenByPlanner = '';
  const crossDayPlanner = {
    createDailyPlan: async (definition: any, context: any, planNow: number) => {
      if (definition.npcId === 'npc_whale_researcher') {
        previousPlanDateSeenByPlanner = String(context.previousDailyPlan?.date || '');
      }
      return fallbackNpcPlan(definition, planNow);
    },
  } as WorldNpcPlanner;
  const crossDayService = new WorldNpcService(crossDayPlanner);
  const previousDayNow = Date.parse('2026-08-28T12:00:00+08:00');
  const nextDayNow = Date.parse('2026-08-29T00:01:00+08:00');
  crossDayService.replacePlanForTesting(fallbackNpcPlan(planningDefinition, previousDayNow));
  await crossDayService.tick(nextDayNow);
  assert.equal(previousPlanDateSeenByPlanner, '2026-08-28',
    'the completed daily plan must become long-term planning memory after midnight');
  const planner = {
    createDailyPlan: async (definition: any, _memories: unknown, planNow: number) => fallbackNpcPlan(definition, planNow),
    createInteractionReply: async () => '这个问题很有意思，我已经记进今天的研究笔记了。',
  } as WorldNpcPlanner;
  const service = new WorldNpcService(planner);
  const now = Date.now();
  const plan: WorldNpcDailyPlan = {
    date: townDate(now), goal: '去咖啡馆收集研究问题', source: 'agent',
    activities: [{
      id: 'cafe_visit', title: '咖啡馆访谈', intention: '前往咖啡馆访谈',
      locationId: 'cafe_research_table', startMinute: 0, endMinute: 1440,
      activityKind: 'socialize', dialogue: '你最近在研究什么？',
    }],
  };
  service.replacePlanForTesting(plan);
  for (const edge of WORLD_ROUTE_EDGES) {
    const from = getWorldLocation(edge.from);
    const to = getWorldLocation(edge.to);
    assert(from.x !== to.x || from.y !== to.y || from.mapId !== to.mapId, `zero-length edge: ${edge.from}`);
    assert.equal(edge.kind === 'transition', from.mapId !== to.mapId, `edge/map mismatch: ${edge.from} -> ${edge.to}`);
  }
  for (const location of WORLD_LOCATIONS) {
    assert(isWorldNpcPublicMap(location.mapId), `private map exposed to NPC planner: ${location.mapId}`);
    assert(findWorldRoute(WORLD_LOCATIONS[0].id, location.id).length > 0, `disconnected location: ${location.id}`);
    if (!location.tags.includes('transit')) {
      const movableDefinitions = WORLD_NPC_DEFINITIONS.filter((definition) => !definition.stationary);
      assert((location.slots?.length || 0) >= movableDefinitions.length,
        `activity location must have one slot per movable NPC: ${location.id}`);
      const slotKeys = new Set(location.slots!.map((slot) => `${slot.x}:${slot.y}`));
      assert.equal(slotKeys.size, location.slots!.length,
        `activity location contains duplicate NPC slots: ${location.id}`);
      const assignedPoints = movableDefinitions.map((definition) =>
        (service as any).locationPointForNpc(definition.npcId, location.id) as { x: number; y: number });
      assert.equal(new Set(assignedPoints.map((point) => `${point.x}:${point.y}`)).size,
        movableDefinitions.length, `NPC slot assignment reuses a position: ${location.id}`);
      for (let first = 0; first < location.slots!.length; first += 1) {
        for (let second = first + 1; second < location.slots!.length; second += 1) {
          assert(Math.hypot(
            location.slots![first].x - location.slots![second].x,
            location.slots![first].y - location.slots![second].y,
          ) >= 80, `activity location slots are too close: ${location.id}`);
        }
      }
    }
  }
  assert(!WORLD_NPC_PUBLIC_MAP_IDS.includes('personal_space' as any), 'personal rooms must not be in the NPC world');
  assert.equal(service.getMapSnapshot('personal_space', now).npcs.length, 0,
    'personal rooms must never receive world NPC snapshots');
  const cafeRoute = findWorldRoute('square_dock_research', 'cafe_research_table');
  assert.equal(cafeRoute[0], 'square_dock_research');
  assert.equal(cafeRoute[cafeRoute.length - 1], 'cafe_research_table');
  assert(cafeRoute.includes('square_work_gate') && cafeRoute.includes('work_square_gate'));
  assert(cafeRoute.includes('work_cafe_gate') && cafeRoute.includes('cafe_entrance'));

  let clock = now;
  let previousLocation = 'square_dock_research';
  let sawTransition = false;
  for (let step = 0; step < 24; step += 1) {
    await service.tick(clock);
    const active = service.getRuntimeForTesting().activeAction;
    assert(active, 'runtime must always have a route or activity action');
    assert.equal(active.fromLocationId, previousLocation, 'each action must start at the previous destination');
    sawTransition ||= active.kind === 'transition';
    clock = active.completesAt + 1;
    await service.tick(clock);
    previousLocation = service.getRuntimeForTesting().locationId;
    if (previousLocation === 'cafe_research_table') break;
  }
  const runtime = service.getRuntimeForTesting();
  assert.equal(runtime.locationId, 'cafe_research_table');
  assert.equal(runtime.mapId, 'whale_cafe');
  assert(sawTransition);
  assert(!service.getMapSnapshot('whale_port', clock).npcs.some((npc) => npc.npcId === 'npc_whale_researcher'));
  assert.equal(service.getMapSnapshot('whale_cafe', clock).npcs.find((npc) =>
    npc.npcId === 'npc_whale_researcher')?.state, 'talking');

  await assert.rejects(() => service.interact({
    npcId: 'npc_whale_researcher', userId: 'far-user', username: '远处玩家',
    mapId: 'whale_cafe', x: 1_000, y: 1_000, message: '听得到吗？', now: clock,
  }), /距离NPC太远/);
  const interaction = await service.interact({
    npcId: 'npc_whale_researcher', userId: 'near-user', username: '测试居民',
    mapId: 'whale_cafe', x: -200, y: 300, message: '今天研究什么？', now: clock,
  });
  assert.equal(interaction.response, '这个问题很有意思，我已经记进今天的研究笔记了。');
  assert.equal(service.getTownStatus(clock).npcs.find((npc) =>
    npc.definition.npcId === 'npc_whale_researcher')?.memoryCount, 1);
  assert.equal(service.getTownStatus(clock).npcs.length, WORLD_NPC_DEFINITIONS.length);

  const replanNow = Date.parse('2026-08-28T10:00:00+08:00');
  const initialReplanPlan = fallbackNpcPlan({
    npcId: 'npc_whale_researcher',
    name: '鲸小研',
    role: '科研交流员',
    personality: '好奇、耐心',
    dailyFocus: '收集科研兴趣',
    homeLocationId: 'square_dock_research',
    scene: 'classic_whale',
  }, replanNow);
  let revisionMemoryCount = 0;
  const replanningPlanner = {
    createDailyPlan: async () => initialReplanPlan,
    createInteractionReply: async () => '我会把这个需求放进今天后续的安排。',
    reviseRemainingPlan: async (_definition: unknown, current: WorldNpcDailyPlan, context: any) => {
      revisionMemoryCount = context.npcMemories.length + context.residentNeedSummaries.length
        + context.activeResidentSignals.length;
      return {
        ...current,
        goal: '根据居民需求调整今天剩余的科研交流',
        source: 'agent' as const,
        revisionReason: 'interaction' as const,
        generatedAt: replanNow,
        activities: current.activities.map((activity) => activity.id === 'evening_share'
          ? { ...activity, locationId: 'square_forum', intention: '回应居民提出的新需求' }
          : activity),
      };
    },
  } as unknown as WorldNpcPlanner;
  const replanningService = new WorldNpcService(replanningPlanner);
  replanningService.replacePlanForTesting(initialReplanPlan);
  await replanningService.tick(replanNow);
  let routeAction = replanningService.getRuntimeForTesting().activeAction;
  assert(routeAction && routeAction.kind === 'walk');
  let replanClock = routeAction.completesAt + 1;
  while (routeAction && routeAction.kind !== 'perform') {
    await replanningService.tick(replanClock);
    routeAction = replanningService.getRuntimeForTesting().activeAction;
    if (routeAction && routeAction.kind !== 'perform') replanClock = routeAction.completesAt + 1;
  }
  assert.equal(replanningService.getRuntimeForTesting().locationId, 'square_forum');
  const activityBeforeRevision = replanningService.getRuntimeForTesting().activeAction;
  assert.equal(activityBeforeRevision?.kind, 'perform');
  assert.equal(activityBeforeRevision?.completesAt, Date.parse('2026-08-28T11:00:00+08:00'),
    'activity end must stay anchored to the daily schedule after travel');
  process.env.WORLD_NPC_REPLAN_COOLDOWN_MS = '0';
  const replanSnapshot = replanningService.getMapSnapshot('whale_port', replanClock).npcs.find((npc) =>
    npc.npcId === 'npc_whale_researcher')!;
  await replanningService.interact({
    npcId: 'npc_whale_researcher', userId: 'replan-user', username: '提出需求的居民',
    mapId: 'whale_port', x: replanSnapshot.x, y: replanSnapshot.y, message: '傍晚可以在广场回应这个问题吗？',
    now: replanClock,
  });
  await new Promise<void>((resolve) => setImmediate(resolve));
  const revisedRuntime = replanningService.getRuntimeForTesting();
  assert.equal(revisionMemoryCount, 1);
  assert.equal(revisedRuntime.plan.revisionReason, 'interaction');
  assert.equal(revisedRuntime.plan.goal, '根据居民需求调整今天剩余的科研交流');
  assert.equal(revisedRuntime.activeAction?.actionId, activityBeforeRevision?.actionId,
    'replanning must not interrupt the current activity');
  assert.equal(revisedRuntime.plan.activities.find((activity) => activity.id === 'evening_share')?.locationId,
    'square_forum');
  delete process.env.WORLD_NPC_REPLAN_COOLDOWN_MS;

  const persistedAction = routeAction!;
  const persistedRuntime = replanningService.getRuntimeForTesting();
  persistedRuntime.locationId = persistedAction.fromLocationId;
  persistedRuntime.mapId = persistedAction.fromMapId;
  persistedRuntime.x = persistedAction.fromX;
  persistedRuntime.y = persistedAction.fromY;
  persistedRuntime.activityId = persistedAction.activityId;
  persistedRuntime.activeAction = persistedAction;
  const normalizeRuntime = (replanningService as any).normalizeRuntime.bind(replanningService);
  const restored = normalizeRuntime(
    replanningService.getTownStatus(replanNow).npcs.find((npc) => npc.definition.npcId === 'npc_whale_researcher')!.definition,
    persistedRuntime,
    persistedAction.startedAt + 1,
  );
  assert.equal(restored.activeAction?.actionId, persistedAction.actionId,
    'a running persisted route must survive a server restart');
  const completedOnRestart = normalizeRuntime(
    replanningService.getTownStatus(replanNow).npcs.find((npc) => npc.definition.npcId === 'npc_whale_researcher')!.definition,
    persistedRuntime,
    persistedAction.completesAt + 1,
  );
  assert.equal(completedOnRestart.locationId, persistedAction.toLocationId,
    'an expired persisted route must recover at its destination');

  const dayStart = Date.parse('2026-08-28T00:00:00+08:00');
  for (const npcId of ['npc_whale_researcher']) {
    const dayService = new WorldNpcService(planner);
    const definition = dayService.getTownStatus(dayStart).npcs.find((npc) => npc.definition.npcId === npcId)!.definition;
    const dayPlan = fallbackNpcPlan(definition, dayStart);
    dayService.replacePlanForTesting(dayPlan, npcId);
    for (const scheduledActivity of dayPlan.activities) {
      let activityClock = dayStart + scheduledActivity.startMinute * 60_000;
      let reachedActivity = false;
      for (let actionStep = 0; actionStep < 20; actionStep += 1) {
        await dayService.tick(activityClock);
        const active = dayService.getRuntimeForTesting(npcId).activeAction;
        assert(active, `${npcId}/${scheduledActivity.id} must have an active action`);
        if (active.kind === 'perform' && active.activityId === scheduledActivity.id) {
          reachedActivity = true;
          break;
        }
        activityClock = active.completesAt + 1;
      }
      const arrived = dayService.getRuntimeForTesting(npcId);
      assert(reachedActivity, `${npcId}/${scheduledActivity.id} did not reach its activity`);
      assert.equal(arrived.locationId, scheduledActivity.locationId,
        `${npcId}/${scheduledActivity.id} arrived at the wrong semantic location`);
      assert.equal(arrived.mapId, getWorldLocation(scheduledActivity.locationId).mapId,
        `${npcId}/${scheduledActivity.id} arrived on the wrong map`);
    }
  }

  for (const [npcId, expected] of [
    ['npc_town_mayor', { locationId: 'square_guild_reception', x: -199, y: -515 }],
    ['npc_dock_guide', { locationId: 'square_dock_guide', x: -825, y: 437 }],
  ] as const) {
    const stationaryService = new WorldNpcService(planner);
    const definition = stationaryService.getTownStatus(dayStart).npcs.find((npc) => npc.definition.npcId === npcId)!.definition;
    stationaryService.replacePlanForTesting(fallbackNpcPlan(definition, dayStart), npcId);
    for (const minute of [0, 600, 1200]) {
      await stationaryService.tick(dayStart + minute * 60_000);
      const runtime = stationaryService.getRuntimeForTesting(npcId);
      assert.equal(runtime.locationId, expected.locationId);
      assert.deepEqual({ x: runtime.x, y: runtime.y }, { x: expected.x, y: expected.y });
      assert.equal(runtime.activeAction?.kind, 'perform');
      assert.equal(runtime.activeAction?.fromLocationId, expected.locationId);
      assert.equal(runtime.activeAction?.toLocationId, expected.locationId);
      assert.equal(stationaryService.getMapSnapshot('whale_port', dayStart + minute * 60_000)
        .npcs.find((npc) => npc.npcId === npcId)?.movementState, 'idle');
    }
  }

  let socialPlannerCalls = 0;
  const socialPlanner = {
    createDailyPlan: async (definition: any, _memories: unknown, planNow: number) => fallbackNpcPlan(definition, planNow),
    createInteractionReply: async () => '',
    createNpcConversation: async (input: any) => {
      socialPlannerCalls += 1;
      return [
        { speakerNpcId: input.first.npcId, speakerName: input.first.name, text: '我收集到一个值得继续研究的问题。' },
        { speakerNpcId: input.second.npcId, speakerName: input.second.name, text: '我会把它带到今天的居民交流里。' },
      ];
    },
  } as WorldNpcPlanner;
  const socialService = new WorldNpcService(socialPlanner);
  const socialDate = townDate(replanNow);
  const atForum = (id: string): WorldNpcDailyPlan => ({
    date: socialDate,
    goal: '在广场交换今天的信息',
    source: 'agent',
    activities: [{
      id, title: '广场交流', intention: '与其他小镇成员交换信息',
      locationId: 'square_forum', startMinute: 0, endMinute: 1440,
      activityKind: 'socialize', dialogue: '今天有什么新消息？',
    }],
  });
  const atReception = (id: string): WorldNpcDailyPlan => ({
    date: socialDate,
    goal: '在公会接待处交换今天的信息',
    source: 'agent',
    activities: [{
      id, title: '接待处交流', intention: '与到访居民交换信息',
      locationId: 'square_guild_reception', startMinute: 0, endMinute: 1440,
      activityKind: 'socialize', dialogue: '今天有什么新消息？',
    }],
  });
  socialService.replacePlanForTesting(atReception('researcher_social'), 'npc_whale_researcher');
  socialService.replacePlanForTesting(atReception('mayor_social'), 'npc_town_mayor');
  const nonSocialPlan = (id: string, locationId: string): WorldNpcDailyPlan => ({
    date: socialDate,
    goal: '独立完成今天的工作',
    source: 'agent',
    activities: [{
      id, title: '独立工作', intention: '完成自己的日常工作', locationId,
      startMinute: 0, endMinute: 1440, activityKind: 'organize', dialogue: '我正在整理今天的工作。',
    }],
  });
  socialService.replacePlanForTesting(nonSocialPlan('guide_work', 'square_dock_guide'), 'npc_dock_guide');
  socialService.replacePlanForTesting(nonSocialPlan('niulai_work', 'square_dock_research'), 'npc_niulai');
  let socialClock = replanNow;
  const socialConversations: WorldNpcConversationEvent[] = [];
  for (let step = 0; step < 12; step += 1) {
    const tickResult = await socialService.tick(socialClock);
    socialConversations.push(...tickResult.conversations);
    const participants = ['npc_whale_researcher', 'npc_town_mayor']
      .map((npcId) => socialService.getRuntimeForTesting(npcId));
    if (participants.every((runtime) => runtime.locationId === 'square_guild_reception'
      && runtime.activeAction?.kind === 'perform')) break;
    const completionTimes = participants
      .map((runtime) => runtime.activeAction?.completesAt)
      .filter((value): value is number => typeof value === 'number' && value > socialClock);
    assert(completionTimes.length > 0, 'social participants stopped before reaching the forum');
    socialClock = Math.min(...completionTimes) + 1;
  }
  await new Promise<void>((resolve) => setImmediate(resolve));
  const socialTick = await socialService.tick(socialClock);
  socialConversations.push(...socialTick.conversations);
  assert.equal(socialPlannerCalls, 1, 'one co-located NPC pair should create one encounter');
  assert.equal(socialConversations.length, 1);
  assert.deepEqual(socialConversations[0].participantNpcIds,
    ['npc_town_mayor', 'npc_whale_researcher']);
  assert.equal(socialService.getTownStatus(socialClock).npcs.find((npc) =>
    npc.definition.npcId === 'npc_whale_researcher')?.recentNpcEncounters.length, 1);
  const socialPositions = ['npc_whale_researcher', 'npc_town_mayor']
    .map((npcId) => socialService.getMapSnapshot('whale_port', socialClock).npcs.find((npc) => npc.npcId === npcId)!);
  assert.notDeepEqual(
    { x: socialPositions[0].x, y: socialPositions[0].y },
    { x: socialPositions[1].x, y: socialPositions[1].y },
    'co-located NPCs must use distinct visual slots',
  );
  assert(Math.hypot(socialPositions[0].x - socialPositions[1].x,
    socialPositions[0].y - socialPositions[1].y) <= 160,
  'conversation slots must remain visually close');
  await new Promise<void>((resolve) => setImmediate(resolve));
  const duplicateSocialTick = await socialService.tick(socialClock + 1);
  assert.equal(duplicateSocialTick.conversations.length, 0, 'the same encounter must not repeat');
  assert.equal(socialPlannerCalls, 1);

  process.env.WORLD_NPC_TIME_SCALE = '60';
  const worldClock = new WorldNpcClock();
  const realAnchor = Date.now();
  const acceleratedDelta = worldClock.now(realAnchor + 1_000) - worldClock.now(realAnchor);
  assert.equal(acceleratedDelta, 60_000);
  worldClock.setForTesting(Date.parse('2026-08-28T10:00:00+08:00'));
  assert.equal(worldClock.now(), Date.parse('2026-08-28T10:00:00+08:00'));
  console.log('WORLD_NPC_RUNTIME_OK');
}

void main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});