Function importMatchResults

Source

export async function importMatchResults(
  file: File,
  options: ImportOptions,
): Promise<{
  imported: number;
  merged: number;
  skipped: number;
  conflicts: number;
}> {
  // Parse and validate file
  const importedData = await parseImportFile(file);
  const validation = validateImportedMatchData(importedData);

  if (!validation.valid) {
    throw createError(
      ErrorType.IMPORT,
      `Import validation failed:\n${validation.errors.join("\n")}`,
      new Error(validation.errors.join("; ")),
      "VALIDATION_FAILED",
    );
  }

  // Get existing results
  const existingResults = storage.getItem(STORAGE_KEYS.MATCH_RESULTS);
  const existingMatches: MatchResult[] = existingResults
    ? JSON.parse(existingResults)
    : [];

  // Apply appropriate merge strategy
  let strategyResult: {
    finalMatches: MatchResult[];
    imported: number;
    merged: number;
    skipped: number;
    conflicts: number;
  };

  if (options.strategy === "replace") {
    strategyResult = applyReplaceStrategy(importedData.matches);
  } else if (options.strategy === "skip-duplicates") {
    strategyResult = applySkipDuplicatesStrategy(
      importedData.matches,
      existingMatches,
    );
  } else {
    strategyResult = await applyMergeStrategy(
      importedData.matches,
      existingMatches,
    );
  }

  // Save results to storage
  storage.setItem(
    STORAGE_KEYS.MATCH_RESULTS,
    JSON.stringify(strategyResult.finalMatches),
  );

  // Update cache version
  const cacheVersion = storage.getItem(STORAGE_KEYS.CACHE_VERSION) || "1";
  const nextVersion = (Number.parseInt(cacheVersion, 10) + 1).toString();
  storage.setItem(STORAGE_KEYS.CACHE_VERSION, nextVersion);

  return {
    imported: strategyResult.imported,
    merged: strategyResult.merged,
    skipped: strategyResult.skipped,
    conflicts: strategyResult.conflicts,
  };
}
Copy