Genarrative/src/data/runtimeItemCompiler.ts

import type {
  InventoryItem,
  ItemBuildProfile,
  ItemRarity,
  ItemStatProfile,
  ItemUseProfile,
  RuntimeItemAiIntent,
  RuntimeItemCompileBudget,
  RuntimeItemGenerationContext,
  RuntimeItemPlan,
  TimedBuildBuff,
} from '../types';
import { normalizeBuildRole, normalizeBuildTags } from './buildTags';

const RARITY_ORDER: ItemRarity[] = [
  'common',
  'uncommon',
  'rare',
  'epic',
  'legendary',
];

function clampIndex(index: number) {
  return Math.max(0, Math.min(RARITY_ORDER.length - 1, index));
}

function hashText(value: string) {
  let hash = 0;
  for (let index = 0; index < value.length; index += 1) {
    hash = (hash << 5) - hash + value.charCodeAt(index);
    hash |= 0;
  }
  return Math.abs(hash);
}

function buildStructuralTags(plan: RuntimeItemPlan) {
  switch (plan.itemKind) {
    case 'equipment':
      return ['weapon'];
    case 'relic':
      return ['relic'];
    case 'material':
      return ['material'];
    case 'consumable':
      return ['consumable'];
    case 'quest':
      return ['relic'];
    default:
      return [];
  }
}

function resolveEquipmentSlotId(plan: RuntimeItemPlan) {
  if (plan.itemKind === 'equipment') {
    if (
      plan.targetBuildDirection.includes('守御') ||
      plan.targetBuildDirection.includes('护体')
    ) {
      return 'armor' as const;
    }
    return 'weapon' as const;
  }

  if (plan.itemKind === 'relic' || plan.itemKind === 'quest') {
    return 'relic' as const;
  }

  return null;
}

function resolveCategory(plan: RuntimeItemPlan) {
  switch (plan.itemKind) {
    case 'equipment':
      return resolveEquipmentSlotId(plan) === 'armor' ? '护甲' : '武器';
    case 'consumable':
      return '消耗品';
    case 'material':
      return '材料';
    case 'quest':
      return '专属物';
    default:
      return '稀有品';
  }
}

function buildRuntimeBudget(
  context: RuntimeItemGenerationContext,
  plan: RuntimeItemPlan,
  seedKey: string,
): RuntimeItemCompileBudget {
  const seed = hashText(
    `${context.generationChannel}:${seedKey}:${plan.slot}:${plan.itemKind}`,
  );
  const channelBaseIndex =
    context.generationChannel === 'quest_reward'
      ? 2
      : context.generationChannel === 'treasure'
        ? 1
        : context.generationChannel === 'monster_drop'
          ? 0
          : 1;
  const slotBonus = plan.slot === 'primary' ? 1 : 0;
  const permanenceBonus = plan.permanence === 'permanent' ? 1 : 0;
  const rarityIndex = clampIndex(
    channelBaseIndex + slotBonus + permanenceBonus + (seed % 2),
  );
  const rarity = RARITY_ORDER[rarityIndex] ?? 'common';

  return {
    rarity,
    buildTagLimit:
      rarity === 'legendary'
        ? 2
        : rarity === 'epic' || rarity === 'rare'
          ? 2
          : 1,
    timedBuffTagLimit:
      rarity === 'legendary'
        ? 3
        : rarity === 'epic' || rarity === 'rare'
          ? 2
          : 1,
    timedBuffDuration: rarity === 'legendary' ? 3 : rarity === 'epic' ? 3 : 2,
    statBudgetTier: rarityIndex + 1,
  };
}

function buildTimedBuffs(
  itemId: string,
  intent: RuntimeItemAiIntent,
  budget: RuntimeItemCompileBudget,
): TimedBuildBuff[] {
  const tags = normalizeBuildTags(
    intent.desiredBuildTags,
    budget.timedBuffTagLimit,
  );
  if (tags.length <= 0) return [];

  return [
    {
      id: `${itemId}:buff`,
      sourceType: 'item',
      sourceId: itemId,
      name: `${tags[0]}增益`,
      tags,
      durationTurns: budget.timedBuffDuration,
    },
  ];
}

function buildUseProfile(
  plan: RuntimeItemPlan,
  intent: RuntimeItemAiIntent,
  budget: RuntimeItemCompileBudget,
  itemId: string,
): ItemUseProfile | null {
  if (plan.itemKind !== 'consumable' && plan.permanence === 'permanent')
    return null;

  const useProfile: ItemUseProfile = {};

  if (intent.desiredFunctionalBias.includes('heal')) {
    useProfile.hpRestore = 16 + budget.statBudgetTier * 10;
  }
  if (intent.desiredFunctionalBias.includes('mana')) {
    useProfile.manaRestore = 14 + budget.statBudgetTier * 8;
  }
  if (intent.desiredFunctionalBias.includes('cooldown')) {
    useProfile.cooldownReduction =
      budget.rarity === 'legendary' || budget.rarity === 'epic' ? 1 : 0;
  }
  if (plan.permanence === 'timed' || plan.itemKind === 'consumable') {
    useProfile.buildBuffs = buildTimedBuffs(itemId, intent, budget);
  }

  if (
    (useProfile.hpRestore ?? 0) <= 0 &&
    (useProfile.manaRestore ?? 0) <= 0 &&
    (useProfile.cooldownReduction ?? 0) <= 0 &&
    (useProfile.buildBuffs?.length ?? 0) <= 0
  ) {
    return null;
  }

  return useProfile;
}

function buildStatProfile(
  plan: RuntimeItemPlan,
  intent: RuntimeItemAiIntent,
  budget: RuntimeItemCompileBudget,
): ItemStatProfile | null {
  if (plan.itemKind === 'material') return null;

  const statProfile: ItemStatProfile = {};
  const tier = budget.statBudgetTier;

  if (
    plan.itemKind === 'equipment' ||
    plan.itemKind === 'relic' ||
    plan.itemKind === 'quest'
  ) {
    if (
      intent.desiredFunctionalBias.includes('guard') ||
      plan.targetBuildDirection.includes('守御')
    ) {
      statProfile.maxHpBonus =
        6 * tier + (plan.itemKind === 'equipment' ? 10 : 4);
      statProfile.incomingDamageMultiplier = Number(
        Math.max(0.84, 1 - tier * 0.03).toFixed(2),
      );
    }
    if (
      intent.desiredFunctionalBias.includes('mana') ||
      plan.targetBuildDirection.includes('法力')
    ) {
      statProfile.maxManaBonus =
        8 * tier + (plan.itemKind === 'relic' ? 10 : 0);
    }
    if (
      intent.desiredFunctionalBias.includes('damage') ||
      plan.targetBuildDirection.length > 0
    ) {
      statProfile.outgoingDamageBonus = Number((0.03 * tier).toFixed(2));
    }
  }

  if (Object.keys(statProfile).length <= 0) return null;
  return statProfile;
}

function buildProfile(
  plan: RuntimeItemPlan,
  intent: RuntimeItemAiIntent,
  budget: RuntimeItemCompileBudget,
): ItemBuildProfile | null {
  if (
    plan.permanence !== 'permanent' ||
    (plan.itemKind !== 'equipment' &&
      plan.itemKind !== 'relic' &&
      plan.itemKind !== 'quest')
  ) {
    return null;
  }

  const tags = normalizeBuildTags(
    intent.desiredBuildTags,
    budget.buildTagLimit,
  );
  if (tags.length <= 0) return null;

  return {
    role: normalizeBuildRole(tags[0]),
    tags,
    synergy: normalizeBuildTags(
      [...plan.targetBuildDirection, ...intent.desiredBuildTags],
      3,
    ),
    craftTags: tags,
    forgeRank: 0,
  };
}

function buildValue(budget: RuntimeItemCompileBudget, plan: RuntimeItemPlan) {
  const baseValue = {
    common: 18,
    uncommon: 32,
    rare: 52,
    epic: 80,
    legendary: 118,
  }[budget.rarity];

  if (plan.itemKind === 'material') return baseValue - 8;
  if (plan.itemKind === 'consumable') return baseValue - 4;
  if (plan.itemKind === 'quest') return baseValue + 12;
  return baseValue;
}

function buildItemTags(
  plan: RuntimeItemPlan,
  intent: RuntimeItemAiIntent,
  budget: RuntimeItemCompileBudget,
) {
  const tags = [
    ...buildStructuralTags(plan),
    ...normalizeBuildTags(intent.desiredBuildTags, budget.buildTagLimit + 1),
  ];

  if (intent.desiredFunctionalBias.includes('heal')) tags.push('healing');
  if (intent.desiredFunctionalBias.includes('mana')) tags.push('mana');
  if (resolveEquipmentSlotId(plan) === 'armor') tags.push('armor');
  if (resolveEquipmentSlotId(plan) === 'weapon') tags.push('weapon');
  if (resolveEquipmentSlotId(plan) === 'relic') tags.push('relic');

  return [...new Set(tags.filter(Boolean))];
}

export function compileRuntimeItem(params: {
  seedKey: string;
  context: RuntimeItemGenerationContext;
  plan: RuntimeItemPlan;
  intent: RuntimeItemAiIntent;
}) {
  const { seedKey, context, plan, intent } = params;
  const budget = buildRuntimeBudget(context, plan, seedKey);
  const itemId = `runtime:${context.generationChannel}:${hashText(seedKey).toString(36)}`;
  const runtimeMetadata = {
    origin: 'ai_compiled' as const,
    generationChannel: context.generationChannel,
    seedKey,
    relationAnchor: plan.relationAnchor,
    sourceReason: intent.reasonToAppear,
    recentEventHook: context.recentActions[0],
  };

  return {
    id: itemId,
    category: resolveCategory(plan),
    name: intent.shortNameSeed || '未命名秘物',
    quantity: 1,
    rarity: budget.rarity,
    tags: buildItemTags(plan, intent, budget),
    equipmentSlotId: resolveEquipmentSlotId(plan),
    statProfile: buildStatProfile(plan, intent, budget),
    useProfile: buildUseProfile(plan, intent, budget, itemId),
    buildProfile: buildProfile(plan, intent, budget),
    value: buildValue(budget, plan),
    runtimeMetadata,
  } satisfies InventoryItem;
}