import {
  normalizeReviewDecision,
  type ReviewDecision,
} from "../../../schema/src/decisions/decision.js";
import {
  compareAndSwapGeneration,
  readStoreGeneration,
  withStoreLock,
} from "../store/concurrency.js";
import {
  loadDecisionStore,
  persistFinalizedDecisions,
  readDecisionIndex,
  type FinalizeResult,
  validateStagedDecisions,
} from "./store.js";

export async function finalizeDecisions(
  root: string,
  staged: ReviewDecision[],
): Promise<FinalizeResult> {
  const normalizedStaged = staged.map((decision) => normalizeReviewDecision(decision));

  return withStoreLock(root, async () => {
    const currentGeneration = await readStoreGeneration(root);
    const store = await loadDecisionStore(root);
    const { normalized, deactivatedIds } = validateStagedDecisions(normalizedStaged, store);
    const currentIndex = await readDecisionIndex(root);

    await compareAndSwapGeneration(
      root,
      currentGeneration,
      currentGeneration + 1,
      normalizedStaged,
    );

    await persistFinalizedDecisions(root, normalized, deactivatedIds, currentIndex);

    return {
      finalized: normalized,
      deactivatedIds,
    };
  });
}