import type { CaptureResult } from "../types/global.js";
import {
  allowedMainStatsForSlot,
  canonicalStatName,
  fixedMainStatBySlot,
  globalMainStats,
  globalSubstats,
  knownCharacters,
  knownPieceNames,
  knownSets,
  mainStatValueReferences,
  normalizeCharacterAlias,
  normalizePieceAlias,
  normalizeSetAlias,
  normalizeSlotAlias,
  pieceToSet,
  pieceToSlot,
  slotNames,
  textReplacements,
} from "./genshinData.js";
import { fuzzyFindKnown, simplifyForMatch } from "./fuzzyMatch.js";
import { matchCharacter, matchPiece, matchSet, matchSlot, matchStat } from "./genshinLookup.js";
import { implausibleSubstats } from "./substatRolls.js";

type MainStatValueReference = { stat: string; base: number; max: number };

export interface ParsedField {
  value: string;
  confidence: number;
  source: "ocr" | "database" | "derived" | "fallback" | "missing";
}

export interface ParsedArtifactCandidate {
  name: string;
  slot: string;
  level: number;
  mainStat: string;
  mainValue: string;
  substats: string[];
  setName: string;
  equipped: string;
  confidence: number;
  notes: string[];
  fields: {
    name: ParsedField;
    slot: ParsedField;
    level?: ParsedField;
    mainStat: ParsedField;
    mainValue: ParsedField;
    setName: ParsedField;
    equipped: ParsedField;
    substats: ParsedField;
  };
}

const mainStatNames = sortLongestFirst(globalMainStats);
const substatNames = sortLongestFirst(globalSubstats);

export function parseArtifactCandidate(capture: CaptureResult | null): ParsedArtifactCandidate | null {
  if (!capture?.ocr?.length) return null;

  const byId = new Map(
    (capture.ocr ?? []).map((entry: (typeof capture.ocr)[number]) => [entry.id, normalizeText(entry.text)]),
  );
  const allText = normalizeText((capture.ocr ?? []).map((entry: (typeof capture.ocr)[number]) => entry.text).join("\n"));
  const nameText = byId.get("artifact-name") ?? "";
  const slotOnlyText = byId.get("artifact-slot") ?? "";
  const legacyTitleText = byId.get("artifact-title") ?? "";
  const titleText = [nameText, slotOnlyText].filter(Boolean).join("\n") || legacyTitleText;
  const mainLabelText = byId.get("artifact-main-stat-label") ?? "";
  const mainValueText = byId.get("artifact-main-stat-value") ?? "";
  const legacyMainText = byId.get("artifact-main-stat") ?? "";
  const mainText = [mainLabelText, mainValueText].filter(Boolean).join("\n") || legacyMainText;
  const levelText = byId.get("artifact-level") ?? "";
  const substatText = byId.get("artifact-substats") ?? "";
  const setText = byId.get("artifact-set-effects") ?? "";
  const footerText = byId.get("artifact-footer") ?? "";

  const nameField = parseArtifactName(titleText);
  const slotField = parseSlot([slotOnlyText, titleText, allText].filter(Boolean).join("\n"), nameField);
  const levelField = parseArtifactLevel([levelText, substatText, mainText, allText].filter(Boolean).join("\n"));
  const parsedLevel = levelField.value ? Number.parseInt(levelField.value, 10) : null;
  const level = parsedLevel ?? 0;
  let mainStatField = inferMainStat(slotField.value, mainText);
  mainStatField = promoteSlotPercentMainStat(slotField.value, mainStatField);
  let mainValueField = findMainValue(mainText, mainStatField.value, slotField.value, parsedLevel);
  if (!mainStatField.value && mainValueField.value) {
    const inferredFromValue = inferMainStatFromValue(slotField.value, mainValueField.value, mainText, parsedLevel);
    if (inferredFromValue.value) {
      mainStatField = inferredFromValue;
      mainValueField = findMainValue(mainText, mainStatField.value, slotField.value, parsedLevel);
    }
  }
  if (!mainStatField.value && mainValueField.value) {
    const exactReferenceMatch = deriveMainStatFromExactReferenceValue(slotField.value, mainValueField.value, mainText, parsedLevel);
    if (exactReferenceMatch.value) {
      mainStatField = exactReferenceMatch;
      mainValueField = findMainValue(mainText, mainStatField.value, slotField.value, parsedLevel);
    }
  }
  if ((!mainStatField.value || !mainValueField.value) && slotField.value) {
    const noisyReferenceMatch = deriveMainStatAndValueFromNoisyReference(slotField.value, mainText, parsedLevel);
    if (!mainStatField.value && noisyReferenceMatch.mainStat.value) {
      mainStatField = noisyReferenceMatch.mainStat;
    }
    if (!mainValueField.value && noisyReferenceMatch.mainValue.value) {
      mainValueField = noisyReferenceMatch.mainValue;
    }
  }
  const substats = parseSubstats([substatText, leadingSetEffectText(setText)].filter(Boolean).join("\n"));
  const substatsField = field(substats.join(", "), substats.length >= 4 ? 96 : substats.length >= 3 ? 82 : substats.length > 0 ? 55 : 0, substats.length ? "ocr" : "missing");
  const setField = parseSetName(setText, nameField);
  const equippedField = parseEquippedCharacter(footerText + "\n" + allText);
  const notes: string[] = [];

  if (!nameField.value) notes.push("Artifact name not confidently parsed.");
  if (nameField.value && nameField.confidence < 84) notes.push("Artifact name was fuzzy-matched; review if this piece matters.");
  if (!slotField.value) notes.push("Slot not confidently parsed.");
  if (!levelField.value) notes.push("Artifact level not confidently parsed.");
  if (!mainStatField.value) notes.push("Main stat not confidently parsed.");
  if (!mainValueField.value) notes.push("Main stat value not confidently parsed.");
  if (substats.length < 3) notes.push("Substats look incomplete; crop or OCR needs tuning.");
  const implausible = implausibleSubstats(substats);
  if (implausible.length) notes.push(`Substat value has no valid roll combination (likely OCR misread): ${implausible.join(", ")}.`);
  if (!setField.value) notes.push("Set name not confidently parsed.");

  for (const [label, parsedField] of Object.entries({
    name: nameField,
    slot: slotField,
    level: levelField,
    mainStat: mainStatField,
    mainValue: mainValueField,
    set: setField,
    equipped: equippedField,
  }) as Array<[string, ParsedField]>) {
    if (parsedField.value && parsedField.confidence < 70) notes.push(`${label} confidence is low; review before trusting it.`);
  }

  const fields = {
    name: nameField,
    slot: slotField,
    level: levelField,
    mainStat: mainStatField,
    mainValue: mainValueField,
    setName: setField,
    equipped: equippedField,
    substats: substatsField,
  };
  const confidence = Math.round(Object.values(fields).reduce((sum, parsedField) => sum + parsedField.confidence, 0) / Object.values(fields).length);

  return {
    name: nameField.value || "Unknown artifact",
    slot: slotField.value || "Unknown slot",
    level,
    mainStat: mainStatField.value || "Unknown main stat",
    mainValue: mainValueField.value || "?",
    substats,
    setName: setField.value || "Unknown set",
    equipped: equippedField.value || "Not detected",
    confidence,
    notes: [...new Set(notes)],
    fields,
  };
}

function parseArtifactName(titleText: string): ParsedField {
  const titleLines = titleText
    .split("\n")
    .map((line) => cleanupOcrLabel(line))
    .filter(Boolean);

  for (const line of titleLines) {
    const match = matchPiece(line);
    if (match.value) {
      return field(match.value, match.confidence, match.source === "exact" || match.source === "alias" ? "database" : "fallback");
    }
    const alias = normalizePieceAlias(line);
    if (alias) return field(alias, 96, "database");
  }

  const partialPiece = derivePieceFromDistinctivePartialName(titleText);
  if (partialPiece) return field(partialPiece, 72, "fallback");

  const knownPiece = fuzzyFindKnown(titleText, knownPieceNames, 0.72);
  if (knownPiece) return field(knownPiece.value, Math.round(knownPiece.score * 100), knownPiece.score >= 0.98 ? "database" : "fallback");

  const fallback = firstUsefulLine(titleText, slotNames);
  return fallback ? field(fallback, 50, "fallback") : field("", 0, "missing");
}

function parseSlot(text: string, artifactName: ParsedField): ParsedField {
  const slotLines = text
    .split("\n")
    .map((line) => cleanupOcrLabel(line))
    .filter(Boolean);

  for (const line of slotLines) {
    const match = matchSlot(line);
    if (match.value) {
      return field(match.value, match.confidence, match.source === "fuzzy" ? "fallback" : "ocr");
    }
    const alias = normalizeSlotAlias(line);
    if (alias) return field(alias, 96, "ocr");
  }

  const directSlot = fuzzyFindKnown(text, slotNames, 0.68);
  if (directSlot) return field(directSlot.value, Math.round(directSlot.score * 100), directSlot.score >= 0.95 ? "ocr" : "fallback");

  const derivedSlot = artifactName.value ? pieceToSlot.get(artifactName.value) ?? "" : "";
  return derivedSlot ? field(derivedSlot, derivedConfidence(artifactName, 94), "derived") : field("", 0, "missing");
}

function parseSetName(setText: string, artifactName: ParsedField): ParsedField {
  const setFromPiece = artifactName.value ? pieceToSet.get(artifactName.value) : undefined;
  const candidateLines = setText
    .split("\n")
    .map((line) => line.trim().replace(/:$/, ""))
    .filter((line) => line.length > 3 && !/^\d/.test(line) && !/piece set/i.test(line));

  for (const line of candidateLines) {
    const match = matchSet(line);
    if (match.value) {
      return field(match.value, match.confidence, match.source === "exact" || match.source === "alias" ? "database" : "fallback");
    }
    const alias = normalizeSetAlias(line);
    if (alias) return field(alias, 96, "database");
  }

  const directLine = candidateLines.find((line) => line.length > 8);

  const setFromText = fuzzyFindKnown(`${directLine ?? ""}\n${setText}`, knownSets, 0.64);
  if (setFromText && (!setFromPiece || setFromText.score >= 0.78)) return field(setFromText.value, Math.round(setFromText.score * 100), setFromText.score >= 0.95 ? "ocr" : "fallback");
  if (setFromPiece) return field(setFromPiece, derivedConfidence(artifactName, 92), "derived");
  const partialSetFromPiece = deriveSetFromPartialPieceName(artifactName.value);
  if (partialSetFromPiece) return field(partialSetFromPiece, 72, "derived");
  return setFromText ? field(setFromText.value, Math.round(setFromText.score * 100), "fallback") : field("", 0, "missing");
}

function derivedConfidence(sourceField: ParsedField, maxConfidence: number) {
  if (sourceField.source === "database" || sourceField.confidence >= maxConfidence) return maxConfidence;
  return Math.max(45, Math.min(maxConfidence, sourceField.confidence));
}

function parseArtifactLevel(text: string): ParsedField {
  const lines = normalizeText(text)
    .split("\n")
    .map((line) => line.trim())
    .filter(Boolean);

  for (const line of lines) {
    const match = line.match(/^\+\s*(20|1[0-9]|[0-9])\b/);
    if (match?.[1]) return field(match[1], 96, "ocr");
  }

  const anywhere = normalizeText(text).match(/(?:^|\s)\+\s*(20|1[0-9]|[0-9])\b/);
  return anywhere?.[1] ? field(anywhere[1], 84, "ocr") : field("", 0, "missing");
}

function normalizeText(text: string) {
  return applyTextReplacements(text)
    .replace(/[\u201c\u201d]/g, '"')
    .replace(/[\u2019]/g, "'")
    .replace(/[\u00B7]/g, ".")
    .replace(/\r/g, "")
    .replace(/[|]/g, "I")
    .replace(/\s+\n/g, "\n")
    .trim();
}

function applyTextReplacements(text: string) {
  return Object.entries(textReplacements as Record<string, string>).reduce(
    (current, [from, to]) => current.replace(new RegExp(escapeRegex(from), "gi"), to),
    text,
  );
}

function firstUsefulLine(text: string, rejectIncludes: string[]) {
  return text
    .split("\n")
    .map((line) => line.trim())
    .find((line) => line.length > 5 && !rejectIncludes.some((reject) => simplifyForMatch(line).includes(simplifyForMatch(reject)))) ?? "";
}

function deriveSetFromPartialPieceName(text: string) {
  const words = cleanupOcrLabel(text)
    .split(/\s+/)
    .map((word) => simplifyForMatch(word))
    .filter((word) => word.length >= 5);
  if (words.length < 2) return "";

  const candidates = knownPieceNames.filter((piece) => {
    const normalizedPiece = simplifyForMatch(piece);
    const hits = words.filter((word) => normalizedPiece.includes(word)).length;
    return hits >= 2;
  });
  const sets = [...new Set(candidates.map((piece) => pieceToSet.get(piece)).filter((set): set is string => Boolean(set)))];
  return sets.length === 1 ? sets[0] : "";
}

function derivePieceFromDistinctivePartialName(text: string) {
  const words = cleanupOcrLabel(text)
    .split(/\s+/)
    .map((word) => simplifyForMatch(word))
    .filter((word) => word.length >= 8);
  if (words.length === 0) return "";

  const candidates = knownPieceNames.filter((piece) => {
    const normalizedPiece = simplifyForMatch(piece);
    return words.some((word) => normalizedPiece.includes(word));
  });
  return candidates.length === 1 ? candidates[0] : "";
}

function findMainValue(text: string, mainStat: string, slot: string, level: number | null): ParsedField {
  const cleaned = text.replace(/\b20\b/g, " ").replace(/[Oo]/g, "0");
  const percentValue = extractPercentValue(cleaned);
  let ocrField = field("", 0, "missing");
  if (percentValue && !mainStat) ocrField = field(percentValue, 84, "ocr");
  if (percentValue && isPercentMainStat(mainStat)) ocrField = field(percentValue, 96, "ocr");
  const flat = /\b([0-9]{1,2},[0-9]{3}|[0-9]{2,4})\b/.exec(cleaned);
  if (!ocrField.value && flat) ocrField = field(flat[1], 92, "ocr");

  const derivedField = deriveMainValueFromLevel(slot, mainStat, level);
  if (!ocrField.value) return derivedField;
  if (!derivedField.value) return ocrField;

  if (["HP", "ATK", "DEF", "Elemental Mastery"].includes(mainStat)) {
    const ocrNumeric = parseNumericValue(ocrField.value);
    const derivedNumeric = parseNumericValue(derivedField.value);
    const derivedIntDigits = String(Math.round(derivedNumeric)).length;
    const ocrIntDigits = String(Math.round(ocrNumeric)).length;
    if (!Number.isFinite(ocrNumeric) || ocrNumeric < derivedNumeric * 0.5 || ocrIntDigits + 1 < derivedIntDigits) return derivedField;
    if (Math.abs(ocrNumeric - derivedNumeric) >= Math.max(4, derivedNumeric * 0.22)) return derivedField;
  }

  return ocrField;
}

function extractPercentValue(text: string) {
  const percentPattern = /([0-9]{1,3}(?:\s*[.,:\u00B7]\s*[0-9])?)\s*%/;
  const lineMatches = text
    .split("\n")
    .map((line) => line.match(percentPattern))
    .filter((match): match is RegExpMatchArray => Boolean(match));

  const preferred = lineMatches[0] ?? text.match(percentPattern);
  if (!preferred?.[1]) return "";
  return `${normalizeMainValue(preferred[1])}%`;
}

function inferMainStat(slot: string, text: string): ParsedField {
  if (fixedMainStatBySlot[slot]) return field(fixedMainStatBySlot[slot], 100, "derived");

  const direct = findDirectMainStat(text);
  if (direct) return field(promotePercentVariant(direct, text), 94, "ocr");

  const allowedForSlot = sortLongestFirst(allowedMainStatsForSlot(slot));
  const lookup = matchStat(text);
  if (lookup.value && allowedForSlot.includes(lookup.value)) {
    return field(promotePercentVariant(lookup.value, text), lookup.confidence, lookup.source === "fuzzy" ? "fallback" : "ocr");
  }
  const fuzzyAllowed = fuzzyFindKnown(text, allowedForSlot, 0.68);
  if (fuzzyAllowed) return field(promotePercentVariant(fuzzyAllowed.value, text), Math.round(fuzzyAllowed.score * 100), "fallback");

  const fuzzy = fuzzyFindKnown(text, mainStatNames, 0.72);
  return fuzzy ? field(promotePercentVariant(fuzzy.value, text), Math.round(fuzzy.score * 100), "fallback") : field("", 0, "missing");
}

function findDirectMainStat(text: string) {
  const compact = simplifyForMatch(text);
  const hasPercentValue = /[0-9]{1,3}(?:\s*[.,:\u00B7]\s*[0-9])?\s*%/.test(text);
  const priority = [
    "Physical DMG Bonus",
    "Elemental Mastery",
    "Energy Recharge",
    "Healing Bonus",
    "Hydro DMG Bonus",
    "Pyro DMG Bonus",
    "Electro DMG Bonus",
    "Cryo DMG Bonus",
    "Dendro DMG Bonus",
    "Anemo DMG Bonus",
    "Geo DMG Bonus",
    "CRIT Rate",
    "CRIT DMG",
    "ATK%",
    "HP%",
    "DEF%",
    "ATK",
    "HP",
    "DEF",
  ];

  const direct = priority.find((stat) => compact.includes(simplifyForMatch(stat))) ?? "";
  if (direct) return direct;

  if (hasPercentValue && /(^|\s)atk(\s|$)/i.test(text)) return "ATK%";
  if (hasPercentValue && /(^|\s)hp(\s|$)/i.test(text)) return "HP%";
  if (hasPercentValue && /(^|\s)def(\s|$)/i.test(text)) return "DEF%";
  if (hasPercentValue && /(^|\s)dlt(\s|$)/i.test(text)) return "DEF%";

  return "";
}

function inferMainStatFromValue(slot: string, mainValue: string, text: string, level: number | null): ParsedField {
  const numeric = Number.parseFloat(normalizeMainValue(mainValue).replace("%", ""));
  if (!Number.isFinite(numeric)) return field("", 0, "missing");

  const candidates = getSlotMainStatValueReferences(slot)
    .map((candidate) => {
      const expected = expectedMainStatValue(candidate, level);
      return {
        ...candidate,
        expected,
        delta: Math.abs(expected - numeric),
      };
    })
    .sort((left, right) => left.delta - right.delta);

  const best = candidates[0];
  const tolerance = toleranceForMainStatValue(best?.stat ?? "", mainValue);
  const competing = candidates.filter((candidate) => candidate.delta <= tolerance);
  if (best && competing.length === 1) {
    return field(promotePercentVariant(best.stat, text), Math.max(72, Math.round(92 - best.delta * 24)), "derived");
  }

  return field("", 0, "missing");
}

function deriveMainStatFromExactReferenceValue(slot: string, mainValue: string, text: string, level: number | null): ParsedField {
  const numeric = Number.parseFloat(normalizeMainValue(mainValue).replace("%", ""));
  if (!Number.isFinite(numeric)) return field("", 0, "missing");

  const matches = getSlotMainStatValueReferences(slot)
    .filter((candidate) => Math.abs(expectedMainStatValue(candidate, level) - numeric) <= toleranceForMainStatValue(candidate.stat, mainValue))
    .sort((left, right) => Math.abs(expectedMainStatValue(left, level) - numeric) - Math.abs(expectedMainStatValue(right, level) - numeric));

  if (matches.length !== 1) return field("", 0, "missing");
  return field(promotePercentVariant(matches[0].stat, text || mainValue), 88, "derived");
}

function deriveMainStatAndValueFromNoisyReference(slot: string, text: string, level: number | null) {
  const fragment = text.replace(/[^\d]/g, "");
  if (fragment.length < 2) {
    return {
      mainStat: field("", 0, "missing"),
      mainValue: field("", 0, "missing"),
    };
  }

  const candidates = getSlotMainStatValueReferences(slot)
    .map((candidate) => {
      const formattedValue = formatExpectedValue(candidate, level);
      const digits = formattedValue.replace(/[^\d]/g, "");
      return {
        candidate,
        formattedValue,
        score: digitReferenceScore(fragment, digits),
      };
    })
    .filter((entry) => entry.score > 0)
    .sort((left, right) => right.score - left.score);

  const best = candidates[0];
  const second = candidates[1];
  if (!best) {
    return {
      mainStat: field("", 0, "missing"),
      mainValue: field("", 0, "missing"),
    };
  }
  if (second && best.score - second.score < 0.2) {
    return {
      mainStat: field("", 0, "missing"),
      mainValue: field("", 0, "missing"),
    };
  }

  return {
    mainStat: field(promotePercentVariant(best.candidate.stat, text), Math.round(72 + best.score * 18), "derived"),
    mainValue: field(best.formattedValue, Math.round(78 + best.score * 14), "derived"),
  };
}

function parseSubstats(text: string) {
  const normalized = normalizeText(text)
    .replace(/CRIT\s*DMG/gi, "CRIT DMG")
    .replace(/CRIT\s*Rate/gi, "CRIT Rate")
    .replace(/Energy\s*Recharge/gi, "Energy Recharge")
    .replace(/Elemental\s*Mastery/gi, "Elemental Mastery")
    .replace(/([A-Z]{2,4})\s*\+/g, "$1+");

  const statPattern = new RegExp(`(${substatNames.map(escapeRegex).join("|")})\\s*\\+\\s*([0-9]+(?:\\.[0-9])?%?)`, "gi");
  const results: string[] = [];
  let match: RegExpExecArray | null;
  while ((match = statPattern.exec(normalized))) {
    const stat = canonicalSubstatName(match[1], match[2]);
    results.push(`${stat}+${match[2]}`);
  }
  return [...new Set(results)].slice(0, 4);
}

function leadingSetEffectText(text: string) {
  const lines = normalizeText(text).split("\n");
  const result: string[] = [];
  for (const line of lines) {
    if (/^\s*\d+\s*-\s*Piece Set/i.test(line) || /piece set/i.test(line)) break;
    result.push(line);
  }
  return result.join("\n");
}

function canonicalSubstatName(rawStat: string, rawValue: string) {
  const cleaned = rawStat.replace(/\s+/g, " ").trim();
  const known = canonicalStatName(cleaned) || fuzzyFindKnown(cleaned, substatNames, 0.8)?.value || cleaned;
  const canonical = canonicalStatName(known);
  if (["ATK", "HP", "DEF"].includes(canonical) && rawValue.includes("%")) return `${canonical}%`;
  return canonical;
}

function parseEquippedCharacter(text: string): ParsedField {
  const equippedLine = text
    .split("\n")
    .map((line) => line.trim())
    .find((line) => /equipped/i.test(line));

  if (!equippedLine) return field("Not detected", 45, "missing");

  const afterLabel = cleanupCharacterNoise(equippedLine);
  const match = afterLabel ? matchCharacter(afterLabel) : null;
  if (match?.value) {
    return field(match.value, match.confidence, match.source === "fuzzy" ? "fallback" : "database");
  }
  const alias = afterLabel ? normalizeCharacterAlias(afterLabel) : "";
  if (alias) return field(alias, 96, "database");
  const known = afterLabel ? fuzzyFindKnown(afterLabel, knownCharacters, 0.6) : null;
  if (known) return field(known.value, Math.round(known.score * 100), known.score >= 0.95 ? "ocr" : "fallback");

  const fallbackSearch = cleanupCharacterNoise(text);
  const wholeTextMatch = fallbackSearch ? fuzzyFindKnown(fallbackSearch, knownCharacters, 0.88) : null;
  if (wholeTextMatch) return field(wholeTextMatch.value, Math.round(wholeTextMatch.score * 100), "fallback");

  return field("Not detected", 45, "missing");
}

function field(value: string, confidence: number, source: ParsedField["source"]): ParsedField {
  return { value, confidence: Math.max(0, Math.min(100, confidence)), source };
}

function isPercentMainStat(stat: string) {
  return /%|Rate|DMG|Bonus|Recharge/i.test(stat);
}

function promotePercentVariant(stat: string, text: string) {
  if (["ATK", "HP", "DEF"].includes(stat) && /[0-9]{1,3}(?:\s*[.,:\u00B7]\s*[0-9])?\s*%/.test(text)) return `${stat}%`;
  return stat;
}

function promoteSlotPercentMainStat(slot: string, mainStat: ParsedField): ParsedField {
  if (!["ATK", "HP", "DEF"].includes(mainStat.value)) return mainStat;
  const references = getSlotMainStatValueReferences(slot);
  const hasFlat = references.some((candidate) => candidate.stat === mainStat.value);
  const hasPercent = references.some((candidate) => candidate.stat === `${mainStat.value}%`);
  if (hasFlat || !hasPercent) return mainStat;
  return {
    ...mainStat,
    value: `${mainStat.value}%`,
    confidence: Math.max(mainStat.confidence, 90),
    source: "derived",
  };
}

function getSlotMainStatValueReferences(slot: string): MainStatValueReference[] {
  const valueReferences = mainStatValueReferences[slot];
  return Array.isArray(valueReferences) ? valueReferences as MainStatValueReference[] : [];
}

function normalizeMainValue(value: string) {
  return value.replace(/[:,\u00B7]/g, ".").replace(/\s+/g, "");
}

function deriveMainValueFromLevel(slot: string, mainStat: string, level: number | null): ParsedField {
  if (!mainStat) return field("", 0, "missing");
  const reference = getSlotMainStatValueReferences(slot).find((candidate) => candidate.stat === mainStat);
  if (!reference) return field("", 0, "missing");
  if (level === null) {
    if (slot === "Flower of Life" || slot === "Plume of Death") return field(formatExpectedValue(reference, null), 72, "derived");
    return field("", 0, "missing");
  }
  if (level < 0 || level > 20) return field("", 0, "missing");
  return field(formatExpectedValue(reference, level), 88, "derived");
}

function expectedMainStatValue(reference: { base: number; max: number }, level: number | null) {
  if (level === null || !Number.isFinite(level)) return reference.max;
  const clampedLevel = Math.max(0, Math.min(20, level));
  return reference.base + (reference.max - reference.base) * (clampedLevel / 20);
}

function formatExpectedValue(reference: { stat: string; base: number; max: number }, level: number | null) {
  const numeric = expectedMainStatValue(reference, level);
  const rounded = isPercentMainStat(reference.stat)
    ? roundTo(numeric, 1)
    : Math.round(numeric);
  return isPercentMainStat(reference.stat) ? `${rounded.toFixed(1)}%` : rounded.toLocaleString("en-US");
}

function toleranceForMainStatValue(stat: string, mainValue: string) {
  if (mainValue.includes("%") || isPercentMainStat(stat)) return 0.45;
  if (stat === "Elemental Mastery") return 2.5;
  return 6;
}

function parseNumericValue(value: string) {
  return Number.parseFloat(
    value
      .replace(/,/g, "")
      .replace("%", "")
      .trim(),
  );
}

function roundTo(value: number, digits: number) {
  const factor = 10 ** digits;
  return Math.round(value * factor) / factor;
}

function digitReferenceScore(fragment: string, referenceDigits: string) {
  if (!fragment || !referenceDigits) return 0;
  if (fragment === referenceDigits) return 1;
  if (referenceDigits.startsWith(fragment)) {
    return Math.max(0, 0.95 - (referenceDigits.length - fragment.length) * 0.08);
  }
  if (fragment.length >= 3 && isDigitSubsequence(fragment, referenceDigits)) {
    return 0.72;
  }
  return 0;
}

function isDigitSubsequence(fragment: string, referenceDigits: string) {
  let index = 0;
  for (const char of referenceDigits) {
    if (char === fragment[index]) index++;
    if (index >= fragment.length) return true;
  }
  return false;
}

function cleanupOcrLabel(line: string) {
  return line
    .replace(/^[^A-Za-z]+/, "")
    .replace(/[^A-Za-z'\s]+$/g, "")
    .replace(/\s+/g, " ")
    .trim();
}

function cleanupCharacterNoise(text: string) {
  return text
    .replace(/^.*?equipped\s*:?\s*/i, "")
    .replace(/^(?:by|to)\s+/i, "")
    .replace(/[^A-Za-z'\-\s]/g, " ")
    .replace(/\s+/g, " ")
    .trim();
}

function sortLongestFirst(values: string[]) {
  return [...values].sort((a, b) => b.length - a.length);
}

function escapeRegex(value: string) {
  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}