const EFFECTS = [
  { id: "critChance", label: "Crit chance", cap: 12, group: "offense" },
  { id: "critDamage", label: "Crit damage", cap: 80, group: "offense" },
  { id: "blockChance", label: "Block chance", cap: 5, group: "defense" },
  { id: "healthRegen", label: "Health regen", cap: 4, group: "defense" },
  { id: "lifesteal", label: "Lifesteal", cap: 20, group: "hybrid" },
  { id: "doubleChance", label: "Double chance", cap: 20, group: "offense" },
  { id: "damage", label: "Damage", cap: 15, group: "offense" },
  { id: "meleeDamage", label: "Melee damage", cap: 50, group: "offense" },
  { id: "rangedDamage", label: "Ranged damage", cap: 15, group: "offense" },
  { id: "attackSpeed", label: "Attack speed", cap: 40, group: "offense" },
  { id: "skillDamage", label: "Skill damage", cap: 30, group: "skill" },
  { id: "skillCooldown", label: "Skill cooldown reduction", cap: 7, group: "skill" },
  { id: "health", label: "Health", cap: 15, group: "defense" },
];

const PROFILES = {
  balanced: {
    label: "Balanced",
    weights: { critChance: 8, critDamage: 4, blockChance: 7, healthRegen: 7, lifesteal: 7, doubleChance: 8, damage: 9, meleeDamage: 3, rangedDamage: 5, attackSpeed: 6, skillDamage: 5, skillCooldown: 8, health: 7 },
    baseDamage: 1,
    baseHealth: 0.75,
  },
  damage: {
    label: "Damage focused",
    weights: { critChance: 10, critDamage: 6, blockChance: 3, healthRegen: 3, lifesteal: 6, doubleChance: 10, damage: 10, meleeDamage: 5, rangedDamage: 7, attackSpeed: 8, skillDamage: 7, skillCooldown: 7, health: 3 },
    baseDamage: 1.25,
    baseHealth: 0.45,
  },
  survival: {
    label: "Survivability focused",
    weights: { critChance: 5, critDamage: 2, blockChance: 10, healthRegen: 10, lifesteal: 9, doubleChance: 5, damage: 5, meleeDamage: 2, rangedDamage: 3, attackSpeed: 4, skillDamage: 3, skillCooldown: 5, health: 10 },
    baseDamage: 0.65,
    baseHealth: 1.2,
  },
  skill: {
    label: "Skill focused",
    weights: { critChance: 7, critDamage: 4, blockChance: 5, healthRegen: 5, lifesteal: 6, doubleChance: 7, damage: 7, meleeDamage: 2, rangedDamage: 4, attackSpeed: 5, skillDamage: 10, skillCooldown: 11, health: 5 },
    baseDamage: 0.9,
    baseHealth: 0.65,
  },
};

const STORAGE_KEY = "forgeMasterOptimizer.v1";
const DRAFT_KEY = "forgeMasterOptimizer.draft.v1";
const EXPORT_VERSION = 1;
const FIXED_ITEMS = [
  { name: "Helmet", baseType: "health", baseValue: 1930000 },
  { name: "Armor", baseType: "health", baseValue: 1890000 },
  { name: "Gloves", baseType: "damage", baseValue: 237000 },
  { name: "Collar", baseType: "damage", baseValue: 237000 },
  { name: "Ring", baseType: "damage", baseValue: 244000 },
  { name: "Weapon", baseType: "damage", baseValue: 398000 },
  { name: "Boots", baseType: "health", baseValue: 1850000 },
  { name: "Belt", baseType: "health", baseValue: 1150000 },
];
const slots = [
  ...FIXED_ITEMS.map((item, i) => ({ type: "item", title: `Item ${i + 1}`, fixed: item })),
  { type: "mount", title: "Mount" },
  ...Array.from({ length: 3 }, (_, i) => ({ type: "pet", title: `Pet ${i + 1}` })),
];

const $ = (selector) => document.querySelector(selector);
const fmt = (value) => Number(value || 0).toLocaleString(undefined, { maximumFractionDigits: 1 });
const effectById = (id) => EFFECTS.find((effect) => effect.id === id);

let state = loadDraft() || createDefaultState();

function createDefaultState() {
  return {
    profile: "balanced",
    combatStyle: "melee",
    recommendationCount: 8,
    pieces: slots.map((slot, index) => createDefaultPiece(slot, index)),
  };
}

function createDefaultPiece(slot, index) {
  return {
    id: `${slot.type}-${index}`,
    type: slot.type,
    title: slot.title,
    name: slot.fixed?.name || slot.title,
    baseType: slot.fixed?.baseType || (index % 3 === 1 ? "health" : "damage"),
    baseValue: slot.fixed?.baseValue || 0,
    baseDamage: slot.fixed?.baseType === "damage" ? slot.fixed.baseValue : 0,
    baseHealth: slot.fixed?.baseType === "health" ? slot.fixed.baseValue : 0,
    fixedBase: Boolean(slot.fixed),
    effects: [{ type: "", value: 1 }, { type: "", value: 1 }],
  };
}

function enforceFixedPieceFields(piece, index) {
  const fixed = FIXED_ITEMS[index];
  if (!fixed || piece.type !== "item") return piece;
  return {
    ...piece,
    name: fixed.name,
    baseType: fixed.baseType,
    baseValue: fixed.baseValue,
    baseDamage: fixed.baseType === "damage" ? fixed.baseValue : 0,
    baseHealth: fixed.baseType === "health" ? fixed.baseValue : 0,
    fixedBase: true,
  };
}

function normalizeState(candidate) {
  const fallback = createDefaultState();
  return {
    ...fallback,
    ...candidate,
    profile: PROFILES[candidate?.profile] ? candidate.profile : "balanced",
    combatStyle: ["melee", "ranged", "skill"].includes(candidate?.combatStyle) ? candidate.combatStyle : "melee",
    recommendationCount: Math.min(20, Math.max(3, Number(candidate?.recommendationCount || 8))),
    pieces: fallback.pieces.map((piece, index) => enforceFixedPieceFields({
      ...piece,
      ...(candidate?.pieces?.[index] || {}),
      baseDamage: Number(candidate?.pieces?.[index]?.baseDamage ?? (candidate?.pieces?.[index]?.baseType === "damage" ? candidate?.pieces?.[index]?.baseValue : piece.baseDamage) ?? 0),
      baseHealth: Number(candidate?.pieces?.[index]?.baseHealth ?? (candidate?.pieces?.[index]?.baseType === "health" ? candidate?.pieces?.[index]?.baseValue : piece.baseHealth) ?? 0),
      effects: [0, 1].map((effectIndex) => ({
        type: candidate?.pieces?.[index]?.effects?.[effectIndex]?.type || "",
        value: clampEffectValue(
          candidate?.pieces?.[index]?.effects?.[effectIndex]?.type || "",
          Number(candidate?.pieces?.[index]?.effects?.[effectIndex]?.value || 1),
        ),
      })),
    }, index)),
  };
}

function clampEffectValue(type, value) {
  if (!type) return 1;
  const effect = effectById(type);
  return Math.min(effect.cap, Math.max(1, Number.isFinite(value) ? value : 1));
}

function render() {
  renderControls();
  renderGear();
  renderSaveSlots();
  updateAnalysis();
}

function renderControls() {
  $("#profileSelect").innerHTML = Object.entries(PROFILES).map(([id, profile]) => `<option value="${id}">${profile.label}</option>`).join("");
  $("#profileSelect").value = state.profile;
  $("#combatStyle").value = state.combatStyle;
  $("#recommendationCount").value = state.recommendationCount;
}

function renderGear() {
  const grid = $("#gearGrid");
  const template = $("#gearTemplate");
  grid.innerHTML = "";

  state.pieces.forEach((piece, pieceIndex) => {
    const node = template.content.firstElementChild.cloneNode(true);
    node.dataset.index = pieceIndex;
    node.querySelector("h3").textContent = piece.name;
    node.querySelector('[data-field="name"]').value = piece.name;
    const baseFields = node.querySelector(".inline-fields");
    if (piece.fixedBase) {
      node.classList.add("fixed-piece");
      node.querySelector('[data-field="name"]').readOnly = true;
      baseFields.innerHTML = `
        <label>Base stat
          <select data-field="baseType" disabled>
            <option value="damage">Damage</option>
            <option value="health">Health</option>
          </select>
        </label>
        <label>Value
          <input data-field="baseValue" type="number" min="0" step="1" readonly />
        </label>`;
      baseFields.querySelector('[data-field="baseType"]').value = piece.baseType;
      baseFields.querySelector('[data-field="baseValue"]').value = piece.baseValue;
    } else {
      baseFields.innerHTML = `
        <label>Damage base
          <input data-field="baseDamage" type="number" min="0" step="1" />
        </label>
        <label>Health base
          <input data-field="baseHealth" type="number" min="0" step="1" />
        </label>`;
      baseFields.querySelector('[data-field="baseDamage"]').value = piece.baseDamage || 0;
      baseFields.querySelector('[data-field="baseHealth"]').value = piece.baseHealth || 0;
    }

    const effects = node.querySelector(".effects");
    piece.effects.forEach((effect, effectIndex) => {
      const row = document.createElement("div");
      row.className = "effect-row";
      row.innerHTML = `
        <label>Effect ${effectIndex + 1}
          <select data-effect-type="${effectIndex}">
            <option value="">None</option>
            ${EFFECTS.map((option) => `<option value="${option.id}">${option.label} (max ${option.cap}%)</option>`).join("")}
          </select>
        </label>
        <label>Percent
          <input data-effect-value="${effectIndex}" type="number" min="1" step="0.1" value="${effect.value}" />
          <span class="cap-hint"></span>
        </label>`;
      row.querySelector("select").value = effect.type;
      const hint = row.querySelector(".cap-hint");
      hint.textContent = effect.type ? `Cap: ${effectById(effect.type).cap}%` : "Ignored";
      effects.appendChild(row);
    });

    grid.appendChild(node);
  });
}

function updateAnalysis() {
  const profile = PROFILES[state.profile];
  const totals = calculateTotals();
  const damageDetails = calculateDamageDetails(totals, state.combatStyle);
  const dps = damageDetails.dps;
  const survivability = calculateSurvivability(totals);
  const pieceScores = state.pieces.map((piece) => scorePiece(piece, profile, totals));

  $("#totalDamage").textContent = fmt(totals.baseDamage);
  $("#totalHealth").textContent = fmt(totals.baseHealth);
  $("#dpsValue").textContent = fmt(dps);
  $("#hitDamageDetails").innerHTML = `Hit ${fmt(damageDetails.singleHit)}<br>Crit ${fmt(damageDetails.critHit)}`;
  $("#defenseScore").textContent = fmt(calculateGroupScore(totals, profile, ["defense", "hybrid"], "health"));

  document.querySelectorAll(".gear-card").forEach((card, index) => {
    card.querySelector(".piece-score").textContent = `Score ${fmt(pieceScores[index].score)}`;
  });
  updateEffectImpactHints(totals, dps);

  renderEffectTotals(totals, dps, survivability);
  renderUpgrades(profile, totals, dps);
  renderSacrifices(pieceScores);
  saveDraft();
}

function calculateTotals() {
  const totals = { baseDamage: 0, baseHealth: 0, effects: Object.fromEntries(EFFECTS.map((effect) => [effect.id, 0])) };
  for (const piece of state.pieces) {
    totals.baseDamage += Number(piece.baseDamage || 0);
    totals.baseHealth += Number(piece.baseHealth || 0);
    for (const effect of piece.effects) {
      if (effect.type) totals.effects[effect.type] += clampEffectValue(effect.type, Number(effect.value));
    }
  }
  return totals;
}

function calculateDps(totals, combatStyle = "melee") {
  return calculateDamageDetails(totals, combatStyle).dps;
}

function calculateDamageDetails(totals, combatStyle = "melee") {
  const effects = totals.effects;
  const baseDamage = Math.max(0, totals.baseDamage);
  const globalDamage = 1 + effects.damage / 100;
  const styleDamage = 1 + getStyleDamageBonus(effects, combatStyle) / 100;
  const singleHit = baseDamage * globalDamage * styleDamage;
  const attackSpeed = 1 + effects.attackSpeed / 100;
  const doubleHit = 1 + effects.doubleChance / 100;
  const critChance = effects.critChance / 100;
  const critDamage = effects.critDamage / 100;
  const crit = 1 + critChance * critDamage;
  const critHit = singleHit * (1 + critDamage);
  const cooldown = combatStyle === "skill" ? 1 / Math.max(0.05, 1 - effects.skillCooldown / 100) : 1;
  return {
    singleHit,
    critHit,
    dps: singleHit * attackSpeed * doubleHit * crit * cooldown,
  };
}

function calculateSurvivability(totals) {
  const effects = totals.effects;
  const baseHealth = Math.max(0, totals.baseHealth);
  const health = baseHealth * (1 + effects.health / 100);
  const blockMultiplier = 1 / Math.max(0.05, 1 - effects.blockChance / 100);
  const regenMultiplier = 1 + effects.healthRegen / 100;
  const lifestealMultiplier = 1 + effects.lifesteal / 100;
  return health * blockMultiplier * regenMultiplier * lifestealMultiplier;
}

function getStyleDamageBonus(effects, combatStyle) {
  if (combatStyle === "ranged") return effects.rangedDamage;
  if (combatStyle === "skill") return effects.skillDamage;
  return effects.meleeDamage;
}

function cloneTotalsWithEffectDelta(totals, effectType, delta) {
  return {
    baseDamage: totals.baseDamage,
    baseHealth: totals.baseHealth,
    effects: {
      ...totals.effects,
      [effectType]: Math.max(0, (totals.effects[effectType] || 0) + delta),
    },
  };
}

function calculateMaxRollGain(effect, totals, currentDps, currentSurvivability) {
  const withMaxRoll = cloneTotalsWithEffectDelta(totals, effect.id, effect.cap);
  const dpsGain = percentChange(currentDps, calculateDps(withMaxRoll, state.combatStyle));
  const survivabilityGain = percentChange(currentSurvivability, calculateSurvivability(withMaxRoll));
  const parts = [];
  if (Math.abs(dpsGain) >= 0.05) parts.push(`+${fmt(dpsGain)}% DPS`);
  if (Math.abs(survivabilityGain) >= 0.05) parts.push(`+${fmt(survivabilityGain)}% survivability`);
  return {
    label: parts.length ? parts.join(" / ") : "no effect for current style",
    score: Math.max(0, dpsGain, survivabilityGain),
  };
}

function classifyGain(score, bestScore) {
  if (bestScore <= 0 || score <= 0.05) return "gain-low";
  const ratio = score / bestScore;
  if (ratio >= 0.75) return "gain-best";
  if (ratio >= 0.4) return "gain-good";
  if (ratio >= 0.15) return "gain-mid";
  return "gain-low";
}

function percentChange(from, to) {
  if (from <= 0) return to > 0 ? 100 : 0;
  return ((to / from) - 1) * 100;
}

function calculateGroupScore(totals, profile, groups, baseKind) {
  const effectScore = EFFECTS.filter((effect) => groups.includes(effect.group))
    .reduce((sum, effect) => sum + (totals.effects[effect.id] / effect.cap) * 100 * profile.weights[effect.id], 0);
  const baseScore = baseKind === "health" ? totals.baseHealth * profile.baseHealth : totals.baseDamage * profile.baseDamage;
  return effectScore + baseScore;
}

function scorePiece(piece, profile, totals) {
  const baseAverageDamage = Math.max(1, totals.baseDamage / 6);
  const baseAverageHealth = Math.max(1, totals.baseHealth / 6);
  let score = (Number(piece.baseDamage || 0) / baseAverageDamage) * 35 * profile.baseDamage
    + (Number(piece.baseHealth || 0) / baseAverageHealth) * 35 * profile.baseHealth;
  const reasons = [];

  for (const effect of piece.effects) {
    if (!effect.type) {
      reasons.push("missing effect slot");
      continue;
    }
    const def = effectById(effect.type);
    const normalized = clampEffectValue(effect.type, Number(effect.value)) / def.cap;
    score += normalized * 100 * profile.weights[effect.type];
    if (normalized < 0.3) reasons.push(`${def.label} is still low`);
    if (profile.weights[effect.type] <= 3) reasons.push(`${def.label} is low priority for this profile`);
  }

  if (!Number(piece.baseDamage || 0) && !Number(piece.baseHealth || 0)) reasons.push("no base stat entered");
  return { piece, score, reasons: [...new Set(reasons)] };
}

function renderEffectTotals(totals, currentDps, currentSurvivability) {
  const gains = EFFECTS.map((effect) => ({
    effect,
    gain: calculateMaxRollGain(effect, totals, currentDps, currentSurvivability),
  }));
  const bestScore = Math.max(...gains.map(({ gain }) => gain.score), 0);

  $("#effectTotals").innerHTML = gains.map(({ effect, gain }) => `
    <div class="effect-pill">
      <span>${effect.label}</span>
      <strong>${fmt(totals.effects[effect.id])}%</strong>
      <small class="max-roll-row">
        <span>Max roll +${effect.cap}%</span>
        <strong class="${classifyGain(gain.score, bestScore)}">${gain.label}</strong>
      </small>
    </div>
  `).join("");
}

function updateEffectImpactHints(totals, currentDps) {
  document.querySelectorAll(".gear-card").forEach((card, pieceIndex) => {
    const piece = state.pieces[pieceIndex];
    card.querySelectorAll(".effect-row").forEach((row, effectIndex) => {
      const effect = piece.effects[effectIndex];
      const hint = row.querySelector(".cap-hint");
      if (!effect.type) {
        hint.textContent = "Ignored";
        return;
      }
      const def = effectById(effect.type);
      const current = clampEffectValue(effect.type, Number(effect.value));
      const withoutThis = calculateDps(cloneTotalsWithEffectDelta(totals, effect.type, -current), state.combatStyle);
      const currentGain = percentChange(withoutThis, currentDps);
      const remaining = Math.max(0, def.cap - current);
      const plusOne = Math.min(1, remaining);
      const plusOneGain = plusOne > 0
        ? percentChange(currentDps, calculateDps(cloneTotalsWithEffectDelta(totals, effect.type, plusOne), state.combatStyle))
        : 0;
      hint.textContent = `Cap: ${def.cap}%. Actual now: ${fmt(currentGain)}% DPS. Next +${fmt(plusOne)}%: ${fmt(plusOneGain)}% DPS.`;
    });
  });
}

function renderUpgrades(profile, totals, currentDps) {
  const upgrades = [];
  for (const piece of state.pieces) {
    for (const effect of piece.effects) {
      if (!effect.type) continue;
      const def = effectById(effect.type);
      const current = clampEffectValue(effect.type, Number(effect.value));
      const remaining = def.cap - current;
      if (remaining <= 0) continue;
      const plusOne = Math.min(1, remaining);
      const onePointDps = calculateDps(cloneTotalsWithEffectDelta(totals, effect.type, plusOne), state.combatStyle);
      const capDps = calculateDps(cloneTotalsWithEffectDelta(totals, effect.type, remaining), state.combatStyle);
      const onePointGain = percentChange(currentDps, onePointDps);
      const capGain = percentChange(currentDps, capDps);
      const fallback = profile.weights[effect.type] * 0.001;
      const efficiency = capGain || onePointGain || fallback;
      upgrades.push({ piece, def, current, remaining, efficiency, onePointGain, capGain });
    }
  }

  upgrades.sort((a, b) => b.efficiency - a.efficiency);
  const count = state.recommendationCount;
  $("#upgradeList").innerHTML = upgrades.slice(0, count).map((item) => `
    <li><strong>${item.def.label}</strong> on ${escapeHtml(item.piece.name || item.piece.title)}
      <small>${fmt(item.current)}% now, ${fmt(item.remaining)}% room to cap. Next +1% gives ${fmt(item.onePointGain)}% DPS; to cap gives ${fmt(item.capGain)}% DPS.</small>
    </li>
  `).join("") || "<li>No upgradeable effects entered yet.</li>";
}

function renderSacrifices(pieceScores) {
  const weakest = [...pieceScores].sort((a, b) => a.score - b.score).slice(0, state.recommendationCount);
  $("#sacrificeList").innerHTML = weakest.map(({ piece, score, reasons }) => `
    <li><strong>${escapeHtml(piece.name || piece.title)}</strong>
      <small>Score ${fmt(score)}. ${reasons.length ? reasons.join("; ") : "Lowest relative contribution among entered pieces."}</small>
    </li>
  `).join("");
}

function saveDraft() {
  localStorage.setItem(DRAFT_KEY, JSON.stringify(state));
}

function loadDraft() {
  try {
    const raw = localStorage.getItem(DRAFT_KEY);
    return raw ? normalizeState(JSON.parse(raw)) : null;
  } catch {
    return null;
  }
}

function getSavedSlots() {
  try {
    return JSON.parse(localStorage.getItem(STORAGE_KEY) || "{}");
  } catch {
    return {};
  }
}

function setSavedSlots(saved) {
  localStorage.setItem(STORAGE_KEY, JSON.stringify(saved));
}

function renderSaveSlots() {
  const saved = getSavedSlots();
  const select = $("#slotSelect");
  const names = Object.keys(saved).sort();
  select.innerHTML = names.map((name) => `<option value="${escapeHtml(name)}">${escapeHtml(name)}</option>`).join("") || '<option value="">No saved slots</option>';
}

function setStatus(message, danger = false) {
  const node = $("#saveStatus");
  node.textContent = message;
  node.style.color = danger ? "var(--danger)" : "var(--good)";
}

function setImportExportStatus(message, danger = false) {
  const node = $("#importExportStatus");
  node.textContent = message;
  node.style.color = danger ? "var(--danger)" : "var(--good)";
}

function createExportPayload() {
  return {
    app: "forge-master-strategy-optimizer",
    version: EXPORT_VERSION,
    exportedAt: new Date().toISOString(),
    build: normalizeState(state),
  };
}

function createExportJson() {
  return JSON.stringify(createExportPayload(), null, 2);
}

async function generateExportJson() {
  const json = createExportJson();
  const textarea = $("#jsonTransfer");
  textarea.value = json;
  textarea.focus();
  textarea.select();
  try {
    await navigator.clipboard.writeText(json);
    setImportExportStatus("Export JSON generated and copied to clipboard.");
  } catch {
    setImportExportStatus("Export JSON generated. Copy it from the text box or download it as a file.");
  }
}

function downloadExportJson() {
  const json = createExportJson();
  $("#jsonTransfer").value = json;
  const blob = new Blob([json], { type: "application/json" });
  const url = URL.createObjectURL(blob);
  const link = document.createElement("a");
  link.href = url;
  link.download = `forge-master-build-${new Date().toISOString().slice(0, 10)}.json`;
  document.body.appendChild(link);
  link.click();
  link.remove();
  URL.revokeObjectURL(url);
  setImportExportStatus("Downloaded current build as JSON.");
}

function parseImportedState(jsonText) {
  if (!jsonText.trim()) throw new Error("Paste JSON first or upload a JSON file.");
  let parsed;
  try {
    parsed = JSON.parse(jsonText);
  } catch {
    throw new Error("Invalid JSON. Check that the full export was copied.");
  }
  const build = parsed?.build || parsed;
  if (!build || typeof build !== "object" || !Array.isArray(build.pieces)) {
    throw new Error("JSON does not look like a Forge Master build export.");
  }
  return normalizeState(build);
}

function importJsonText(jsonText, sourceLabel = "JSON") {
  try {
    state = parseImportedState(jsonText);
    render();
    setImportExportStatus(`Imported ${sourceLabel}. Draft autosaved.`);
  } catch (error) {
    setImportExportStatus(error.message, true);
  }
}

function importPastedJson() {
  importJsonText($("#jsonTransfer").value, "pasted JSON");
}

function importUploadedJson(event) {
  const file = event.target.files?.[0];
  if (!file) return;
  const reader = new FileReader();
  reader.addEventListener("load", () => {
    const text = String(reader.result || "");
    $("#jsonTransfer").value = text;
    importJsonText(text, file.name);
    event.target.value = "";
  });
  reader.addEventListener("error", () => {
    setImportExportStatus("Could not read the selected file.", true);
    event.target.value = "";
  });
  reader.readAsText(file);
}

function bindEvents() {
  $("#profileSelect").addEventListener("change", (event) => {
    state.profile = event.target.value;
    updateAnalysis();
  });
  $("#combatStyle").addEventListener("change", (event) => {
    state.combatStyle = event.target.value;
    updateAnalysis();
  });
  $("#recommendationCount").addEventListener("input", (event) => {
    state.recommendationCount = Math.min(20, Math.max(3, Number(event.target.value || 8)));
    updateAnalysis();
  });
  $("#resetBuild").addEventListener("click", () => {
    state = createDefaultState();
    render();
    setStatus("Current build reset. Draft autosaved.");
  });
  $("#gearGrid").addEventListener("input", handleGearInput);
  $("#gearGrid").addEventListener("change", handleGearInput);
  $("#saveSlot").addEventListener("click", saveNamedSlot);
  $("#loadSlot").addEventListener("click", loadNamedSlot);
  $("#deleteSlot").addEventListener("click", deleteNamedSlot);
  $("#copyExport").addEventListener("click", generateExportJson);
  $("#downloadExport").addEventListener("click", downloadExportJson);
  $("#importJson").addEventListener("click", importPastedJson);
  $("#importFile").addEventListener("change", importUploadedJson);
}

function handleGearInput(event) {
  const card = event.target.closest(".gear-card");
  if (!card) return;
  const piece = state.pieces[Number(card.dataset.index)];

  if (event.target.dataset.field) {
    if (piece.fixedBase && ["name", "baseType", "baseValue"].includes(event.target.dataset.field)) {
      event.target.value = piece[event.target.dataset.field];
      return;
    }
    const field = event.target.dataset.field;
    piece[field] = ["baseValue", "baseDamage", "baseHealth"].includes(field) ? Math.max(0, Number(event.target.value || 0)) : event.target.value;
    if (field === "baseDamage" || field === "baseHealth") {
      piece.baseType = Number(piece.baseHealth || 0) > Number(piece.baseDamage || 0) ? "health" : "damage";
      piece.baseValue = Math.max(Number(piece.baseDamage || 0), Number(piece.baseHealth || 0));
    }
  }
  if (event.target.dataset.effectType !== undefined) {
    const index = Number(event.target.dataset.effectType);
    piece.effects[index].type = event.target.value;
    piece.effects[index].value = clampEffectValue(event.target.value, piece.effects[index].value);
    renderGear();
  }
  if (event.target.dataset.effectValue !== undefined) {
    const index = Number(event.target.dataset.effectValue);
    piece.effects[index].value = clampEffectValue(piece.effects[index].type, Number(event.target.value || 1));
  }
  updateAnalysis();
}

function saveNamedSlot() {
  const name = $("#slotName").value.trim();
  if (!name) return setStatus("Enter a slot name first.", true);
  const saved = getSavedSlots();
  saved[name] = { ...state, savedAt: new Date().toISOString() };
  setSavedSlots(saved);
  renderSaveSlots();
  $("#slotSelect").value = name;
  setStatus(`Saved slot “${name}”.`);
}

function loadNamedSlot() {
  const name = $("#slotSelect").value;
  const saved = getSavedSlots();
  if (!name || !saved[name]) return setStatus("Choose a saved slot to load.", true);
  state = normalizeState(saved[name]);
  render();
  setStatus(`Loaded slot “${name}”.`);
}

function deleteNamedSlot() {
  const name = $("#slotSelect").value;
  const saved = getSavedSlots();
  if (!name || !saved[name]) return setStatus("Choose a saved slot to delete.", true);
  delete saved[name];
  setSavedSlots(saved);
  renderSaveSlots();
  setStatus(`Deleted slot “${name}”.`);
}

function escapeHtml(value) {
  return String(value).replace(/[&<>"]/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[char]));
}

bindEvents();
render();