import { resolveCustomWorldRoleIdReference } from '../services/customWorldRoleReferences';
import {
  canUseLimitedPrimaryNpcChat,
  resolveActiveSceneActEncounterFocusNpcId,
  resolveActiveSceneActEncounterNpcIds,
} from '../services/customWorldSceneActRuntime';
import {
  AnimationState,
  Encounter,
  GameState,
  SceneHostileNpc,
  SceneNpc,
  WorldType,
} from '../types';
import { getRecruitedNpcIds } from './companionRoster';
import {
  createSceneHostileNpcsFromEncounters,
  createSceneHostileNpcsFromIds,
  getFacingTowardPlayer,
  getMonsterGroupAnchorX,
  pickEncounterMonsterIds,
  PLAYER_BASE_X_METERS,
} from './hostileNpcs';
import { buildInitialNpcState, createNpcBattleMonster } from './npcInteractions';
import {
  buildEncounterFromSceneNpc,
  getSceneFriendlyNpcs,
  getSceneHostileNpcs,
  getWorldCampScenePreset,
} from './scenePresets';

export const EXPLORE_APPROACH_DURATION_MS = 4000;
export const PREVIEW_ENTITY_X_METERS = 12;
export const RESOLVED_ENTITY_X_METERS = 3.2;
export const CALL_OUT_ENTRY_X_METERS = 18;
export const TREASURE_ENCOUNTERS_ENABLED = false;
const SCENE_ACT_BACK_ROW_BATTLE_X_METERS = Number(
  (RESOLVED_ENTITY_X_METERS + 1.08).toFixed(2),
);
const SCENE_ACT_BACK_ROW_BATTLE_Y_OFFSETS = [62, -46] as const;

function isNpcBattleAlignmentDebugEnabled() {
  if (typeof window === 'undefined') {
    return false;
  }

  return (
    window.localStorage.getItem('rpg:npc-battle-alignment-debug') === '1' ||
    window.location.search.includes('npcBattleAlignmentDebug=1')
  );
}

function logNpcBattleFormation(
  label: string,
  monsters: Array<Pick<SceneHostileNpc, 'id' | 'xMeters' | 'yOffset' | 'encounter'>>,
) {
  if (!isNpcBattleAlignmentDebugEnabled()) {
    return;
  }

  console.info(
    `[npc-battle-formation] ${label}`,
    monsters.map((monster) => ({
      id: monster.id,
      encounterId: monster.encounter?.id ?? null,
      encounterName: monster.encounter?.npcName ?? null,
      xMeters: monster.xMeters,
      yOffset: monster.yOffset,
    })),
  );
}

function getNpcEncounterKey(encounter: Encounter) {
  return encounter.id ?? encounter.npcName;
}

function getResolvedNpcState(state: GameState, encounter: Encounter) {
  return state.npcStates[getNpcEncounterKey(encounter)] ?? buildInitialNpcState(encounter, state.worldType, state);
}

function shouldAutoStartBattleForEncounter(state: GameState, encounter: Encounter) {
  if (encounter.kind !== 'npc') return false;
  const npcState = getResolvedNpcState(state, encounter);
  const npcId = getNpcEncounterKey(encounter);
  if (
    canUseLimitedPrimaryNpcChat({
      profile: state.customWorldProfile,
      sceneId: state.currentScenePreset?.id ?? null,
      storyEngineMemory: state.storyEngineMemory,
      npcId,
      affinity: npcState.affinity,
    })
  ) {
    return false;
  }
  return npcState.affinity < 0 || (npcState.relationState?.affinity ?? npcState.affinity) < 0;
}

function resolveSceneActEncounterMembers(
  state: GameState,
  encounter: Encounter,
) {
  const currentSceneNpcs = state.currentScenePreset?.npcs ?? [];
  if (currentSceneNpcs.length === 0) {
    return [];
  }

  const activeActNpcIds = resolveActiveSceneActEncounterNpcIds({
    profile: state.customWorldProfile,
    sceneId: state.currentScenePreset?.id ?? null,
    storyEngineMemory: state.storyEngineMemory,
  });
  if (activeActNpcIds.length <= 1) {
    return [];
  }

  const seenNpcIds = new Set<string>();

  return currentSceneNpcs
    .filter((candidate) => {
      const candidateIds = [
        candidate.id,
        candidate.characterId,
        candidate.name,
        candidate.title,
      ]
        .map((value) =>
          resolveCustomWorldRoleIdReference(state.customWorldProfile, value),
        )
        .filter(Boolean);

      return candidateIds.some((candidateId) => activeActNpcIds.includes(candidateId));
    })
    .filter((npc): npc is SceneNpc => Boolean(npc))
    .filter((npc) => {
      if (seenNpcIds.has(npc.id)) {
        return false;
      }
      seenNpcIds.add(npc.id);
      return true;
    })
    .slice(0, 3);
}

function getSceneActBattleSlots(primaryX: number) {
  return [
    {
      xMeters: primaryX,
      yOffset: 0,
    },
    {
      xMeters: SCENE_ACT_BACK_ROW_BATTLE_X_METERS,
      yOffset: SCENE_ACT_BACK_ROW_BATTLE_Y_OFFSETS[0],
    },
    {
      xMeters: SCENE_ACT_BACK_ROW_BATTLE_X_METERS,
      yOffset: SCENE_ACT_BACK_ROW_BATTLE_Y_OFFSETS[1],
    },
  ] satisfies Array<Pick<SceneHostileNpc, 'xMeters' | 'yOffset'>>;
}

export function buildNpcBattleFormationFromEncounter(params: {
  state: GameState;
  encounter: Encounter;
  mode?: 'fight' | 'spar';
}) {
  const { state, encounter, mode = 'fight' } = params;
  const sceneActMembers = resolveSceneActEncounterMembers(state, encounter);
  const primaryX =
    sceneActMembers.length > 1
      ? RESOLVED_ENTITY_X_METERS
      : encounter.xMeters ?? RESOLVED_ENTITY_X_METERS;
  const formationSourceEncounters =
    sceneActMembers.length > 1
      ? sceneActMembers.map((member, index) =>
          buildEncounterFromSceneNpc(
            member,
            index === 0 ? primaryX : SCENE_ACT_BACK_ROW_BATTLE_X_METERS,
          ),
        )
      : [encounter];
  const slots = getSceneActBattleSlots(primaryX);

  const resolvedFormation = formationSourceEncounters.map((memberEncounter, index) => {
    const slot = slots[index] ?? slots[slots.length - 1] ?? {
      xMeters: primaryX,
      yOffset: 0,
    };
    const npcState = getResolvedNpcState(state, memberEncounter);
    const battleMonster = createNpcBattleMonster(
      memberEncounter,
      npcState,
      mode,
      {
        worldType: state.worldType,
        customWorldProfile: state.customWorldProfile,
      },
    );

    return {
      ...battleMonster,
      xMeters: slot.xMeters,
      yOffset: slot.yOffset,
      facing: getFacingTowardPlayer(slot.xMeters, PLAYER_BASE_X_METERS),
      encounter: battleMonster.encounter
        ? {
            ...battleMonster.encounter,
            xMeters: slot.xMeters,
          }
        : battleMonster.encounter,
    } satisfies SceneHostileNpc;
  });

  logNpcBattleFormation(
    `buildNpcBattleFormationFromEncounter:${encounter.id ?? encounter.npcName}`,
    resolvedFormation,
  );

  return resolvedFormation;
}

function buildResolvedNpcBattleState(state: GameState, encounter: Encounter) {
  const battleNpcId = getNpcEncounterKey(encounter);

  return {
    ...state,
    // 中文注释：幕预览和正式运行都统一走这一套 NPC 战斗编队生成，
    // 避免开战时把同幕后排角色压缩成单体，导致阵容缺失和站位突变。
    sceneHostileNpcs: buildNpcBattleFormationFromEncounter({
      state,
      encounter,
      mode: 'fight',
    }),
    currentEncounter: null,
    npcInteractionActive: false,
    playerX: 0,
    playerFacing: 'right' as const,
    animationState: AnimationState.IDLE,
    playerActionMode: 'idle' as const,
    activeCombatEffects: [],
    scrollWorld: false,
    inBattle: true,
    currentBattleNpcId: battleNpcId,
    currentNpcBattleMode: 'fight' as const,
    currentNpcBattleOutcome: null,
    // 中文注释：NPC 开战后要保留战前原始遭遇，供战斗收尾时恢复和平态站位。
    // 这里复用现有 sparReturnEncounter 存槽，避免战后误把 battle encounter 的临时坐标带回场景。
    sparReturnEncounter: encounter,
    sparPlayerHpBefore: null,
    sparPlayerMaxHpBefore: null,
    sparStoryHistoryBefore: null,
  };
}

function pickRandomItem<T>(items: T[]) {
  if (items.length === 0) return null;
  return items[Math.floor(Math.random() * items.length)] ?? null;
}

function createTreasureEncounter(state: GameState, treasureHint: string): Encounter {
  return {
    id: `treasure-${state.currentScenePreset?.id ?? 'unknown'}`,
    kind: 'treasure',
    npcName: '宝藏',
    npcDescription: `你发现了与${treasureHint}相关的线索，看起来像是有人故意藏起的宝物。`,
    npcAvatar: '/Icons/47_treasure.png',
    context: 'treasure',
    xMeters: PREVIEW_ENTITY_X_METERS,
  };
}

function getAvailableFriendlySceneNpcs(state: GameState) {
  const recruitedNpcIds = getRecruitedNpcIds(state);
  const isCampScene = Boolean(
    state.worldType
    && state.currentScenePreset?.id
    && getWorldCampScenePreset(state.worldType)?.id === state.currentScenePreset.id,
  );
  const activeActNpcIds = resolveActiveSceneActEncounterNpcIds({
    profile: state.customWorldProfile,
    sceneId: state.currentScenePreset?.id ?? null,
    storyEngineMemory: state.storyEngineMemory,
  });
  const activeActNpcIdSet = new Set(activeActNpcIds);

  return getSceneFriendlyNpcs(state.currentScenePreset)
    .filter(candidate =>
      !isCampScene ||
      Boolean(candidate.characterId) ||
      activeActNpcIdSet.has(candidate.id),
    )
    .filter(candidate => candidate.characterId !== state.playerCharacter?.id)
    .filter(candidate => !recruitedNpcIds.has(candidate.id))
    .filter(candidate =>
      activeActNpcIdSet.size === 0
        ? true
        : activeActNpcIdSet.has(candidate.id)
          || (candidate.characterId ? activeActNpcIdSet.has(candidate.characterId) : false),
    );
}

function getAvailableActiveSceneActNpcs(state: GameState) {
  const recruitedNpcIds = getRecruitedNpcIds(state);
  const activeActNpcIds = resolveActiveSceneActEncounterNpcIds({
    profile: state.customWorldProfile,
    sceneId: state.currentScenePreset?.id ?? null,
    storyEngineMemory: state.storyEngineMemory,
  });
  const activeActNpcIdSet = new Set(activeActNpcIds);
  if (activeActNpcIdSet.size === 0) {
    return [];
  }

  return (state.currentScenePreset?.npcs ?? [])
    .filter(candidate => {
      const candidateIds = [
        candidate.id,
        candidate.characterId,
        candidate.name,
        candidate.title,
      ]
        .map((value) =>
          resolveCustomWorldRoleIdReference(state.customWorldProfile, value),
        )
        .filter(Boolean);
      return candidateIds.some(id => activeActNpcIdSet.has(id));
    })
    .filter(candidate => candidate.characterId !== state.playerCharacter?.id)
    .filter(candidate => !recruitedNpcIds.has(candidate.id));
}

function getAvailableHostileSceneNpcs(state: GameState) {
  const recruitedNpcIds = getRecruitedNpcIds(state);

  return getSceneHostileNpcs(state.currentScenePreset)
    .filter(candidate => !recruitedNpcIds.has(candidate.id))
    .filter((candidate): candidate is SceneNpc & { monsterPresetId: string } => Boolean(candidate.monsterPresetId));
}

function pickEncounterHostileNpcs(hostileNpcs: Array<SceneNpc & { monsterPresetId: string }>) {
  const selectedMonsterIds = new Set(
    pickEncounterMonsterIds(hostileNpcs.map(npc => npc.monsterPresetId)),
  );

  return hostileNpcs.filter(npc => selectedMonsterIds.has(npc.monsterPresetId));
}

function pickFriendlySceneNpcForActiveAct(state: GameState, npcs: SceneNpc[]) {
  const focusNpcId = resolveActiveSceneActEncounterFocusNpcId({
    profile: state.customWorldProfile,
    sceneId: state.currentScenePreset?.id ?? null,
    storyEngineMemory: state.storyEngineMemory,
  });

  return (
    npcs.find(
      (npc) =>
        resolveCustomWorldRoleIdReference(state.customWorldProfile, npc.id) === focusNpcId ||
        resolveCustomWorldRoleIdReference(
          state.customWorldProfile,
          npc.characterId,
        ) === focusNpcId ||
        resolveCustomWorldRoleIdReference(
          state.customWorldProfile,
          npc.name,
        ) === focusNpcId ||
        resolveCustomWorldRoleIdReference(
          state.customWorldProfile,
          npc.title,
        ) === focusNpcId,
    ) ?? pickRandomItem(npcs)
  );
}

function hasActiveSceneActEncounterTarget(state: GameState) {
  return resolveActiveSceneActEncounterNpcIds({
    profile: state.customWorldProfile,
    sceneId: state.currentScenePreset?.id ?? null,
    storyEngineMemory: state.storyEngineMemory,
  }).length > 0;
}

function buildEmptyEncounterPreview() {
  return {
    sceneHostileNpcs: [],
    currentEncounter: null,
    npcInteractionActive: false,
    inBattle: false,
  };
}

function buildActiveSceneActNpcEncounter(
  state: GameState,
  availableNpcs: SceneNpc[],
  xMeters: number,
) {
  const npc = pickFriendlySceneNpcForActiveAct(state, availableNpcs);

  return {
    sceneHostileNpcs: [],
    currentEncounter: npc ? buildFriendlyEncounter(npc, xMeters) : null,
    npcInteractionActive: false,
    inBattle: false,
  };
}

function buildHostileEncounterGroup(
  state: GameState,
  entryX: number,
  animation: 'idle' | 'move',
) {
  if (!state.worldType || !state.currentScenePreset) return [];

  const selectedHostiles = pickEncounterHostileNpcs(getAvailableHostileSceneNpcs(state));
  const hostileEncounters = selectedHostiles.map(npc => buildEncounterFromSceneNpc(npc));
  const hostileMonsters = createSceneHostileNpcsFromEncounters(
    state.worldType,
    hostileEncounters,
    PLAYER_BASE_X_METERS,
  );
  const anchorX = getMonsterGroupAnchorX(hostileMonsters);

  return hostileMonsters.map(monster => {
    const xMeters = Number((entryX + (monster.xMeters - anchorX)).toFixed(2));
    return {
      ...monster,
      xMeters,
      facing: getFacingTowardPlayer(xMeters, PLAYER_BASE_X_METERS),
      animation,
      encounter: monster.encounter
        ? {
            ...monster.encounter,
            xMeters,
          }
        : monster.encounter,
    };
  });
}

function buildFriendlyEncounter(npc: SceneNpc, xMeters: number) {
  return {
    ...buildEncounterFromSceneNpc(npc, xMeters),
    xMeters,
  } satisfies Encounter;
}

function buildResolvedHostileBattleState(state: GameState, hostileEncounters: Encounter[]) {
  if (!state.worldType) return state;

  const resolvedMonsters = createSceneHostileNpcsFromEncounters(
    state.worldType,
    hostileEncounters,
    PLAYER_BASE_X_METERS,
  ).map(monster => ({
    ...monster,
    animation: 'idle' as const,
    facing: getFacingTowardPlayer(monster.xMeters, PLAYER_BASE_X_METERS),
    encounter: monster.encounter
      ? {
          ...monster.encounter,
          xMeters: monster.xMeters,
        }
      : monster.encounter,
  }));

  return {
    ...state,
    sceneHostileNpcs: resolvedMonsters,
    currentEncounter: null,
    npcInteractionActive: false,
    playerX: 0,
    playerFacing: 'right' as const,
    animationState: AnimationState.IDLE,
    playerActionMode: 'idle' as const,
    activeCombatEffects: [],
    scrollWorld: false,
    inBattle: true,
  };
}

export function createSceneEncounterPreview(state: GameState) {
  if (!state.worldType || !state.currentScenePreset) {
    return buildEmptyEncounterPreview();
  }

  if (hasActiveSceneActEncounterTarget(state)) {
    return buildActiveSceneActNpcEncounter(
      state,
      getAvailableActiveSceneActNpcs(state),
      PREVIEW_ENTITY_X_METERS,
    );
  }

  const availableNpcs = getAvailableFriendlySceneNpcs(state);
  const availableHostiles = getAvailableHostileSceneNpcs(state);
  const availableKinds: Array<'hostile' | 'npc' | 'treasure'> = [];
  if (availableHostiles.length > 0) availableKinds.push('hostile');
  if (availableNpcs.length > 0) availableKinds.push('npc');
  if (TREASURE_ENCOUNTERS_ENABLED && (state.currentScenePreset.treasureHints?.length ?? 0) > 0) {
    availableKinds.push('treasure');
  }

  const kind = pickRandomItem(availableKinds);
  if (!kind) {
    return buildEmptyEncounterPreview();
  }

  if (kind === 'hostile') {
    return {
      sceneHostileNpcs: buildHostileEncounterGroup(state, PREVIEW_ENTITY_X_METERS, 'idle'),
      currentEncounter: null,
      npcInteractionActive: false,
      inBattle: false,
    };
  }

  if (kind === 'npc') {
    const npc = pickFriendlySceneNpcForActiveAct(state, availableNpcs);

    return {
      sceneHostileNpcs: [],
      currentEncounter: npc ? buildFriendlyEncounter(npc, PREVIEW_ENTITY_X_METERS) : null,
      npcInteractionActive: false,
      inBattle: false,
    };
  }

  const treasureHint = pickRandomItem(state.currentScenePreset.treasureHints ?? []);
  return {
    sceneHostileNpcs: [],
    currentEncounter: treasureHint ? createTreasureEncounter(state, treasureHint) : null,
    npcInteractionActive: false,
    inBattle: false,
  };
}

export function createSceneCallOutEncounter(state: GameState) {
  if (!state.worldType || !state.currentScenePreset) {
    return buildEmptyEncounterPreview();
  }

  if (hasActiveSceneActEncounterTarget(state)) {
    return buildActiveSceneActNpcEncounter(
      state,
      getAvailableActiveSceneActNpcs(state),
      CALL_OUT_ENTRY_X_METERS,
    );
  }

  const availableNpcs = getAvailableFriendlySceneNpcs(state);
  const availableKinds: Array<'hostile' | 'npc' | 'treasure'> = [];
  const availableHostiles = getAvailableHostileSceneNpcs(state);
  if (availableHostiles.length > 0) availableKinds.push('hostile');

  if (availableNpcs.length > 0) availableKinds.push('npc');
  if (TREASURE_ENCOUNTERS_ENABLED && (state.currentScenePreset.treasureHints?.length ?? 0) > 0) {
    availableKinds.push('treasure');
  }

  const kind = pickRandomItem(availableKinds);
  if (kind === 'hostile') {
    return {
      sceneHostileNpcs: buildHostileEncounterGroup(state, CALL_OUT_ENTRY_X_METERS, 'move'),
      currentEncounter: null,
      npcInteractionActive: false,
      inBattle: false,
    };
  }

  if (kind === 'npc') {
    const npc = pickFriendlySceneNpcForActiveAct(state, availableNpcs);
    return {
      sceneHostileNpcs: [],
      currentEncounter: npc ? buildFriendlyEncounter(npc, CALL_OUT_ENTRY_X_METERS) : null,
      npcInteractionActive: false,
      inBattle: false,
    };
  }

  if (kind === 'treasure') {
    const treasureHint = pickRandomItem(state.currentScenePreset.treasureHints ?? []);
    return {
      sceneHostileNpcs: [],
      currentEncounter: treasureHint
        ? {
            ...createTreasureEncounter(state, treasureHint),
            xMeters: CALL_OUT_ENTRY_X_METERS,
          }
        : null,
      npcInteractionActive: false,
      inBattle: false,
    };
  }

  return {
    sceneHostileNpcs: [],
    currentEncounter: null,
    npcInteractionActive: false,
    inBattle: false,
  };
}

export function ensureSceneEncounterPreview(state: GameState): GameState {
  if (
    state.inBattle ||
    state.sceneHostileNpcs.length > 0 ||
    state.currentEncounter ||
    !state.currentScenePreset ||
    !state.worldType
  ) {
    return state;
  }

  return {
    ...state,
    ...createSceneEncounterPreview(state),
    playerX: 0,
    playerFacing: 'right' as const,
    animationState: AnimationState.IDLE,
    playerActionMode: 'idle' as const,
    activeCombatEffects: [],
    scrollWorld: false,
  };
}

export function hasAutoBattleSceneEncounter(state: GameState) {
  if (!state.currentScenePreset || !state.worldType || state.inBattle) {
    return false;
  }

  if (state.sceneHostileNpcs.length > 0) {
    return state.sceneHostileNpcs.some(monster => Boolean(monster.encounter?.monsterPresetId));
  }

  return state.currentEncounter?.kind === 'npc'
    ? shouldAutoStartBattleForEncounter(state, state.currentEncounter)
    : false;
}

export function resolveSceneEncounterPreview(state: GameState): GameState {
  if (!state.currentScenePreset || !state.worldType) {
    return state;
  }

  const previewState =
    state.sceneHostileNpcs.length > 0 || state.currentEncounter
      ? state
      : ensureSceneEncounterPreview(state);

  if (previewState.sceneHostileNpcs.length > 0) {
    const hostileEncounters = previewState.sceneHostileNpcs
      .map(monster => monster.encounter)
      .filter((encounter): encounter is Encounter => Boolean(encounter?.monsterPresetId));

    if (hostileEncounters.length > 0) {
      return buildResolvedHostileBattleState(previewState, hostileEncounters);
    }

    const resolvedMonsters = createSceneHostileNpcsFromIds(
      previewState.worldType ?? WorldType.WUXIA,
      previewState.sceneHostileNpcs.map(monster => monster.id),
      PLAYER_BASE_X_METERS,
    ).map(monster => ({
      ...monster,
      animation: 'idle' as const,
      facing: getFacingTowardPlayer(monster.xMeters, PLAYER_BASE_X_METERS),
    }));

    return {
      ...previewState,
      sceneHostileNpcs: resolvedMonsters,
      currentEncounter: null,
      npcInteractionActive: false,
      playerX: 0,
      playerFacing: 'right' as const,
      animationState: AnimationState.IDLE,
      playerActionMode: 'idle' as const,
      activeCombatEffects: [],
      scrollWorld: false,
      inBattle: true,
    };
  }

  if (
    previewState.currentEncounter?.kind === 'npc'
    && shouldAutoStartBattleForEncounter(previewState, previewState.currentEncounter)
  ) {
    return buildResolvedNpcBattleState(previewState, previewState.currentEncounter);
  }

  if (previewState.currentEncounter) {
    return {
      ...previewState,
      currentEncounter: {
        ...previewState.currentEncounter,
        xMeters: RESOLVED_ENTITY_X_METERS,
      },
      npcInteractionActive: false,
      sceneHostileNpcs: [],
      playerX: 0,
      playerFacing: 'right' as const,
      animationState: AnimationState.IDLE,
      playerActionMode: 'idle' as const,
      activeCombatEffects: [],
      scrollWorld: false,
      inBattle: false,
    };
  }

  return previewState;
}

export function getPreviewEntityX(state: GameState) {
  return state.sceneHostileNpcs.length > 0
    ? getMonsterGroupAnchorX(state.sceneHostileNpcs)
    : state.currentEncounter?.xMeters ?? PREVIEW_ENTITY_X_METERS;
}