import {
  Character,
  FunctionCategory,
  PlayerStateMode,
  SceneDirective,
  SceneHostileNpc,
  SkillStyle,
  StoryOption,
  WorldType,
} from '../types';
import {
  CAMP_TRAVEL_HOME_FUNCTION,
  NPC_CHAT_FUNCTION,
  NPC_PREVIEW_TALK_FUNCTION,
  NPC_RECRUIT_FUNCTION,
  STATE_FUNCTION_DEFINITIONS as SPLIT_STATE_FUNCTION_DEFINITIONS,
  STATE_FUNCTION_PROMPT_DESCRIPTIONS as SPLIT_STATE_FUNCTION_PROMPT_DESCRIPTIONS,
} from './functionCatalog';
import {
  getForwardScenePreset,
  getTravelScenePreset,
  getWorldCampScenePreset,
} from './scenePresets';
import stateFunctionOverridesJson from './stateFunctionOverrides.json';

export interface FunctionEffectConfig {
  damageMultiplier?: number;
  incomingDamageMultiplier?: number;
  healAmount?: number;
  manaRestore?: number;
  cooldownTickBonus?: number;
  turnTimeMultiplier?: number;
  skillWeights?: Partial<Record<SkillStyle, number>>;
  escapeDurationMs?: number;
  escapeDistance?: number;
  monsterLagStart?: number;
  monsterLagEnd?: number;
  sceneShift?: number;
  enterBattle?: boolean;
}

export type FunctionVisualConfig = Omit<SceneDirective, 'monsterChanges'> & {
  monsterActionTemplate?: string;
  monsterAnimation?: 'idle' | 'move' | 'attack';
  monsterMoveMeters?: number;
};

export interface StateFunctionDefinition {
  id: string;
  state: PlayerStateMode;
  category: FunctionCategory;
  text: string;
  description: string;
  visual: FunctionVisualConfig;
  effect: FunctionEffectConfig;
}

export type StateFunctionDefinitionOverride = Partial<
  Pick<StateFunctionDefinition, 'state' | 'category' | 'text' | 'description'>
> & {
  visual?: Partial<FunctionVisualConfig>;
  effect?: Partial<FunctionEffectConfig>;
};

export type StateFunctionOverrideMap = Record<
  string,
  StateFunctionDefinitionOverride
>;

export interface FunctionAvailabilityContext {
  worldType: WorldType;
  playerCharacter: Character | null;
  inBattle: boolean;
  currentSceneId?: string | null;
  currentSceneName?: string | null;
  monsters: SceneHostileNpc[];
  playerHp: number;
  playerMaxHp: number;
  playerMana: number;
  playerMaxMana: number;
}

const FUNCTION_OPTION_PRIORITIES: Record<string, number> = {
  [CAMP_TRAVEL_HOME_FUNCTION.id]: 4,
  [NPC_PREVIEW_TALK_FUNCTION.id]: 3,
  [NPC_RECRUIT_FUNCTION.id]: 3,
  [NPC_CHAT_FUNCTION.id]: 1,
};

const MODEL_PRIORITY_LOCKED_OPTION_COUNT = 2;

export function getFunctionPromptDescription(
  functionId: string,
  fallback?: string,
) {
  return (
    SPLIT_STATE_FUNCTION_PROMPT_DESCRIPTIONS[functionId] ??
    fallback ??
    functionId
  );
}

const STATE_FUNCTION_OVERRIDES =
  stateFunctionOverridesJson as StateFunctionOverrideMap;
const BASE_FUNCTIONS = [...SPLIT_STATE_FUNCTION_DEFINITIONS];

function mergeStateFunctionDefinition(
  definition: StateFunctionDefinition,
  override?: StateFunctionDefinitionOverride,
): StateFunctionDefinition {
  if (!override) {
    return {
      ...definition,
      visual: { ...definition.visual },
      effect: {
        ...definition.effect,
        skillWeights: definition.effect.skillWeights
          ? { ...definition.effect.skillWeights }
          : undefined,
      },
    };
  }

  const mergedSkillWeights = override.effect?.skillWeights
    ? {
        ...(definition.effect.skillWeights ?? {}),
        ...override.effect.skillWeights,
      }
    : definition.effect.skillWeights
      ? { ...definition.effect.skillWeights }
      : undefined;

  return {
    ...definition,
    ...override,
    visual: {
      ...definition.visual,
      ...(override.visual ?? {}),
    },
    effect: {
      ...definition.effect,
      ...(override.effect ?? {}),
      skillWeights: mergedSkillWeights,
    },
  };
}

function applyRuntimeFunctionAdjustments(
  definitions: StateFunctionDefinition[],
) {
  return definitions
    .filter((definition) => definition.id !== 'idle_follow_clue')
    .map((definition) => {
      if (definition.id === 'idle_explore_forward') {
        return {
          ...definition,
          text: '继续向前探索',
          description:
            '沿着当前场景继续深入，把前路真正探出来，下一刻就可能撞上新的危险或际遇。',
        };
      }

      if (definition.id === 'idle_call_out') {
        return {
          ...definition,
          text: '主动出声试探',
          description:
            '主动朝前方喊话试探，可能把附近潜着的角色或怪物直接从远处引出来。',
        };
      }

      return definition;
    });
}

export function buildStateFunctionDefinitions(
  overrides: StateFunctionOverrideMap = STATE_FUNCTION_OVERRIDES,
) {
  return applyRuntimeFunctionAdjustments(
    BASE_FUNCTIONS.map((definition) =>
      mergeStateFunctionDefinition(definition, overrides[definition.id]),
    ),
  );
}

const ALL_FUNCTIONS = buildStateFunctionDefinitions();

function hasAliveMonsters(monsters: SceneHostileNpc[]) {
  return monsters.some((monster) => monster.hp > 0);
}

function getPrimaryMonster(context: FunctionAvailabilityContext) {
  return (
    context.monsters.find((monster) => monster.hp > 0) ??
    context.monsters[0] ??
    null
  );
}

function getPlayerHpRatio(context: FunctionAvailabilityContext) {
  return context.playerHp / Math.max(context.playerMaxHp, 1);
}

function getPlayerManaRatio(context: FunctionAvailabilityContext) {
  return context.playerMana / Math.max(context.playerMaxMana, 1);
}

function getMonsterHpRatio(context: FunctionAvailabilityContext) {
  const monster = getPrimaryMonster(context);
  if (!monster) return 0;
  return monster.hp / Math.max(monster.maxHp, 1);
}

function buildSuggestedActionText(
  definition: StateFunctionDefinition,
  context: FunctionAvailabilityContext,
) {
  const monster = getPrimaryMonster(context);
  const monsterName = monster?.name ?? '前方怪物';
  const playerHpRatio = getPlayerHpRatio(context);
  const playerManaRatio = getPlayerManaRatio(context);
  const monsterHpRatio = getMonsterHpRatio(context);
  const forwardScene = getForwardScenePreset(
    context.worldType,
    context.currentSceneId,
  );
  const travelScene = getTravelScenePreset(
    context.worldType,
    context.currentSceneId,
  );

  const sceneName = context.currentSceneName ?? '前路';

  if (definition.id === 'idle_explore_forward') {
    if (playerHpRatio <= 0.35)
      return `按着伤口，沿着${sceneName}继续往深处摸去`;
    if (forwardScene) return `顺着${sceneName}的路势，继续朝前方深处探去`;
    return `拨开${sceneName}前的遮挡，继续朝更深处探去`;
  }

  if (definition.id === 'idle_call_out') {
    return `冲着${sceneName}前方扬声试探，看是谁先被逼出来`;
  }

  switch (definition.id) {
    case 'battle_finisher_window':
      if (monsterHpRatio <= 0.25) return `完成对${monsterName}的残血收割`;
      if (monsterHpRatio <= 0.45) return `抓住${monsterName}露出的破绽补上重击`;
      return `盯住${monsterName}的空当准备终结一击`;
    case 'battle_all_in_crush':
      if (monsterHpRatio <= 0.25) return `压上去收掉${monsterName}最后一口气`;
      if (playerHpRatio <= 0.35) return `顶着伤势强压${monsterName}赌一波强杀`;
      return `正面强压${monsterName}不给喘息`;
    case 'battle_guard_break':
      if (monsterHpRatio <= 0.35) return `砸开${monsterName}的架势直接斩落`;
      return `重击破开${monsterName}的招架`;
    case 'battle_probe_pressure':
      if (playerManaRatio <= 0.3)
        return `稳住节奏试探${monsterName}，先省下灵力`;
      if (monsterHpRatio <= 0.3) return `稳步逼近，补掉${monsterName}残余血量`;
      return `稳扎稳打继续试探${monsterName}`;
    case 'battle_feint_step':
      if (monsterHpRatio <= 0.35) return `虚晃切进去收掉${monsterName}`;
      return `借假动作切进${monsterName}身前`;
    case 'battle_recover_breath':
      if (playerHpRatio <= 0.35) return '原地打坐恢复血量';
      if (playerManaRatio <= 0.3) return '收势调息回一口灵力';
      return '边守边调息稳住节奏';
    case 'battle_escape_breakout':
      if (playerHpRatio <= 0.35) return `撑着伤势先脱离${monsterName}的追杀`;
      return `转身拉开距离，甩开${monsterName}`;
    case 'idle_explore_forward':
      if (forwardScene) return `继续向前探路`;
      if (playerHpRatio <= 0.35) return '拖着伤势继续向前摸索';
      return '继续向前探索前路';
    case 'idle_travel_next_scene':
      return travelScene ? `前往${travelScene.name}` : '前往其他场景';
    case 'idle_rest_focus':
      if (playerHpRatio <= 0.35) return '原地打坐恢复气血';
      if (playerManaRatio <= 0.35) return '盘坐调息恢复灵力';
      return '原地调息整理状态';
    case 'idle_observe_signs':
      return '停步观察附近的风吹草动';
    case 'idle_follow_clue':
      return '顺着可疑痕迹继续靠近';
    case 'idle_call_out':
      return '朝前方主动出声试探';
    default:
      return definition.text;
  }
}

function buildOptionDetailText(
  definition: StateFunctionDefinition,
  context: FunctionAvailabilityContext,
) {
  const forwardScene = getForwardScenePreset(
    context.worldType,
    context.currentSceneId,
  );
  const travelScene = getTravelScenePreset(
    context.worldType,
    context.currentSceneId,
  );
  const sceneName = context.currentSceneName ?? '当前区域';

  if (definition.id === 'idle_explore_forward') {
    return forwardScene
      ? `沿着${sceneName}继续往前压过去，真正把前方会遇到的人影、怪物或宝藏探出来。`
      : `继续深入${sceneName}前方未探明的地带，下一刻就可能撞见新的动静。`;
  }

  if (definition.id === 'idle_call_out') {
    return '主动打破寂静，把附近潜着的角色或怪物从屏幕外直接引到眼前。';
  }

  switch (definition.id) {
    case 'idle_explore_forward':
      return forwardScene
        ? `沿当前路径继续深入，可能会遇到角色、怪物、宝藏……`
        : '继续向前试探这片区域，可能会遇到角色、怪物、宝藏……';
    case 'idle_travel_next_scene':
      return travelScene?.description ?? '离开当前区域，前往相邻场景继续冒险。';
    case 'idle_observe_signs':
      return '先确认附近是否潜伏着人影、怪物或其他值得靠近的东西。';
    case 'idle_follow_clue':
      return '沿着声音、脚印或灵气痕迹继续摸过去，可能更快接近前方目标。';
    case 'idle_call_out':
      return '主动打破寂静，看看附近是谁或什么东西先有反应。';
    default:
      return undefined;
  }
}

function getFunctionPriority(
  definition: StateFunctionDefinition,
  context: FunctionAvailabilityContext,
) {
  const playerHpRatio = getPlayerHpRatio(context);
  const playerManaRatio = getPlayerManaRatio(context);
  const monsterHpRatio = getMonsterHpRatio(context);

  if (definition.id === 'idle_call_out') {
    return 5;
  }

  switch (definition.id) {
    case 'battle_recover_breath':
      return (
        (playerHpRatio <= 0.35 ? 10 : 0) + (playerManaRatio <= 0.3 ? 6 : 0)
      );
    case 'battle_finisher_window':
      return monsterHpRatio <= 0.25 ? 10 : monsterHpRatio <= 0.45 ? 6 : 1;
    case 'battle_all_in_crush':
      return monsterHpRatio <= 0.25 ? 8 : playerHpRatio <= 0.35 ? 2 : 4;
    case 'battle_guard_break':
      return monsterHpRatio <= 0.4 ? 6 : 3;
    case 'battle_probe_pressure':
      return playerManaRatio <= 0.3 ? 8 : 4;
    case 'battle_feint_step':
      return monsterHpRatio <= 0.5 ? 5 : 3;
    case 'battle_escape_breakout':
      return playerHpRatio <= 0.2 ? 9 : playerHpRatio <= 0.35 ? 5 : 1;
    case 'idle_rest_focus':
      return playerHpRatio <= 0.35 || playerManaRatio <= 0.35 ? 8 : 2;
    case 'idle_explore_forward':
      return playerHpRatio > 0.45 ? 6 : 2;
    case 'idle_travel_next_scene':
      return playerHpRatio > 0.45 ? 5 : 3;
    case 'idle_observe_signs':
      return 4;
    case 'idle_follow_clue':
      return 5;
    case 'idle_call_out':
      return 3;
    default:
      return 0;
  }
}

function matchesCategory(
  definition: StateFunctionDefinition,
  context: FunctionAvailabilityContext,
) {
  switch (definition.category) {
    case 'battle':
    case 'escape':
      return context.inBattle && hasAliveMonsters(context.monsters);
    case 'idle':
      return !context.inBattle;
    case 'recovery':
      return definition.state === 'battle'
        ? context.inBattle && hasAliveMonsters(context.monsters)
        : !context.inBattle;
    default:
      return false;
  }
}

function isCampSceneContext(context: FunctionAvailabilityContext) {
  return (
    getWorldCampScenePreset(context.worldType)?.id === context.currentSceneId
  );
}

export function getPlayerStateMode(inBattle: boolean): PlayerStateMode {
  return inBattle ? 'battle' : 'idle';
}

export function getAllStateFunctionDefinitions(
  definitions: StateFunctionDefinition[] = ALL_FUNCTIONS,
) {
  return definitions;
}

export function getFunctionsForState(
  state: PlayerStateMode,
  definitions: StateFunctionDefinition[] = ALL_FUNCTIONS,
) {
  return definitions.filter((item) => item.state === state);
}

export function getFunctionById(
  functionId: string,
  definitions: StateFunctionDefinition[] = ALL_FUNCTIONS,
) {
  return definitions.find((item) => item.id === functionId) ?? null;
}

export function getExecutableFunctions(
  context: FunctionAvailabilityContext,
  definitions: StateFunctionDefinition[] = ALL_FUNCTIONS,
) {
  const state = getPlayerStateMode(context.inBattle);
  return getFunctionsForState(state, definitions)
    .filter((definition) => matchesCategory(definition, context))
    .filter(
      (definition) =>
        !(
          definition.id === 'idle_explore_forward' &&
          isCampSceneContext(context)
        ),
    )
    .sort((a, b) => {
      const scoreDiff =
        getFunctionPriority(b, context) - getFunctionPriority(a, context);
      if (scoreDiff !== 0) return scoreDiff;
      return a.id.localeCompare(b.id);
    });
}

export function isFunctionExecutable(
  functionId: string,
  context: FunctionAvailabilityContext,
  definitions: StateFunctionDefinition[] = ALL_FUNCTIONS,
) {
  return getExecutableFunctions(context, definitions).some(
    (item) => item.id === functionId,
  );
}

export function buildFunctionCatalogText(
  context: FunctionAvailabilityContext,
  definitions: StateFunctionDefinition[] = ALL_FUNCTIONS,
) {
  return getExecutableFunctions(context, definitions)
    .map(
      (item) =>
        `- ${item.id}：${getFunctionPromptDescription(item.id, item.description)}`,
    )
    .join('\n');
}

export function resolveFunctionOption(
  functionId: string,
  context: FunctionAvailabilityContext,
  actionText?: string,
  definitions: StateFunctionDefinition[] = ALL_FUNCTIONS,
): StoryOption | null {
  const definition = getFunctionById(functionId, definitions);
  if (!definition || !isFunctionExecutable(functionId, context, definitions))
    return null;

  const primaryMonster =
    context.monsters.find((monster) => monster.hp > 0) ?? context.monsters[0];
  const monsterAction =
    definition.visual.monsterActionTemplate && primaryMonster
      ? definition.visual.monsterActionTemplate.replaceAll(
          '{monster}',
          primaryMonster.name,
        )
      : '前方的气氛依旧紧绷';
  const suggestedActionText = buildSuggestedActionText(definition, context);
  const shouldForceSuggestedActionText =
    definition.id === 'idle_explore_forward' ||
    definition.id === 'idle_travel_next_scene';
  const resolvedActionText = shouldForceSuggestedActionText
    ? suggestedActionText
    : actionText?.trim() || suggestedActionText;
  const detailText = buildOptionDetailText(definition, context);

  return {
    functionId: definition.id,
    actionText: resolvedActionText,
    text: resolvedActionText,
    detailText,
    priority: getStoryOptionPriority(definition.id),
    visuals: {
      playerAnimation: definition.visual.playerAnimation,
      playerMoveMeters: definition.visual.playerMoveMeters,
      playerOffsetY: definition.visual.playerOffsetY,
      playerFacing: definition.visual.playerFacing,
      scrollWorld: definition.visual.scrollWorld,
      monsterChanges:
        primaryMonster && definition.visual.monsterAnimation
          ? [
              {
                id: primaryMonster.id,
                action: monsterAction,
                animation: definition.visual.monsterAnimation,
                moveMeters: definition.visual.monsterMoveMeters ?? 0,
                yOffset: 0,
              },
            ]
          : [],
    },
  };
}

export function getDefaultFunctionIdsForContext(
  context: FunctionAvailabilityContext,
  definitions: StateFunctionDefinition[] = ALL_FUNCTIONS,
) {
  return getExecutableFunctions(context, definitions)
    .slice(0, 6)
    .map((item) => item.id);
}

export function getFunctionEffect(
  functionId: string,
  definitions: StateFunctionDefinition[] = ALL_FUNCTIONS,
) {
  return getFunctionById(functionId, definitions)?.effect ?? {};
}

export function getFunctionSkillWeights(
  functionId: string,
  definitions: StateFunctionDefinition[] = ALL_FUNCTIONS,
) {
  return getFunctionById(functionId, definitions)?.effect.skillWeights ?? null;
}

export function getStoryOptionPriority(functionId: string) {
  return FUNCTION_OPTION_PRIORITIES[functionId] ?? 1;
}

export function sortStoryOptionsByPriority(options: StoryOption[]) {
  const normalizedOptions = options.map((option, index) => ({
    option: {
      ...option,
      priority: getStoryOptionPriority(option.functionId),
    },
    index,
  }));

  const lockedOptions = normalizedOptions
    .slice(0, MODEL_PRIORITY_LOCKED_OPTION_COUNT)
    .map((item) => item.option);
  const prioritizedOptions = normalizedOptions
    .slice(MODEL_PRIORITY_LOCKED_OPTION_COUNT)
    .sort((a, b) => {
      const priorityDiff = (b.option.priority ?? 1) - (a.option.priority ?? 1);
      if (priorityDiff !== 0) return priorityDiff;
      return a.index - b.index;
    })
    .map((item) => item.option);

  return [...lockedOptions, ...prioritizedOptions];
}