ChallengeService.ts

/**
 * This service provides operations of challenge.
 */
const _ = require("lodash");
const Joi = require("joi");
const { Prisma } = require("@prisma/client");
const { v4: uuid } = require("uuid");
const config = require("config");
const xss = require("xss");
const helper = require("../common/helper");
const logger = require("../common/logger");
const errors = require("../common/errors");
const constants = require("../../app-constants");
const ChallengeTimelineTemplateService = require("./ChallengeTimelineTemplateService");
const { BadRequestError } = require("../common/errors");

const phaseHelper = require("../common/phase-helper");
const projectHelper = require("../common/project-helper");
const challengeHelper = require("../common/challenge-helper");
const { getReviewClient } = require("../common/review-prisma");

const PhaseAdvancer = require("../phase-management/PhaseAdvancer");

const { hasAdminRole } = require("../common/role-helper");
const { enrichChallengeForResponse, convertToISOString } = require("../common/challenge-helper");
const deepEqual = require("deep-equal");
const prismaHelper = require("../common/prisma-helper");

const {
  getClient,
  ReviewTypeEnum,
  DiscussionTypeEnum,
  ChallengeStatusEnum,
  PrizeSetTypeEnum,
  ReviewOpportunityTypeEnum,
} = require("../common/prisma");
const prisma = getClient();

const BILLING_MARKUP_COPILOT_ROLES = new Set(["copilot", "connect copilot"]);
const BILLING_MARKUP_VISIBLE_ROLES = new Set([
  "administrator",
  "connect admin",
  "connect manager",
  "project manager",
  "topcoder project manager",
  "talent manager",
  "topcoder talent manager",
]);
const CHALLENGE_BILLING_LOCK_STATUSES = new Set([
  ChallengeStatusEnum.DRAFT,
  ChallengeStatusEnum.APPROVED,
  ChallengeStatusEnum.ACTIVE,
]);

const CHALLENGE_APPROVAL_STATUS = {
  PENDING_APPROVAL: "PENDING_APPROVAL",
  APPROVED: "APPROVED",
  REJECTED: "REJECTED",
};
const CHALLENGE_APPROVAL_ACTION_STATUSES = new Set([
  CHALLENGE_APPROVAL_STATUS.APPROVED,
  CHALLENGE_APPROVAL_STATUS.REJECTED,
]);

const DEFAULT_ESTIMATED_SUBMISSIONS_COUNT = 2;
const CHECKPOINT_SUBMISSION_TYPE = "CHECKPOINT_SUBMISSION";

// Provide aliases for friendlier sortBy query params
const sortByAliases = {
  updated: constants.validChallengeParams.Updated,
  created: constants.validChallengeParams.Created,
};

const allowedSortByValues = _.uniq([
  ..._.values(constants.validChallengeParams),
  ...Object.keys(sortByAliases),
]);

const CANCELLED_CHALLENGE_STATUSES = new Set([
  ChallengeStatusEnum.CANCELLED,
  ChallengeStatusEnum.CANCELLED_REQUIREMENTS_INFEASIBLE,
  ChallengeStatusEnum.CANCELLED_PAYMENT_FAILED,
  ChallengeStatusEnum.CANCELLED_FAILED_REVIEW,
  ChallengeStatusEnum.CANCELLED_FAILED_SCREENING,
  ChallengeStatusEnum.CANCELLED_ZERO_SUBMISSIONS,
  ChallengeStatusEnum.CANCELLED_WINNER_UNRESPONSIVE,
  ChallengeStatusEnum.CANCELLED_CLIENT_REQUEST,
  ChallengeStatusEnum.CANCELLED_ZERO_REGISTRATIONS,
]);

const TERMINAL_CHALLENGE_STATUSES = new Set([
  ChallengeStatusEnum.COMPLETED,
  ...CANCELLED_CHALLENGE_STATUSES,
]);

/**
 * Determines whether a challenge status is one of the terminal cancelled states.
 * @param {String} status challenge status from the update payload or stored challenge
 * @returns {Boolean} true when the status represents a cancelled challenge
 */
function isCancelledChallengeStatus(status) {
  return CANCELLED_CHALLENGE_STATUSES.has(status);
}

/**
 * Determines whether a challenge has reached a terminal status for test-data cleanup rules.
 * Completed and every explicit cancelled status are terminal; draft, approved, active, deleted,
 * and new challenges are not.
 *
 * @param {String} status challenge status from persistence
 * @returns {Boolean} true for COMPLETED and CANCELLED* statuses
 */
function isTerminalChallengeStatus(status) {
  return TERMINAL_CHALLENGE_STATUSES.has(status);
}

/**
 * Reads the effective test-challenge flag from metadata using strict enabled semantics.
 * Only the exact metadata pair `is_test_challenge: "true"` is enabled. Missing, false, and
 * malformed values are disabled. Update protection and deletion eligibility use this method.
 *
 * @param {Array<Object>|undefined|null} metadata challenge metadata entries
 * @returns {Boolean} true only when an exact enabled metadata entry exists
 */
function isTestChallengeMetadataEnabled(metadata) {
  return _.some(metadata, {
    name: constants.ChallengeMetadataNames.IS_TEST_CHALLENGE,
    value: "true",
  });
}

/**
 * Prevents changing test-data classification in updates that start or finish terminal.
 * Metadata arrays replace the stored array on update, so supplying an array without the flag has
 * an effective false value. Omitting the metadata property entirely preserves the stored value.
 * This guard runs before project lookups or persistence in updateChallenge.
 *
 * @param {Object} challenge current persisted challenge response
 * @param {Object} data raw validated update payload
 * @returns {void}
 * @throws {BadRequestError} when a terminal update changes the effective test-challenge flag
 */
function ensureTerminalTestChallengeMetadataIsUnchanged(challenge, data) {
  const currentStatus = _.get(challenge, "status");
  const finalStatus = _.isNil(_.get(data, "status")) ? currentStatus : _.get(data, "status");
  if (
    _.isNil(data) ||
    (!isTerminalChallengeStatus(currentStatus) && !isTerminalChallengeStatus(finalStatus)) ||
    !Object.prototype.hasOwnProperty.call(data, "metadata")
  ) {
    return;
  }

  const currentFlag = isTestChallengeMetadataEnabled(_.get(challenge, "metadata"));
  const requestedFlag = isTestChallengeMetadataEnabled(data.metadata);
  if (currentFlag !== requestedFlag) {
    throw new errors.BadRequestError(
      "is_test_challenge metadata cannot be changed when a challenge is or becomes COMPLETED or CANCELLED",
    );
  }
}

/**
 * Loads submission counters for challenge responses from the review submission table.
 *
 * Community app badges normally show the number of members with submissions,
 * so repeated uploads by the same member are counted once. Design challenges
 * count every submission because each upload can be a unique concept.
 *
 * @param {Array<String>} challengeIds challenge identifiers to count submissions for
 * @param {Array<String>} designChallengeIds Design challenge identifiers that count every upload
 * @returns {Promise<Map<String, { numOfSubmissions: Number, numOfCheckpointSubmissions: Number }>>}
 * counts keyed by challenge id
 * @throws {Error} when the review database query fails
 */
async function getLatestSubmissionCountsByChallenge(challengeIds, designChallengeIds = []) {
  const ids = _.uniq(
    (challengeIds || [])
      .map((challengeId) => _.toString(challengeId).trim())
      .filter((challengeId) => !!challengeId),
  );
  const designIds = _.uniq(
    (designChallengeIds || [])
      .map((challengeId) => _.toString(challengeId).trim())
      .filter((challengeId) => !!challengeId),
  );
  const countsByChallenge = new Map();

  if (!ids.length || !config.REVIEW_DB_URL) {
    return countsByChallenge;
  }

  const reviewSchema = _.toString(config.REVIEW_DB_SCHEMA || "").trim();
  const submissionTable = reviewSchema
    ? Prisma.raw(`"${reviewSchema.replace(/"/g, '""')}"."submission"`)
    : Prisma.raw('"submission"');
  const submissionIdentity = designIds.length
    ? Prisma.sql`CASE
        WHEN "challengeId" IN (${Prisma.join(designIds)}) THEN "id"
        ELSE "memberId"
      END`
    : Prisma.sql`"memberId"`;
  const reviewClient = getReviewClient();

  const rows = await reviewClient.$queryRaw`
    SELECT
      "challengeId",
      COUNT(DISTINCT CASE
        WHEN "type"::text = ${CHECKPOINT_SUBMISSION_TYPE} THEN ${submissionIdentity}
      END)::int AS "numOfCheckpointSubmissions",
      COUNT(DISTINCT CASE
        WHEN "type"::text <> ${CHECKPOINT_SUBMISSION_TYPE} THEN ${submissionIdentity}
      END)::int AS "numOfSubmissions"
    FROM ${submissionTable}
    WHERE "challengeId" IN (${Prisma.join(ids)})
      AND "memberId" IS NOT NULL
    GROUP BY "challengeId"
  `;

  rows.forEach((row) => {
    countsByChallenge.set(_.toString(row.challengeId), {
      numOfSubmissions: Number(row.numOfSubmissions || 0),
      numOfCheckpointSubmissions: Number(row.numOfCheckpointSubmissions || 0),
    });
  });

  return countsByChallenge;
}

/**
 * Applies submission counts to challenge records before response conversion.
 *
 * Design challenges count every submission as a separate concept. Other tracks
 * count distinct submitting members so replacement attempts do not inflate the
 * displayed total.
 *
 * If the review query succeeds, challenges without submission rows are reset to
 * zero so stale stored counters are not shown. If the query cannot run, callers
 * keep the stored counters and log a warning instead of failing challenge reads.
 *
 * @param {Array<Object>} challenges challenge records being returned by the API
 * @returns {Promise<void>}
 */
async function applyLatestSubmissionCounts(challenges) {
  const records = (challenges || []).filter((challenge) => challenge && challenge.id);
  if (!records.length || !config.REVIEW_DB_URL) {
    return;
  }

  let countsByChallenge;
  try {
    const designChallengeIds = records
      .filter((challenge) => phaseHelper.isDesignTrack(challenge.track))
      .map((challenge) => challenge.id);
    countsByChallenge = await getLatestSubmissionCountsByChallenge(
      records.map((challenge) => challenge.id),
      designChallengeIds,
    );
  } catch (err) {
    logger.warn(`Failed to load latest submission counts: ${err.message}`);
    return;
  }

  records.forEach((challenge) => {
    const counts = countsByChallenge.get(_.toString(challenge.id)) || {
      numOfSubmissions: 0,
      numOfCheckpointSubmissions: 0,
    };
    challenge.numOfSubmissions = counts.numOfSubmissions;
    challenge.numOfCheckpointSubmissions = counts.numOfCheckpointSubmissions;
  });
}

/**
 * Loads the latest non-checkpoint Marathon Match submission per member from
 * the review database.
 *
 * The close flow uses this to avoid selecting winners before parallel system
 * scoring has produced a final summation for every member's latest attempt.
 *
 * @param {String} challengeId challenge identifier
 * @returns {Promise<Array<Object>>} latest submission rows keyed by member
 */
async function getLatestMarathonMatchSubmissions(challengeId) {
  if (!config.REVIEW_DB_URL) {
    return [];
  }

  const reviewSchema = _.toString(config.REVIEW_DB_SCHEMA || "").trim();
  const submissionTable = reviewSchema
    ? Prisma.raw(`"${reviewSchema.replace(/"/g, '""')}"."submission"`)
    : Prisma.raw('"submission"');
  const reviewClient = getReviewClient();

  return reviewClient.$queryRaw`
    SELECT
      "id",
      "memberId",
      "submittedDate",
      "createdAt",
      "updatedAt"
    FROM (
      SELECT
        "id",
        "memberId",
        "submittedDate",
        "createdAt",
        "updatedAt",
        ROW_NUMBER() OVER (
          PARTITION BY "memberId"
          ORDER BY
            COALESCE("isLatest", false) DESC,
            COALESCE("submittedDate", "createdAt", "updatedAt") DESC,
            "id" DESC
        ) AS "rowNumber"
      FROM ${submissionTable}
      WHERE "challengeId" = ${challengeId}
        AND "memberId" IS NOT NULL
        AND COALESCE("type"::text, '') <> ${CHECKPOINT_SUBMISSION_TYPE}
        AND COALESCE("status"::text, '') <> 'DELETED'
    ) ranked
    WHERE "rowNumber" = 1
  `;
}

/**
 * Normalizes identifiers used to match review summations to submissions.
 * @param {*} value raw identifier value
 * @returns {String} trimmed identifier, or an empty string when absent
 */
function normalizeMatchId(value) {
  return _.toString(value || "").trim();
}

/**
 * Reads a review summation timestamp for latest-result comparisons.
 * @param {Object} summation review summation returned by Review API
 * @returns {Number} timestamp in milliseconds, or zero when unavailable
 */
function getReviewSummationTimestampValue(summation) {
  const candidate =
    _.get(summation, "reviewedDate") ||
    _.get(summation, "updatedAt") ||
    _.get(summation, "createdAt");
  const timestamp = new Date(candidate).getTime();
  return Number.isFinite(timestamp) ? timestamp : 0;
}

/**
 * Compares two review summations for the same submission or submitter.
 * Newer summations win; ties keep the higher score.
 *
 * @param {Object|null} current currently selected summation
 * @param {Object} candidate summation being considered
 * @returns {Boolean} true when candidate should replace current
 */
function shouldReplaceSelectedReviewSummation(current, candidate) {
  if (!current) {
    return true;
  }

  const currentTimestamp = getReviewSummationTimestampValue(current);
  const candidateTimestamp = getReviewSummationTimestampValue(candidate);
  if (candidateTimestamp !== currentTimestamp) {
    return candidateTimestamp > currentTimestamp;
  }

  return Number(candidate.aggregateScore) > Number(current.aggregateScore);
}

/**
 * Finds the newest submission-scoped review summation per submitter.
 *
 * This is used as a fallback completeness signal when latest submission rows
 * cannot be read directly from the review database.
 *
 * @param {Array<Object>} reviewSummations review summations returned by Review API
 * @returns {Map<String, Object>} latest submission-scoped summation by submitter id
 */
function getLatestSubmissionScopedSummationsBySubmitter(reviewSummations) {
  const latestBySubmitter = new Map();

  (Array.isArray(reviewSummations) ? reviewSummations : []).forEach((summation) => {
    const submitterId = normalizeMatchId(summation.submitterId);
    const submissionId = normalizeMatchId(summation.submissionId);
    if (!submitterId || !submissionId) {
      return;
    }

    if (shouldReplaceSelectedReviewSummation(latestBySubmitter.get(submitterId), summation)) {
      latestBySubmitter.set(submitterId, summation);
    }
  });

  return latestBySubmitter;
}

/**
 * Selects the final summations that should determine Marathon Match winners.
 *
 * When latest submission rows are available, every latest submission must have
 * a matching final summation. Without submission rows, the function uses the
 * newest submission-scoped summation per submitter as a fallback completeness
 * signal before ranking the newest final summation per submitter.
 *
 * @param {String} challengeId challenge identifier used in error messages
 * @param {Array<Object>} reviewSummations all review summations
 * @param {Array<Object>} finalSummations final review summations
 * @param {Array<Object>} latestSubmissions latest submission rows
 * @returns {Array<Object>} selected final summations to rank
 * @throws {BadRequestError} when any latest submission or fallback latest
 * submitter summation has no final summation
 */
function selectMarathonMatchWinnerSummations(
  challengeId,
  reviewSummations,
  finalSummations,
  latestSubmissions,
) {
  if (!Array.isArray(latestSubmissions) || latestSubmissions.length === 0) {
    const latestBySubmitter = new Map();
    finalSummations.forEach((summation) => {
      const submitterId = normalizeMatchId(summation.submitterId);
      if (!submitterId) {
        return;
      }
      if (shouldReplaceSelectedReviewSummation(latestBySubmitter.get(submitterId), summation)) {
        latestBySubmitter.set(submitterId, summation);
      }
    });

    const latestKnownSummations = getLatestSubmissionScopedSummationsBySubmitter(reviewSummations);
    const missingSubmitters = [];
    latestKnownSummations.forEach((latestSummation, submitterId) => {
      const selectedFinal = latestBySubmitter.get(submitterId);
      if (
        !selectedFinal ||
        normalizeMatchId(selectedFinal.submissionId) !==
          normalizeMatchId(latestSummation.submissionId)
      ) {
        missingSubmitters.push(submitterId);
      }
    });

    if (missingSubmitters.length > 0) {
      throw new errors.BadRequestError(
        `Cannot close Marathon Match challenge ${challengeId}: final system scoring is not complete for latest submitter summations. Missing final summations for submitterIds: ${missingSubmitters
          .sort()
          .join(", ")}`,
      );
    }

    return Array.from(latestBySubmitter.values());
  }

  const finalBySubmission = new Map();
  finalSummations.forEach((summation) => {
    const submitterId = normalizeMatchId(summation.submitterId);
    const submissionId = normalizeMatchId(summation.submissionId);
    if (!submitterId || !submissionId) {
      return;
    }
    const key = `${submitterId}:${submissionId}`;
    if (shouldReplaceSelectedReviewSummation(finalBySubmission.get(key), summation)) {
      finalBySubmission.set(key, summation);
    }
  });

  const selectedSummations = [];
  const missingSubmissions = [];
  latestSubmissions.forEach((submission) => {
    const memberId = normalizeMatchId(submission.memberId);
    const submissionId = normalizeMatchId(submission.id);
    if (!memberId || !submissionId) {
      return;
    }

    const summation = finalBySubmission.get(`${memberId}:${submissionId}`);
    if (summation) {
      selectedSummations.push(summation);
    } else {
      missingSubmissions.push(submissionId);
    }
  });

  if (missingSubmissions.length > 0) {
    throw new errors.BadRequestError(
      `Cannot close Marathon Match challenge ${challengeId}: final system scoring is not complete for latest submissions. Missing final summations for submissionIds: ${missingSubmissions.join(
        ", ",
      )}`,
    );
  }

  return selectedSummations;
}

function normalizeStatusSortValue(statusValue) {
  if (_.isNil(statusValue)) {
    return null;
  }

  const normalizedStatus = _.toString(statusValue).trim().toUpperCase();
  if (!normalizedStatus) {
    return null;
  }

  return normalizedStatus;
}

function normalizeApprovalStatus(value) {
  if (_.isNil(value)) {
    return null;
  }

  const normalized = _.toString(value).trim().toUpperCase();
  if (!normalized) {
    return null;
  }

  if (!Object.values(CHALLENGE_APPROVAL_STATUS).includes(normalized)) {
    return null;
  }

  return normalized;
}

/**
 * Normalizes a configured billing-account list for membership checks.
 *
 * @param {Array<string|number>|string|number|null|undefined} billingAccountIds Billing-account ids from config.
 * @returns {Array<string>} Trimmed billing-account ids, with empty values removed.
 */
function normalizeConfiguredBillingAccountIds(billingAccountIds) {
  if (_.isNil(billingAccountIds)) {
    return [];
  }

  return _.flatMap([].concat(billingAccountIds), (billingAccountId) =>
    _.toString(billingAccountId).split(","),
  )
    .map(normalizeOptionalString)
    .filter(Boolean);
}

/**
 * Resolves the billing account that should drive challenge approval decisions.
 *
 * @param {Object|null|undefined} challenge Existing or incoming challenge payload.
 * @param {Object|null|undefined} data Incoming update payload, when applicable.
 * @param {string|number|null|undefined} projectBillingAccountId Billing account returned by the project.
 * @returns {string|null} The first available billing-account id, or `null` when none is present.
 */
function getApprovalFlowBillingAccountId(challenge, data?: any, projectBillingAccountId?: any) {
  return (
    normalizeOptionalString(projectBillingAccountId) ||
    normalizeOptionalString(_.get(data, "billing.billingAccountId")) ||
    normalizeOptionalString(_.get(challenge, "billing.billingAccountId")) ||
    normalizeOptionalString(_.get(challenge, "billingRecord.billingAccountId")) ||
    null
  );
}

/**
 * Determines whether the challenge approval flow should be bypassed.
 *
 * Fun challenges and challenges billed to configured Topgear billing accounts
 * are auto-approved because they should not enter the manual budget approval flow.
 *
 * @param {string|number|null|undefined} billingAccountId Billing-account identifier.
 * @param {boolean} [funChallenge=false] Effective Fun challenge flag from the create or update.
 * @returns {boolean} `true` when challenge approval should be skipped.
 * @throws This function does not throw.
 * @remarks Used by challenge create, update, and launch validation to apply one approval policy.
 */
function shouldSkipChallengeApprovalFlow(billingAccountId, funChallenge = false) {
  if (funChallenge === true) {
    return true;
  }

  const normalizedBillingAccountId = normalizeOptionalString(billingAccountId);

  if (!normalizedBillingAccountId) {
    return false;
  }

  return _.includes(
    normalizeConfiguredBillingAccountIds(config.TOPGEAR_BILLING_ACCOUNTS_ID),
    normalizedBillingAccountId,
  );
}

/**
 * Applies the approval-flow bypass to a challenge payload.
 *
 * @param {Object} target Challenge create or update payload to mutate.
 * @param {string|number|null|undefined} billingAccountId Billing-account identifier.
 * @param {boolean} [funChallenge=false] Effective Fun challenge flag from the create or update.
 * @returns {boolean} `true` when approval fields were forced to approved.
 * @throws This function does not intentionally throw; callers provide a mutable challenge payload.
 * @remarks Used before normal approval validation so bypassed challenges persist as approved.
 */
function applyChallengeApprovalFlowBypass(target, billingAccountId, funChallenge = false) {
  if (!shouldSkipChallengeApprovalFlow(billingAccountId, funChallenge)) {
    return false;
  }

  target.approvalStatus = CHALLENGE_APPROVAL_STATUS.APPROVED;
  target.approvalRejectionReason = null;
  target.approvalApprovedBy = null;

  return true;
}

/**
 * Determines whether challenge activation must wait for budget approval.
 *
 * @param {string|null|undefined} approvalStatus Effective approval status.
 * @param {string|number|null|undefined} billingAccountId Billing-account identifier.
 * @param {boolean} [funChallenge=false] Effective Fun challenge flag from the create or update.
 * @returns {boolean} `true` when launch should be blocked by approval state.
 * @throws This function does not throw.
 * @remarks Used when a challenge update transitions its status to Active.
 */
function shouldBlockChallengeLaunchForApproval(
  approvalStatus,
  billingAccountId,
  funChallenge = false,
) {
  return (
    !shouldSkipChallengeApprovalFlow(billingAccountId, funChallenge) &&
    normalizeApprovalStatus(approvalStatus) !== CHALLENGE_APPROVAL_STATUS.APPROVED
  );
}

async function userCanApproveChallengeBudget(currentUser, challengeOrProjectId) {
  if (!currentUser) {
    return false;
  }

  if (currentUser.isMachine || hasAdminRole(currentUser)) {
    return true;
  }

  const projectId = _.isObject(challengeOrProjectId)
    ? _.get(challengeOrProjectId, "projectId")
    : challengeOrProjectId;

  return helper.userHasProjectManagerAccess(projectId, currentUser);
}

function compareStatusSortValues(aStatusValue, bStatusValue) {
  const normalizedA = normalizeStatusSortValue(aStatusValue);
  const normalizedB = normalizeStatusSortValue(bStatusValue);

  if (normalizedA === normalizedB) {
    return _.toString(aStatusValue).localeCompare(_.toString(bStatusValue));
  }

  if (_.isNil(normalizedA)) {
    return 1;
  }
  if (_.isNil(normalizedB)) {
    return -1;
  }

  return normalizedA.localeCompare(normalizedB);
}

/**
 * Determines whether the challenge budget should remain locked.
 *
 * @param {string|undefined|null} status Challenge status from the request or persistence.
 * @returns {boolean} True when the challenge should reserve billing-account budget.
 */
function isChallengeBillingLockStatus(status) {
  return CHALLENGE_BILLING_LOCK_STATUSES.has(normalizeStatusSortValue(status));
}

/**
 * Calculates the billable USD prize-set total for a challenge.
 *
 * @param {object} challenge Challenge model or response object.
 * @returns {number|undefined} USD prize-set member-payment amount before markup,
 * or `undefined` when prize sets are not loaded.
 */
function getChallengePrizeSetMemberPaymentAmount(challenge) {
  const prizeSets = _.get(challenge, "prizeSets");

  if (!Array.isArray(prizeSets)) {
    return undefined;
  }

  return prizeSets.reduce((total, prizeSet) => {
    const prizes = Array.isArray(prizeSet && prizeSet.prizes) ? prizeSet.prizes : [];

    return (
      total +
      prizes.reduce((prizeTotal, prize) => {
        if (_.toString(_.get(prize, "type")).toUpperCase() !== constants.prizeTypes.USD) {
          return prizeTotal;
        }

        const prizeValue = _.toNumber(_.get(prize, "value"));

        return Number.isFinite(prizeValue) ? prizeTotal + prizeValue : prizeTotal;
      }, 0)
    );
  }, 0);
}

/**
 * Reads the first-place placement prize used by reviewer cost estimates.
 *
 * @param {object} challenge Challenge model or response object.
 * @returns {number|undefined} First-place USD placement prize amount, or undefined when unavailable.
 */
function getFirstPlacePrizeValue(challenge) {
  const prizeSets = _.get(challenge, "prizeSets");

  if (!Array.isArray(prizeSets)) {
    return undefined;
  }

  const placementPrizeSet = _.find(
    prizeSets,
    (prizeSet) => _.toString(_.get(prizeSet, "type")).toUpperCase() === PrizeSetTypeEnum.PLACEMENT,
  );
  const firstPrize = _.get(placementPrizeSet, "prizes[0]");

  if (_.toString(_.get(firstPrize, "type")).toUpperCase() !== constants.prizeTypes.USD) {
    return undefined;
  }

  const prizeValue = _.toNumber(_.get(firstPrize, "value"));

  return Number.isFinite(prizeValue) ? prizeValue : undefined;
}

/**
 * Calculates the estimated member-review payment amount for billing locks.
 *
 * The work app shows review cost using a two-submission estimate, so draft
 * budget locks need the same fixed and coefficient-based reviewer math.
 *
 * @param {object} challenge Challenge model or response object.
 * @returns {number} Estimated member-review payment amount before markup.
 */
function getEstimatedReviewerPaymentAmount(challenge) {
  const reviewers = _.get(challenge, "reviewers");

  if (!Array.isArray(reviewers)) {
    return 0;
  }

  const firstPlacePrizeValue = getFirstPlacePrizeValue(challenge);

  if (_.isNil(firstPlacePrizeValue)) {
    return 0;
  }

  return reviewers.reduce((total, reviewer) => {
    if (_.get(reviewer, "isMemberReview") === false) {
      return total;
    }

    const fixedAmount = _.toNumber(_.get(reviewer, "fixedAmount"));
    const baseCoefficient = _.toNumber(_.get(reviewer, "baseCoefficient"));
    const incrementalCoefficient = _.toNumber(_.get(reviewer, "incrementalCoefficient"));
    const memberReviewerCount = Math.max(
      1,
      Math.trunc(_.toNumber(_.get(reviewer, "memberReviewerCount")) || 1),
    );
    const reviewerPayment =
      (Number.isFinite(fixedAmount) ? fixedAmount : 0) +
      ((Number.isFinite(baseCoefficient) ? baseCoefficient : 0) +
        (Number.isFinite(incrementalCoefficient) ? incrementalCoefficient : 0) *
          DEFAULT_ESTIMATED_SUBMISSIONS_COUNT) *
        firstPlacePrizeValue;

    return total + reviewerPayment * memberReviewerCount;
  }, 0);
}

/**
 * Reads the currently persisted challenge member-payment total.
 *
 * @param {object} challenge Challenge model or response object.
 * @returns {number|undefined} Total USD member-payment amount before markup,
 * including estimated member-review cost when prize sets are loaded.
 */
function getChallengeMemberPaymentAmount(challenge) {
  const prizeSetMemberPaymentAmount = getChallengePrizeSetMemberPaymentAmount(challenge);

  if (!_.isNil(prizeSetMemberPaymentAmount)) {
    return Number(
      (prizeSetMemberPaymentAmount + getEstimatedReviewerPaymentAmount(challenge)).toFixed(2),
    );
  }

  const totalPrizes = _.get(
    challenge,
    "overview.totalPrizes",
    _.get(challenge, "overviewTotalPrizes"),
  );
  const amount = _.toNumber(totalPrizes);

  return Number.isFinite(amount) ? amount : undefined;
}

/**
 * Synchronizes the draft/active challenge budget lock to billing accounts.
 *
 * The challenge service owns the current estimated member-payment amount while
 * finance later consumes the finalized payment amount after payment generation.
 * This keeps draft challenge rows visible as locked budget in billing-account
 * details until finance moves the row to consumed.
 * Accounts configured to ignore challenge activation billing validation also
 * skip this lock because the Billing Accounts API validates available funds
 * when writing the lock.
 *
 * @param {object} challenge Challenge model or response object after persistence.
 * @returns {Promise<void>} Resolves after the billing-account lock is written or skipped.
 * @throws {Error} When the Billing Accounts API rejects the lock request.
 */
async function syncChallengeBillingAccountLock(challenge) {
  if (!isChallengeBillingLockStatus(challenge && challenge.status)) {
    return;
  }

  const billing = _.get(challenge, "billing", _.get(challenge, "billingRecord"));
  const billingAccountId = _.get(billing, "billingAccountId");
  const hasBillingAccountId = !_.isNil(billingAccountId) && _.toString(billingAccountId).trim();
  const memberPaymentAmount = getChallengeMemberPaymentAmount(challenge);

  if (shouldIgnoreChallengeActivationBillingValidation(billingAccountId)) {
    logger.info("Skipping challenge billing lock sync for ignored billing account", {
      billingAccountId,
      challengeId: _.get(challenge, "id"),
    });
    return;
  }

  if (!hasBillingAccountId || _.isNil(memberPaymentAmount)) {
    logger.warn("Skipping challenge billing lock sync due to missing billing context", {
      challengeId: _.get(challenge, "id"),
      hasBillingAccountId: Boolean(hasBillingAccountId),
      hasMemberPaymentAmount: !_.isNil(memberPaymentAmount),
    });
    return;
  }

  await projectHelper.lockChallengeBillingAccountAmount({
    billingAccountId,
    challengeId: challenge.id,
    markup: _.get(billing, "clientBillingRate", _.get(billing, "markup")),
    memberPaymentAmount,
  });
}

/**
 * Returns normalized role names from the authenticated user payload.
 * @param {Object} currentUser the authenticated user
 * @returns {Set<String>} lower-cased role names
 */
function getNormalizedUserRoles(currentUser) {
  const roles = _.get(currentUser, "roles", []);
  const roleValues = Array.isArray(roles)
    ? roles
    : _.toString(roles)
        .split(",")
        .map((role) => role.trim());

  return new Set(
    _.map(roleValues, (role) => _.toString(role).trim().toLowerCase()).filter(Boolean),
  );
}

/**
 * Determines whether challenge billing markup should be hidden from the caller.
 * @param {Object} currentUser the authenticated user
 * @returns {Boolean} true when the caller is copilot-only and should not see markup
 */
function shouldHideBillingMarkupForCopilot(currentUser) {
  if (!currentUser || _.get(currentUser, "isMachine", false)) {
    return false;
  }

  const roles = getNormalizedUserRoles(currentUser);
  const hasCopilotRole = [...BILLING_MARKUP_COPILOT_ROLES].some((role) => roles.has(role));

  if (!hasCopilotRole) {
    return false;
  }

  return ![...BILLING_MARKUP_VISIBLE_ROLES].some((role) => roles.has(role));
}

/**
 * Removes raw billing markup from challenge response data for copilot-only callers.
 * @param {Object} currentUser the authenticated user
 * @param {Object} challenge the challenge response object to sanitize
 * @returns {Object} the same challenge object after response sanitization
 */
function sanitizeBillingMarkupForCaller(currentUser, challenge) {
  if (shouldHideBillingMarkupForCopilot(currentUser)) {
    _.unset(challenge, "billing.markup");
  }

  return challenge;
}

/**
 * Keeps persisted billing markup intact when copilot-only callers submit billing data.
 * @param {Object} currentUser the authenticated user
 * @param {Object} data incoming update payload
 * @param {Object} challenge persisted challenge response shape
 * @returns {Object} the update payload with protected billing markup restored
 */
function preserveBillingMarkupForCopilotUpdate(currentUser, data, challenge) {
  if (
    shouldHideBillingMarkupForCopilot(currentUser) &&
    _.has(data, "billing") &&
    _.has(challenge, "billing.markup")
  ) {
    _.set(data, "billing.markup", _.get(challenge, "billing.markup"));
  }

  return data;
}

// Minimal domain adapter for PhaseAdvancer to fetch phase-specific facts.
// For now this returns an empty factResponses array which makes the
// PhaseAdvancer default to conservative behavior when such facts are needed.
// This avoids runtime errors until a richer domain is implemented.
const challengeDomain = {
  /**
   * Retrieve phase-specific facts from downstream services (stubbed).
   * @param {{ legacyId: number | null, facts: Array<number> }} _request
   * @returns {Promise<{ factResponses: Array<{ response: object }> }>}
   */
  async getPhaseFacts(_request) {
    return { factResponses: [] };
  },
};

const phaseAdvancer = new PhaseAdvancer(challengeDomain);

const REVIEW_STATUS_BLOCKING = Object.freeze(["IN_PROGRESS", "COMPLETED"]);
const CHECKPOINT_REVIEW_PHASE_NAME = "checkpoint review";
const REVIEW_PHASE_NAMES = Object.freeze([
  CHECKPOINT_REVIEW_PHASE_NAME,
  "checkpoint screening",
  "screening",
  "review",
  "approval",
]);
const REVIEW_PHASE_NAME_SET = new Set(REVIEW_PHASE_NAMES);
const REQUIRED_REVIEW_PHASE_NAME_SET = new Set([...REVIEW_PHASE_NAMES, "iterative review"]);
const AI_SCREENING_PHASE_NAME = "ai screening";
const AI_REVIEW_PHASE_NAME = "ai review";

function normalizePhaseNameForComparison(phaseName) {
  return _.toString(phaseName).replace(/-/g, " ").trim().toLowerCase();
}

/**
 * Determines whether checkpoint winners are ready to be included in challenge responses.
 * Detail and search response sanitization use this after Checkpoint Review has closed,
 * while completed challenges preserve their existing winner visibility.
 *
 * @param {Object} challenge challenge data containing status and phase state
 * @returns {Boolean} true when assigned checkpoint winners may be returned
 * @throws {Error} this function does not throw
 */
function shouldExposeCheckpointWinners(challenge) {
  if (challenge.status === ChallengeStatusEnum.COMPLETED) {
    return true;
  }
  if (challenge.status !== ChallengeStatusEnum.ACTIVE) {
    return false;
  }

  return _.some(
    challenge.phases,
    (phase) =>
      normalizePhaseNameForComparison(phase.name) === CHECKPOINT_REVIEW_PHASE_NAME &&
      phase.isOpen !== true &&
      !_.isNil(phase.actualStartDate) &&
      !_.isNil(phase.actualEndDate),
  );
}

function extractSubmissionId(submission) {
  const candidate =
    _.get(submission, "id") ||
    _.get(submission, "submissionId") ||
    _.get(submission, "legacySubmissionId");
  if (_.isNil(candidate)) {
    return null;
  }
  const normalized = _.toString(candidate).trim();
  return normalized.length > 0 ? normalized : null;
}

async function ensureChallengeHasAiReviewers(challengeId) {
  const reviewers = await prisma.challengeReviewer.findMany({
    where: { challengeId, isMemberReview: false, aiWorkflowId: { not: null } },
  });

  const hasAIReviewers = Array.isArray(reviewers) && reviewers.length > 0;

  if (!hasAIReviewers) {
    throw new errors.BadRequestError(`Challenge does not have any AI reviewers assigned`);
  }
}

async function ensureAIPhaseCanBeClosed(challengeId, phaseName = 'AI Screening') {
  logger.debug(`Validating ${phaseName} closure for challenge ${challengeId}`);
  await ensureChallengeHasAiReviewers(challengeId);

  const aiReviewConfig = await helper.getAIReviewConfigByChallengeId(challengeId);
  if (!aiReviewConfig || !aiReviewConfig.id) {
    logger.debug(
      `${phaseName} closure blocked for challenge ${challengeId}: AI review configuration not found`,
    );
    throw new errors.BadRequestError(
      `Cannot close ${phaseName} phase because AI review configuration could not be fetched`,
    );
  }

  logger.debug(`Found AI review configuration ${aiReviewConfig.id} for challenge ${challengeId}`);

  const reviewPrisma = getReviewClient();
  const reviewSchema = config.REVIEW_DB_SCHEMA;
  const submissionTable = Prisma.raw(`"${reviewSchema}"."submission"`);
  const aiReviewDecisionTable = Prisma.raw(`"${reviewSchema}"."aiReviewDecision"`);

  let submissions;
  let decisions;
  try {
    [submissions, decisions] = await Promise.all([
      reviewPrisma.$queryRaw(
        Prisma.sql`
          SELECT "id", "legacySubmissionId"
          FROM ${submissionTable}
          WHERE "challengeId" = ${challengeId}
            AND "status"::text <> 'DELETED'
        `,
      ),
      reviewPrisma.$queryRaw(
        Prisma.sql`
          SELECT "submissionId", "isFinal"
          FROM ${aiReviewDecisionTable}
          WHERE "configId" = ${aiReviewConfig.id}
        `,
      ),
    ]);
  } catch (err) {
    logger.error(
      `Failed to fetch ${phaseName} submissions/decisions for challenge ${challengeId}: ${err.message}`,
      err,
    );
    throw err;
  }

  logger.debug(
    `${phaseName} data for challenge ${challengeId}: submissions=${(submissions || []).length}, decisions=${
      (decisions || []).length
    }`,
  );

  const submissionIds = _.uniq(
    (submissions || []).map((submission) => extractSubmissionId(submission)).filter((id) => !!id),
  );
  if (submissionIds.length === 0) {
    logger.debug(`${phaseName} closure allowed for challenge ${challengeId}: no submissions found`);
    return;
  }

  const finalizedDecisionSubmissionIds = new Set(
    (decisions || [])
      .filter((decision) => decision && decision.isFinal === true)
      .map((decision) => extractSubmissionId(decision))
      .filter((id) => !!id),
  );

  const hasPendingDecision = (decisions || []).some(
    (decision) => decision && decision.isFinal !== true,
  );
  const missingFinalizedSubmissions = submissionIds.filter(
    (submissionId) => !finalizedDecisionSubmissionIds.has(submissionId),
  );

  if (hasPendingDecision || missingFinalizedSubmissions.length > 0) {
    logger.debug(
      `${phaseName} closure blocked for challenge ${challengeId}: hasPendingDecision=${hasPendingDecision}, missingFinalizedSubmissions=${missingFinalizedSubmissions.length}`,
    );
    throw new errors.BadRequestError(
      `Cannot close ${phaseName} phase because AI reviews are not complete`,
    );
  }

  logger.debug(`${phaseName} closure allowed for challenge ${challengeId}: all reviews finalized`);
}

/**
 * Enrich skills data with full details from standardized skills API.
 * @param {Object} challenge the challenge object
 * @param {Object} [options]
 * @param {Map<string, Object>} [options.skillLookup] optional map of skillId -> skill payload
 */
async function enrichSkillsData(challenge, { skillLookup }: { skillLookup?: any } = {}) {
  if (!Array.isArray(challenge.skills) || challenge.skills.length === 0) {
    return;
  }

  const skillIds = _(challenge.skills)
    .map((skill) => skill.skillId || skill.id)
    .filter((id) => !_.isNil(id))
    .uniq()
    .value();

  if (skillIds.length === 0) {
    return;
  }

  let lookup = skillLookup;
  if (!lookup) {
    try {
      const standSkills = await helper.getStandSkills(skillIds);
      lookup = new Map();
      standSkills.forEach((skill) => {
        if (skill && skill.id) {
          lookup.set(skill.id, skill);
        }
      });
    } catch (error) {
      logger.error("Failed to enrich skills data:", error);
      challenge.skills = challenge.skills.map((skill) => ({
        id: skill.skillId || skill.id,
        name: skill.name || "",
      }));
      return;
    }
  }

  const getFromLookup = (skillId) => {
    if (!lookup) {
      return null;
    }
    if (lookup instanceof Map) {
      return lookup.get(skillId);
    }
    return lookup[skillId];
  };

  challenge.skills = _.uniqBy(challenge.skills, (skill) => skill.skillId || skill.id).map(
    (skill) => {
      const skillId = skill.skillId || skill.id;
      const found = getFromLookup(skillId);
      if (found) {
        const enrichedSkill: any = {
          id: skillId,
          name: found.name,
        };

        if (found.category) {
          enrichedSkill.category = {
            id: found.category.id,
            name: found.category.name,
          };
        }

        return enrichedSkill;
      }

      return {
        id: skillId,
        name: skill.name || "",
      };
    },
  );
}

/**
 * Enrich skills for a list of challenges using a single lookup call when possible.
 * @param {Array<Object>} challenges
 */
async function enrichSkillsDataBulk(challenges) {
  const challengesWithSkills = challenges.filter(
    (challenge) => Array.isArray(challenge.skills) && challenge.skills.length > 0,
  );

  if (challengesWithSkills.length === 0) {
    return;
  }

  const uniqueSkillIds = _(challengesWithSkills)
    .flatMap((challenge) =>
      challenge.skills.map((skill) => skill.skillId || skill.id).filter((id) => !_.isNil(id)),
    )
    .uniq()
    .value();

  if (uniqueSkillIds.length === 0) {
    return;
  }

  let lookup = null;
  try {
    const standSkills = await helper.getStandSkills(uniqueSkillIds);
    lookup = new Map();
    standSkills.forEach((skill) => {
      if (skill && skill.id) {
        lookup.set(skill.id, skill);
      }
    });
  } catch (error) {
    logger.error("Failed to enrich skills data in bulk:", error);
    await Promise.all(challengesWithSkills.map((challenge) => enrichSkillsData(challenge)));
    return;
  }

  await Promise.all(
    challengesWithSkills.map((challenge) => enrichSkillsData(challenge, { skillLookup: lookup })),
  );
}

// define return field for challenge model. Used in prisma.
const includeReturnFields = {
  legacyRecord: true,
  billingRecord: true,
  metadata: true,
  phases: {
    // sort by start/end date
    orderBy: [
      {
        scheduledEndDate: "asc",
      },
      {
        scheduledStartDate: "asc",
      },
    ],
    include: { constraints: true },
  },
  discussions: {
    include: { options: true },
  },
  events: true,
  prizeSets: {
    include: {
      prizes: {
        orderBy: { value: "desc" },
      },
    },
  },
  reviewers: {
    orderBy: { createdAt: "asc" },
  },
  terms: true,
  skills: true,
  winners: {
    orderBy: { placement: "asc" },
  },
  attachments: true,
  track: true,
  type: true,
};

/**
 * Build the Prisma include payload for challenges, optionally projecting the
 * memberAccesses relation when we need to know whether the current user can
 * see private fields.
 * @param {string|null} memberId
 * @returns {Object} prisma include payload
 */
function buildChallengeInclude(memberId) {
  if (!memberId) {
    return includeReturnFields;
  }
  return {
    ...includeReturnFields,
    memberAccesses: {
      where: { memberId },
      select: { memberId: true },
    },
  };
}

/**
 * Get default reviewers for a given typeId and trackId
 * @param {Object} currentUser
 * @param {Object} criteria { typeId, trackId }
 */
async function getDefaultReviewers(currentUser, criteria) {
  const schema = Joi.object()
    .keys({
      typeId: Joi.id(),
      trackId: Joi.id(),
      timelineTemplateId: Joi.optionalId(),
    })
    .required();
  const { error, value } = schema.validate(criteria);
  if (error) throw error;

  const baseWhere = { typeId: value.typeId, trackId: value.trackId };
  let rows = [];

  if (value.timelineTemplateId) {
    rows = await prisma.defaultChallengeReviewer.findMany({
      where: { ...baseWhere, timelineTemplateId: value.timelineTemplateId },
      orderBy: { createdAt: "asc" },
    });
  }

  if (!rows || rows.length === 0) {
    rows = await prisma.defaultChallengeReviewer.findMany({
      where: { ...baseWhere, timelineTemplateId: null },
      orderBy: { createdAt: "asc" },
    });
  }

  return rows.map((r) => ({
    scorecardId: r.scorecardId,
    isMemberReview: r.isMemberReview,
    memberReviewerCount: r.memberReviewerCount,
    phaseName: r.phaseName,
    phaseId: r.phaseId,
    fixedAmount: r.fixedAmount,
    baseCoefficient: r.baseCoefficient,
    incrementalCoefficient: r.incrementalCoefficient,
    type: r.opportunityType,
    aiConfigTemplateId: r.aiConfigTemplateId,
    shouldOpenOpportunity: _.isBoolean(r.shouldOpenOpportunity) ? r.shouldOpenOpportunity : true,
  }));
}
getDefaultReviewers.schema = { currentUser: Joi.any(), criteria: Joi.any() };

/**
 * Set default reviewers for a given typeId and trackId
 * @param {Object} currentUser
 * @param {Object} data { typeId, trackId, reviewers }
 */
async function setDefaultReviewers(currentUser, data) {
  const schema = Joi.object()
    .keys({
      typeId: Joi.id().required(),
      trackId: Joi.id().required(),
      timelineTemplateId: Joi.optionalId(),
      reviewers: Joi.array()
        .items(
          Joi.object().keys({
            scorecardId: Joi.string().required(),
            isMemberReview: Joi.boolean().required(),
            shouldOpenOpportunity: Joi.boolean().default(true),
            memberReviewerCount: Joi.when("isMemberReview", {
              is: true,
              then: Joi.number().integer().min(1).required(),
              otherwise: Joi.forbidden(),
            }),
            phaseName: Joi.string().required(),
            fixedAmount: Joi.number().min(0).optional().allow(null),
            baseCoefficient: Joi.number().min(0).max(1).optional().allow(null),
            incrementalCoefficient: Joi.number().min(0).max(1).optional().allow(null),
            type: Joi.when("isMemberReview", {
              is: true,
              then: Joi.string()
                .valid(..._.values(ReviewOpportunityTypeEnum))
                .insensitive(),
              otherwise: Joi.forbidden(),
            }),
            aiConfigTemplateId: Joi.when("isMemberReview", {
              is: false,
              then: Joi.string().required(),
              otherwise: Joi.forbidden(),
            }),
          }),
        )
        .default([]),
    })
    .required();

  const { error, value } = schema.validate(data);
  if (error) throw error;

  // validate referenced type and track
  const [type, track] = await Promise.all([
    prisma.challengeType.findUnique({ where: { id: value.typeId } }),
    prisma.challengeTrack.findUnique({ where: { id: value.trackId } }),
  ]);
  if (!type) throw new errors.NotFoundError(`ChallengeType with id: ${value.typeId} doesn't exist`);
  if (!track)
    throw new errors.NotFoundError(`ChallengeTrack with id: ${value.trackId} doesn't exist`);

  if (value.timelineTemplateId) {
    const timelineTemplate = await prisma.timelineTemplate.findUnique({
      where: { id: value.timelineTemplateId },
    });
    if (!timelineTemplate) {
      throw new errors.NotFoundError(
        `TimelineTemplate with id: ${value.timelineTemplateId} doesn't exist`,
      );
    }
  }

  const userId = _.toString(currentUser && currentUser.userId ? currentUser.userId : "system");
  const auditFields = { createdBy: userId, updatedBy: userId };

  // Validate phase names exist
  const uniquePhaseNames = _.uniq(value.reviewers.map((r) => r.phaseName));
  if (uniquePhaseNames.length > 0) {
    const phases = await prisma.phase.findMany({ where: { name: { in: uniquePhaseNames } } });
    const existing = new Set(phases.map((p) => p.name));
    const missing = uniquePhaseNames.filter((n) => !existing.has(n));
    if (missing.length > 0) {
      throw new errors.BadRequestError(`Invalid phaseName(s): ${missing.join(", ")}`);
    }
  }

  await prisma.$transaction(async (tx) => {
    await tx.defaultChallengeReviewer.deleteMany({
      where: {
        typeId: value.typeId,
        trackId: value.trackId,
        timelineTemplateId: _.isNil(value.timelineTemplateId) ? null : value.timelineTemplateId,
      },
    });
    if (value.reviewers.length > 0) {
      await tx.defaultChallengeReviewer.createMany({
        data: value.reviewers.map((r) => ({
          ...auditFields,
          typeId: value.typeId,
          trackId: value.trackId,
          timelineTemplateId: _.isNil(value.timelineTemplateId) ? null : value.timelineTemplateId,
          scorecardId: String(r.scorecardId),
          isMemberReview: !!r.isMemberReview,
          aiConfigTemplateId: _.isNil(r.aiConfigTemplateId) ? null : r.aiConfigTemplateId,
          memberReviewerCount: _.isNil(r.memberReviewerCount)
            ? null
            : Number(r.memberReviewerCount),
          phaseName: r.phaseName,
          fixedAmount: _.isNil(r.fixedAmount) ? null : Number(r.fixedAmount),
          baseCoefficient: _.isNil(r.baseCoefficient) ? null : Number(r.baseCoefficient),
          incrementalCoefficient: _.isNil(r.incrementalCoefficient)
            ? null
            : Number(r.incrementalCoefficient),
          opportunityType: r.type ? _.toUpper(r.type) : null,
          shouldOpenOpportunity: _.isNil(r.shouldOpenOpportunity)
            ? true
            : !!r.shouldOpenOpportunity,
        })),
      });
    }
  });

  return await getDefaultReviewers(currentUser, {
    typeId: value.typeId,
    trackId: value.trackId,
    timelineTemplateId: value.timelineTemplateId,
  });
}
setDefaultReviewers.schema = { currentUser: Joi.any(), data: Joi.any() };

/**
 * Search challenges by legacyId
 * @param {Object} currentUser the user who perform operation
 * @param {Number} legacyId the legacyId
 * @param {Number} page the page
 * @param {Number} perPage the perPage
 * @returns {Array} the search result
 */
async function searchByLegacyId(currentUser, legacyId, page, perPage) {
  const whitelistFilter = helper.getChallengeWhitelistAccessFilter(currentUser);
  const where: any = { legacyId };
  if (whitelistFilter) {
    where.AND = [whitelistFilter];
  }

  // Do not take nested objects, query will be faster
  let challenges;
  try {
    challenges = await prisma.challenge.findMany({
      take: perPage,
      skip: (page - 1) * perPage,
      where,
      include: includeReturnFields,
    });
  } catch (err) {
    if (helper.shouldApplyChallengeWhitelist(currentUser)) {
      logger.warn(`searchByLegacyId whitelist-filtered query failed: ${err.message}`);
      return [];
    }
    throw err;
  }

  _.forEach(challenges, (c) => {
    prismaHelper.convertModelToResponse(c);
    enrichChallengeForResponse(c, c.track, c.type);
  });
  return challenges;
}

/**
 * Specialized search path when filtering by a specific memberId. We pivot through the
 * Resource table to load the member's challenge ids, then apply the remaining filters in
 * manageable chunks so the database never has to process thousands of correlated joins.
 * @param {Object} options
 * @param {string} options.requestedMemberId
 * @param {Object} options.challengeWhere Prisma where clause ({ AND: [...] })
 * @param {Object} options.sortFilter e.g. { startDate: "desc" }
 * @param {string} options.sortByProp normalized challenge column name
 * @param {string} options.sortOrderProp "asc" | "desc"
 * @param {number} options.page
 * @param {number} options.perPage
 * @param {Object} options.challengeInclude include payload
 * @param {Function} options.markTiming timing logger
 * @returns {Promise<{ total: number, challenges: Array<Object> }>}
 */
async function searchChallengesViaMemberAccess({
  requestedMemberId,
  challengeWhere,
  sortFilter,
  sortByProp,
  sortOrderProp,
  page,
  perPage,
  challengeInclude,
  markTiming,
}) {
  const chunkSize = Number(process.env.SEARCH_MEMBER_CHUNK_SIZE || 500);
  const memberChallengeIdStart = Date.now();
  const memberChallengeIdRows = await prisma.memberChallengeAccess.findMany({
    where: { memberId: requestedMemberId },
    select: { challengeId: true },
    distinct: ["challengeId"],
  });
  const memberChallengeIds = memberChallengeIdRows
    .map((row) => row.challengeId)
    .filter((id) => !_.isNil(id));
  markTiming("memberResourceChallengeIds", {
    durationMs: Date.now() - memberChallengeIdStart,
    count: memberChallengeIds.length,
  });
  if (memberChallengeIds.length === 0) {
    return { total: 0, challenges: [] };
  }

  const summarySelect = { id: true };
  summarySelect[sortByProp] = true;

  const baseWhere = _.cloneDeep(challengeWhere);
  const summaryStart = Date.now();
  const summaryRecords = [];
  const idChunks = _.chunk(memberChallengeIds, chunkSize);

  for (const chunk of idChunks) {
    const chunkWhere = _.cloneDeep(baseWhere);
    chunkWhere.AND = [...(chunkWhere.AND || []), { id: { in: chunk } }];
    const rows = await prisma.challenge.findMany({
      where: chunkWhere,
      select: summarySelect,
    });
    summaryRecords.push(...rows);
  }

  markTiming("memberChunkScan", {
    durationMs: Date.now() - summaryStart,
    chunkCount: idChunks.length,
    candidateCount: summaryRecords.length,
  });

  if (summaryRecords.length === 0) {
    return { total: 0, challenges: [] };
  }

  const compareValues = (aValue, bValue) => {
    if (aValue === bValue) {
      return 0;
    }
    if (sortByProp === "status") {
      return compareStatusSortValues(aValue, bValue);
    }
    if (_.isNil(aValue)) {
      return 1;
    }
    if (_.isNil(bValue)) {
      return -1;
    }
    if (_.isNumber(aValue) && _.isNumber(bValue)) {
      return aValue - bValue;
    }
    if (aValue instanceof Date && bValue instanceof Date) {
      return (aValue as any) - (bValue as any);
    }
    const aStr = `${aValue}`;
    const bStr = `${bValue}`;
    return aStr.localeCompare(bStr);
  };

  const sortDirection = sortOrderProp === "asc" ? 1 : -1;
  summaryRecords.sort((a, b) => compareValues(a[sortByProp], b[sortByProp]) * sortDirection);

  const total = summaryRecords.length;
  const offset = (page - 1) * perPage;
  const pageSummaries = summaryRecords.slice(offset, offset + perPage);
  const pageIds = pageSummaries.map((summary) => summary.id);

  if (pageIds.length === 0) {
    return { total, challenges: [] };
  }

  const fetchWhere = _.cloneDeep(baseWhere);
  fetchWhere.AND = [...(fetchWhere.AND || []), { id: { in: pageIds } }];

  const fetchStart = Date.now();
  const challenges = await prisma.challenge.findMany({
    where: fetchWhere,
    include: challengeInclude,
  });
  markTiming("memberChunkFetch", {
    durationMs: Date.now() - fetchStart,
    fetched: challenges.length,
  });

  const challengesById = new Map();
  challenges.forEach((challenge) => {
    challengesById.set(challenge.id, challenge);
  });

  const orderedChallenges = pageIds.map((id) => challengesById.get(id)).filter((c) => !!c);

  return {
    total,
    challenges: orderedChallenges,
  };
}

/**
 * Search challenges
 * @param {Object} currentUser the user who perform operation
 * @param {Object} criteria the search criteria
 * @returns {Object} the search result
 */
async function searchChallenges(currentUser, criteria) {
  const page = criteria.page || 1;
  const perPage = criteria.perPage || 20;
  const searchTimingEnabled =
    process.env.SEARCH_CHALLENGE_TIMING === "true" ||
    (typeof config.has === "function" &&
      config.has("challengeSearch.debugTimings") &&
      config.get("challengeSearch.debugTimings"));
  const searchTimingStart = Date.now();
  const searchTimingMarks = [];
  const markTiming = (label, extra = {}) => {
    if (!searchTimingEnabled) {
      return;
    }
    searchTimingMarks.push({
      label,
      elapsedMs: Date.now() - searchTimingStart,
      ...extra,
    });
  };

  if (criteria.sortBy && sortByAliases[criteria.sortBy]) {
    criteria.sortBy = sortByAliases[criteria.sortBy];
  }

  // Log the requested search filter (omit pagination for brevity)
  try {
    const filterToLog = _.omit(criteria, ["page", "perPage"]);
    logger.info(`SearchChallenges filter: ${JSON.stringify(filterToLog)}`);
  } catch (e) {
    // best-effort logging; don't block on serialization issues
    logger.info("SearchChallenges filter: <unable to serialize criteria>");
  }
  if (!_.isUndefined(criteria.legacyId)) {
    const result = await searchByLegacyId(currentUser, criteria.legacyId, page, perPage);
    const sanitizedResult = result.map((challenge) =>
      helper.removeNullProperties(sanitizeBillingMarkupForCaller(currentUser, challenge)),
    );
    return { total: sanitizedResult.length, page, perPage, result: sanitizedResult };
  }

  const prismaFilter = {
    where: {
      AND: [],
    },
  };

  const matchPhraseKeys = [
    "id",
    "timelineTemplateId",
    "projectId",
    "legacyId",
    "createdBy",
    "updatedBy",
  ];

  const _hasAdminRole = hasAdminRole(currentUser);
  const _isMachineToken = _.get(currentUser, "isMachine", false);
  const whitelistFilter = helper.getChallengeWhitelistAccessFilter(currentUser);
  if (whitelistFilter) {
    prismaFilter.where.AND.push(whitelistFilter);
  }

  const normalizeGroupIdValue = (value) => {
    if (_.isNil(value)) {
      return null;
    }
    const normalized = _.toString(value).trim();
    if (!normalized) {
      return null;
    }
    const lowered = normalized.toLowerCase();
    if (lowered === "null" || lowered === "undefined") {
      return null;
    }
    return normalized;
  };

  const normalizeGroupIdList = (list) => {
    if (_.isNil(list)) {
      return [];
    }
    const arrayValue = Array.isArray(list) ? list : [list];
    return _.uniq(
      arrayValue.map((value) => normalizeGroupIdValue(value)).filter((value) => !_.isNil(value)),
    );
  };

  let includedTrackIds = _.isArray(criteria.trackIds) ? criteria.trackIds : [];
  let includedTypeIds = _.isArray(criteria.typeIds) ? criteria.typeIds : [];

  if (criteria.type) {
    const typeSearchRes = await prisma.challengeType.findFirst({
      where: { abbreviation: criteria.type },
    });
    if (typeSearchRes && _.get(typeSearchRes, "id")) {
      criteria.typeId = _.get(typeSearchRes, "id");
    }
  }
  if (criteria.track) {
    const trackSearchRes = await prisma.challengeTrack.findFirst({
      where: { abbreviation: criteria.track },
    });
    if (trackSearchRes && _.get(trackSearchRes, "id")) {
      criteria.trackId = _.get(trackSearchRes, "id");
    }
  }
  if (criteria.types) {
    const typeIds = await prisma.challengeType.findMany({
      where: { abbreviation: { in: criteria.types } },
      select: { id: true },
    });
    if (typeIds.length > 0) {
      includedTypeIds = _.concat(
        includedTypeIds,
        typeIds.map((t) => t.id),
      );
    }
  }
  if (criteria.tracks) {
    const trackIds = await prisma.challengeTrack.findMany({
      select: { id: true },
      where: { abbreviation: { in: criteria.tracks } },
    });
    if (trackIds.length > 0) {
      includedTrackIds = _.concat(
        includedTrackIds,
        trackIds.map((t) => t.id),
      );
    }
  }
  if (criteria.typeId) {
    includedTypeIds.push(criteria.typeId);
  }
  if (criteria.trackId) {
    includedTrackIds.push(criteria.trackId);
  }

  _.forIn(_.pick(criteria, matchPhraseKeys), (value, key) => {
    if (!_.isUndefined(value)) {
      const f = {};
      f[key] = value;
      prismaFilter.where.AND.push(f);
    }
  });

  // handle projectIds (array of project IDs, applied as IN filter)
  if (Array.isArray(criteria.projectIds) && criteria.projectIds.length > 0) {
    prismaFilter.where.AND.push({
      projectId: { in: criteria.projectIds },
    });
  }

  // handle status
  if (!_.isNil(criteria.status)) {
    prismaFilter.where.AND.push({
      status: criteria.status.toUpperCase(),
    });
  }

  // handle approvalStatus
  if (!_.isNil(criteria.approvalStatus)) {
    prismaFilter.where.AND.push({
      approvalStatus: criteria.approvalStatus.toUpperCase(),
    });
  }

  _.forEach(_.keys(criteria), (key) => {
    if (_.toString(key).indexOf("meta.") > -1) {
      // Parse and use metadata key
      if (!_.isUndefined(criteria[key])) {
        const metaKey = key.split("meta.")[1];
        prismaFilter.where.AND.push({
          metadata: {
            some: {
              name: { contains: metaKey },
              value: { contains: _.toString(criteria[key]) },
            },
          },
        });
      }
    }
  });

  if (includedTypeIds.length > 0) {
    prismaFilter.where.AND.push({
      typeId: { in: includedTypeIds },
    });
  }

  if (includedTrackIds.length > 0) {
    prismaFilter.where.AND.push({
      trackId: { in: includedTrackIds },
    });
  }

  if (criteria.search) {
    prismaFilter.where.AND.push({
      OR: [
        {
          name: {
            contains: criteria.search,
            mode: "insensitive",
          },
        },
        {
          description: { contains: criteria.search },
          // TODO: Skills doesn't have name field in db.
          /*
      }, {
        skills: { some: { name: { contains: criteria.search } } }
      */
        },
        {
          tags: { has: criteria.search },
        },
      ],
    });
  } else {
    if (criteria.name) {
      prismaFilter.where.AND.push({
        name: {
          contains: criteria.name,
          mode: "insensitive",
        },
      });
    }

    if (criteria.description) {
      prismaFilter.where.AND.push({
        description: { contains: criteria.description },
      });
    }
  }

  if (criteria.tag) {
    prismaFilter.where.AND.push({
      tags: {
        has: criteria.tag,
      },
    });
  }

  if (criteria.tags) {
    if (criteria.includeAllTags) {
      prismaFilter.where.AND.push({
        tags: { hasEvery: criteria.tags },
      });
    } else {
      prismaFilter.where.AND.push({
        tags: { hasSome: criteria.tags },
      });
    }
  }

  if (criteria.totalPrizesFrom || criteria.totalPrizesTo) {
    if (criteria.totalPrizesFrom) {
      prismaFilter.where.AND.push({
        overviewTotalPrizes: { gte: criteria.totalPrizesFrom },
      });
    }
    if (criteria.totalPrizesTo) {
      prismaFilter.where.AND.push({
        overviewTotalPrizes: { lte: criteria.totalPrizesTo },
      });
    }
  }
  if (criteria.selfService) {
    prismaFilter.where.AND.push({
      legacyRecord: {
        is: { selfService: criteria.selfService },
      },
    });
  }
  if (criteria.selfServiceCopilot) {
    prismaFilter.where.AND.push({
      legacyRecord: {
        is: { selfServiceCopilot: criteria.selfServiceCopilot },
      },
    });
  }
  if (criteria.forumId) {
    prismaFilter.where.AND.push({
      legacyRecord: {
        is: { forumId: criteria.forumId },
      },
    });
  }
  if (criteria.reviewType) {
    prismaFilter.where.AND.push({
      legacyRecord: {
        is: { reviewType: criteria.reviewType.toUpperCase() },
      },
    });
  }
  if (criteria.confidentialityType) {
    prismaFilter.where.AND.push({
      legacyRecord: {
        is: { confidentialityType: criteria.confidentialityType },
      },
    });
  }
  if (criteria.directProjectId) {
    prismaFilter.where.AND.push({
      legacyRecord: {
        is: { directProjectId: criteria.directProjectId },
      },
    });
  }
  if (criteria.currentPhaseName) {
    const phaseNamesToMatch =
      criteria.currentPhaseName === "Registration"
        ? ["Registration", "Open"]
        : [criteria.currentPhaseName];

    prismaFilter.where.AND.push({
      OR: [
        { currentPhaseNames: { hasSome: phaseNamesToMatch } },
        {
          phases: {
            some: {
              name: { in: phaseNamesToMatch },
              isOpen: true,
            },
          },
        },
      ],
    });
  }
  if (criteria.createdDateStart) {
    prismaFilter.where.AND.push({
      createdAt: { gte: criteria.createdDateStart },
    });
  }
  if (criteria.createdDateEnd) {
    prismaFilter.where.AND.push({
      createdAt: { lte: criteria.createdDateEnd },
    });
  }
  if (criteria.registrationStartDateStart) {
    prismaFilter.where.AND.push({
      registrationStartDate: { gte: criteria.registrationStartDateStart },
    });
  }
  if (criteria.registrationStartDateEnd) {
    prismaFilter.where.AND.push({
      registrationStartDate: { lte: criteria.registrationStartDateEnd },
    });
  }
  if (criteria.registrationEndDateStart) {
    prismaFilter.where.AND.push({
      registrationEndDate: { gte: criteria.registrationEndDateStart },
    });
  }
  if (criteria.registrationEndDateEnd) {
    prismaFilter.where.AND.push({
      registrationEndDate: { lte: criteria.registrationEndDateEnd },
    });
  }
  if (criteria.submissionStartDateStart) {
    prismaFilter.where.AND.push({
      submissionStartDate: { gte: criteria.submissionStartDateStart },
    });
  }
  if (criteria.submissionStartDateEnd) {
    prismaFilter.where.AND.push({
      submissionStartDate: { lte: criteria.submissionStartDateEnd },
    });
  }
  if (criteria.submissionEndDateStart) {
    prismaFilter.where.AND.push({
      submissionEndDate: { gte: criteria.submissionEndDateStart },
    });
  }
  if (criteria.submissionEndDateEnd) {
    prismaFilter.where.AND.push({
      submissionEndDate: { lte: criteria.submissionEndDateEnd },
    });
  }
  if (criteria.updatedDateStart) {
    prismaFilter.where.AND.push({
      updatedAt: { gte: criteria.updatedDateStart },
    });
  }
  if (criteria.updatedDateEnd) {
    prismaFilter.where.AND.push({
      updatedAt: { lte: criteria.updatedDateEnd },
    });
  }
  if (criteria.startDateStart) {
    prismaFilter.where.AND.push({
      startDate: { gte: criteria.startDateStart },
    });
  }
  if (criteria.startDateEnd) {
    prismaFilter.where.AND.push({
      startDate: { lte: criteria.startDateEnd },
    });
  }
  if (criteria.endDateStart) {
    prismaFilter.where.AND.push({
      endDate: { gte: criteria.endDateStart },
    });
  }
  if (criteria.endDateEnd) {
    prismaFilter.where.AND.push({
      endDate: { lte: criteria.endDateEnd },
    });
  }

  let sortByProp = criteria.sortBy ? criteria.sortBy : "createdAt";

  const sortOrderProp = criteria.sortOrder ? criteria.sortOrder : "desc";

  if (sortByProp === "overview.totalPrizes") {
    sortByProp = "overviewTotalPrizes";
  }

  if (criteria.tco) {
    prismaFilter.where.AND.push({
      events: {
        some: { key: { contains: "tco" } },
      },
    });
  }

  if (criteria.events) {
    const eventQuery = _.map(criteria.events, (e) => ({
      events: {
        some: { key: { contains: e } },
      },
    }));
    if (criteria.includeAllEvents) {
      prismaFilter.where.AND = _.concat(prismaFilter.where.AND, eventQuery);
    } else {
      prismaFilter.where.AND.push({
        OR: eventQuery,
      });
    }
  }

  const requestedMemberId = !_.isNil(criteria.memberId) ? _.toString(criteria.memberId) : null;
  const currentUserMemberId =
    currentUser && !_hasAdminRole && !_isMachineToken ? _.toString(currentUser.userId) : null;
  const isSelfMemberSearch = Boolean(
    requestedMemberId && currentUserMemberId && requestedMemberId === currentUserMemberId,
  );
  const shouldApplyGroupVisibilityFilter = Boolean(
    currentUser && !_isMachineToken && !_hasAdminRole && !isSelfMemberSearch,
  );

  let hasProjectManagerAccessForSearch = false;
  if (currentUser && !_hasAdminRole && !_isMachineToken && !_.isNil(criteria.projectId)) {
    hasProjectManagerAccessForSearch = await helper.userHasProjectManagerAccess(
      criteria.projectId,
      currentUser,
    );
  }

  let groupsToFilter = [];
  let accessibleGroups = [];
  let accessibleGroupsSet = new Set();

  if (shouldApplyGroupVisibilityFilter) {
    const accessibleGroupsStart = Date.now();
    const rawAccessibleGroups = await helper.getCompleteUserGroupTreeIds(currentUser.userId);
    accessibleGroups = normalizeGroupIdList(rawAccessibleGroups);
    accessibleGroupsSet = new Set(accessibleGroups);
    markTiming("loaded-accessible-groups", {
      durationMs: Date.now() - accessibleGroupsStart,
      groupCount: accessibleGroups.length,
    });
  }

  // Filter all groups from the criteria to make sure the user can access those
  if (!_.isUndefined(criteria.group) || !_.isUndefined(criteria.groups)) {
    const criteriaGroupsList = _.isNil(criteria.groups) ? [] : [].concat(criteria.groups);

    // check group access
    if (_.isUndefined(currentUser)) {
      const normalizedGroup = normalizeGroupIdValue(criteria.group);
      if (normalizedGroup) {
        const group = await helper.getGroupById(normalizedGroup);
        if (group && !group.privateGroup) {
          groupsToFilter.push(normalizedGroup);
        }
      }

      if (criteriaGroupsList.length > 0) {
        const promises = criteriaGroupsList.map(async (groupValue) => {
          const normalized = normalizeGroupIdValue(groupValue);
          if (!normalized) {
            return;
          }
          const group = await helper.getGroupById(normalized);
          if (group && !group.privateGroup) {
            groupsToFilter.push(normalized);
          }
        });
        await Promise.all(promises);
      }
    } else if (shouldApplyGroupVisibilityFilter) {
      const normalizedGroup = normalizeGroupIdValue(criteria.group);
      if (normalizedGroup && accessibleGroupsSet.has(normalizedGroup)) {
        groupsToFilter.push(normalizedGroup);
      }

      if (criteriaGroupsList.length > 0) {
        criteriaGroupsList.forEach((groupValue) => {
          const normalized = normalizeGroupIdValue(groupValue);
          if (normalized && accessibleGroupsSet.has(normalized)) {
            groupsToFilter.push(normalized);
          }
        });
      }
    } else {
      groupsToFilter = normalizeGroupIdList(criteriaGroupsList);
      const normalizedGroup = normalizeGroupIdValue(criteria.group);
      if (normalizedGroup) {
        groupsToFilter.push(normalizedGroup);
      }
    }

    groupsToFilter = _.uniq(groupsToFilter);

    if (groupsToFilter.length === 0) {
      // User can't access any of the groups from the filters
      // We return an empty array as the result
      return { total: 0, page, perPage, result: [] };
    }
  }

  if (groupsToFilter.length === 0) {
    // Return public challenges + challenges from groups that the user has access to
    if (_.isUndefined(currentUser)) {
      // If the user is not authenticated, only query challenges that don't have a group
      prismaFilter.where.AND.push({
        groups: { isEmpty: true },
      });
    } else if (shouldApplyGroupVisibilityFilter) {
      prismaFilter.where.AND.push({
        OR: [
          {
            // include public challenges
            groups: { isEmpty: true },
          },
          {
            // If the user is not M2M and is not an admin, return public + challenges from groups the user can access
            groups: { hasSome: accessibleGroups },
          },
        ],
      });
    }
  } else {
    prismaFilter.where.AND.push({
      groups: { hasSome: groupsToFilter },
    });
  }

  if (criteria.ids) {
    prismaFilter.where.AND.push({
      id: { in: criteria.ids },
    });
  }

  /**
   * Task challenges are visible to ordinary authenticated users only when they
   * have a resource on the task. Anonymous users never receive tasks. Admin,
   * machine-token and project-manager searches retain their operational access.
   * A requested memberId narrows results but never grants the caller task access.
   */
  if (currentUser && (_hasAdminRole || _isMachineToken)) {
    // For admins/m2m, allow filtering based on task properties
    if (!_.isNil(criteria.isTask)) {
      prismaFilter.where.AND.push({
        taskIsTask: criteria.isTask,
      });
    }
    if (!_.isNil(criteria.taskIsAssigned)) {
      prismaFilter.where.AND.push({
        taskIsAssigned: criteria.taskIsAssigned,
      });
    }
    if (!_.isNil(criteria.taskMemberId)) {
      prismaFilter.where.AND.push({
        taskMemberId: criteria.taskMemberId,
      });
    }
  } else if (!hasProjectManagerAccessForSearch) {
    const taskFilter: any[] = [{ taskIsTask: false }];
    if (currentUserMemberId) {
      taskFilter.push({
        taskIsTask: true,
        memberAccesses: {
          some: { memberId: currentUserMemberId },
        },
      });
    }
    prismaFilter.where.AND.push({
      OR: taskFilter,
    });
  }

  const sortFilter = {};
  sortFilter[sortByProp] = sortOrderProp;

  const challengeInclude = buildChallengeInclude(currentUserMemberId);

  const prismaQuery = {
    ...prismaFilter,
    take: perPage,
    skip: (page - 1) * perPage,
    orderBy: [sortFilter],
    include: challengeInclude,
  };

  try {
    const logContext = requestedMemberId
      ? {
          memberAccessWhere: {
            memberId: requestedMemberId,
            challenge: prismaFilter.where,
          },
          orderBy: [
            {
              challenge: sortFilter,
            },
          ],
          pagination: {
            page,
            perPage,
            take: perPage,
            skip: (page - 1) * perPage,
          },
        }
      : {
          where: prismaFilter.where,
          orderBy: prismaQuery.orderBy,
          pagination: {
            page,
            perPage,
            take: perPage,
            skip: (page - 1) * perPage,
          },
          groupsToFilterCount: groupsToFilter.length,
          accessibleGroupsCount: accessibleGroups.length,
          shouldApplyGroupVisibilityFilter,
        };
    const logPayload = JSON.stringify(logContext, (_key, value) => {
      if (typeof value === "bigint") {
        return value.toString();
      }
      if (value instanceof Date) {
        return value.toISOString();
      }
      return value;
    });
    logger.info(`SearchChallenges prisma query: ${logPayload}`);
  } catch (logError) {
    logger.warn(`SearchChallenges prisma logging failed: ${logError.message}`);
  }

  let challenges = [];
  let total = 0;
  try {
    if (requestedMemberId) {
      ({ total, challenges } = await searchChallengesViaMemberAccess({
        requestedMemberId,
        challengeWhere: prismaFilter.where,
        sortFilter,
        sortByProp,
        sortOrderProp,
        page,
        perPage,
        challengeInclude,
        markTiming,
      }));
    } else if (sortByProp === "status") {
      const summaryStart = Date.now();
      const summaryRecords = await prisma.challenge.findMany({
        where: prismaFilter.where,
        select: {
          id: true,
          status: true,
        },
      });
      markTiming("statusSortSummaryScan", {
        durationMs: Date.now() - summaryStart,
        candidateCount: summaryRecords.length,
      });

      const sortDirection = sortOrderProp === "asc" ? 1 : -1;
      summaryRecords.sort((a, b) => compareStatusSortValues(a.status, b.status) * sortDirection);

      total = summaryRecords.length;
      const offset = (page - 1) * perPage;
      const pageSummaries = summaryRecords.slice(offset, offset + perPage);
      const pageIds = pageSummaries.map((summary) => summary.id);
      if (pageIds.length === 0) {
        challenges = [];
      } else {
        const fetchWhere = _.cloneDeep(prismaFilter.where);
        fetchWhere.AND = [...(fetchWhere.AND || []), { id: { in: pageIds } }];

        const findManyStart = Date.now();
        const fetchedChallenges = await prisma.challenge.findMany({
          where: fetchWhere,
          include: challengeInclude,
        });
        markTiming("statusSortFetch", {
          durationMs: Date.now() - findManyStart,
          resultCount: fetchedChallenges.length,
        });

        const challengesById = new Map();
        fetchedChallenges.forEach((challenge) => {
          challengesById.set(challenge.id, challenge);
        });
        challenges = pageIds
          .map((challengeId) => challengesById.get(challengeId))
          .filter((challenge) => !!challenge);
      }
    } else {
      const countStart = Date.now();
      total = await prisma.challenge.count({ ...prismaFilter });
      markTiming("count", { durationMs: Date.now() - countStart, total });
      const findManyStart = Date.now();
      challenges = await prisma.challenge.findMany(prismaQuery);
      markTiming("findMany", {
        durationMs: Date.now() - findManyStart,
        resultCount: challenges.length,
      });
    }

    const taskSyncTargets = challenges.filter((challenge) => {
      const taskInfo = helper.getTaskInfo(challenge);
      return taskInfo.isTask && !taskInfo.isAssigned && _.isNil(taskInfo.memberId);
    });
    if (taskSyncTargets.length > 0) {
      await Promise.all(
        taskSyncTargets.map((challenge) => helper.syncTaskAssignmentFromResources(challenge)),
      );
    }
    if (!currentUser) {
      challenges = challenges.filter((challenge) => {
        const taskInfo = helper.getTaskInfo(challenge);
        const hasAssignee = taskInfo.isAssigned || !_.isNil(taskInfo.memberId);
        return !taskInfo.isTask || !hasAssignee;
      });
    }

    await applyLatestSubmissionCounts(challenges);

    challenges.forEach((challenge) => {
      prismaHelper.convertModelToResponse(challenge);
    });

    const enrichStart = Date.now();
    await enrichSkillsDataBulk(challenges);
    markTiming("enrichSkillsDataBulk", { durationMs: Date.now() - enrichStart });

    challenges.forEach((challenge) => {
      enrichChallengeForResponse(challenge, challenge.track, challenge.type);
    });

    // Note: numOfRegistrants and numOfSubmissions are no longer calculated here.
  } catch (e) {
    // logger.error(JSON.stringify(e));
    console.log(e);
  }

  const result = challenges;

  if (currentUser) {
    if (!currentUser.isMachine && !_hasAdminRole) {
      result.forEach((challenge) => {
        _.unset(challenge, "billing");
        const hasCurrentUserAccess = _.get(challenge, "memberAccesses.length", 0) > 0;
        if (!hasCurrentUserAccess) {
          _.unset(challenge, "privateDescription");
        }
        _.unset(challenge, "memberAccesses");
      });
    } else {
      result.forEach((challenge) => _.unset(challenge, "memberAccesses"));
    }
  } else {
    result.forEach((challenge) => {
      _.unset(challenge, "billing");
      _.unset(challenge, "privateDescription");
      _.unset(challenge, "memberAccesses");
    });
  }

  if (criteria.isLightweight === "true") {
    result.forEach((challenge) => {
      _.unset(challenge, "description");
      _.unset(challenge, "privateDescription");
    });
  }

  result.forEach((challenge) => {
    if (challenge.status !== ChallengeStatusEnum.COMPLETED) {
      _.unset(challenge, "winners");
    }
    if (!shouldExposeCheckpointWinners(challenge)) {
      _.unset(challenge, "checkpointWinners");
    }
    if (!_hasAdminRole && !_.get(currentUser, "isMachine", false)) {
      _.unset(challenge, "payments");
    }
  });

  const sanitizedResult = result.map((challenge) =>
    helper.removeNullProperties(sanitizeBillingMarkupForCaller(currentUser, challenge)),
  );

  if (searchTimingEnabled) {
    logger.info(
      `SearchChallenges timings (page=${page}, perPage=${perPage}): ${JSON.stringify({
        totalElapsedMs: Date.now() - searchTimingStart,
        marks: searchTimingMarks,
      })}`,
    );
  }

  return { total, page, perPage, result: sanitizedResult };
}
searchChallenges.schema = {
  currentUser: Joi.any(),
  criteria: Joi.object()
    .keys({
      page: Joi.page(),
      perPage: Joi.perPage(),
      id: Joi.optionalId(),
      selfService: Joi.boolean(),
      selfServiceCopilot: Joi.string(),
      confidentialityType: Joi.string(),
      directProjectId: Joi.number(),
      typeIds: Joi.array().items(Joi.optionalId()),
      trackIds: Joi.array().items(Joi.optionalId()),
      types: Joi.array().items(Joi.string()),
      tracks: Joi.array().items(Joi.string()),
      typeId: Joi.optionalId(),
      trackId: Joi.optionalId(),
      type: Joi.string(),
      track: Joi.string(),
      name: Joi.string(),
      search: Joi.string(),
      description: Joi.string(),
      timelineTemplateId: Joi.string(), // Joi.optionalId(),
      reviewType: Joi.string(),
      tag: Joi.string(),
      tags: Joi.array().items(Joi.string()),
      includeAllTags: Joi.boolean().default(true),
      projectId: Joi.number().integer().positive(),
      projectIds: Joi.array().items(Joi.number().integer().positive()),
      forumId: Joi.number().integer(),
      legacyId: Joi.number().integer().positive(),
      status: Joi.string()
        .valid(..._.values(ChallengeStatusEnum))
        .insensitive(),
      approvalStatus: Joi.string()
        .valid(..._.values(CHALLENGE_APPROVAL_STATUS))
        .insensitive(),
      group: Joi.string(),
      startDateStart: Joi.date(),
      startDateEnd: Joi.date(),
      endDateStart: Joi.date(),
      endDateEnd: Joi.date(),
      currentPhaseName: Joi.string(),
      createdDateStart: Joi.date(),
      createdDateEnd: Joi.date(),
      updatedDateStart: Joi.date(),
      updatedDateEnd: Joi.date(),
      registrationStartDateStart: Joi.date(),
      registrationStartDateEnd: Joi.date(),
      registrationEndDateStart: Joi.date(),
      registrationEndDateEnd: Joi.date(),
      submissionStartDateStart: Joi.date(),
      submissionStartDateEnd: Joi.date(),
      submissionEndDateStart: Joi.date(),
      submissionEndDateEnd: Joi.date(),
      createdBy: Joi.string(),
      updatedBy: Joi.string(),
      isLightweight: Joi.boolean().default(false),
      memberId: Joi.string(),
      sortBy: Joi.string().valid(...allowedSortByValues),
      sortOrder: Joi.string().valid("asc", "desc"),
      groups: Joi.array().items(Joi.optionalId()).unique(),
      ids: Joi.array().items(Joi.optionalId()).unique().min(1),
      isTask: Joi.boolean(),
      taskIsAssigned: Joi.boolean(),
      taskMemberId: Joi.string(),
      events: Joi.array().items(Joi.string()),
      includeAllEvents: Joi.boolean().default(true),
      useSchedulingAPI: Joi.boolean(),
      totalPrizesFrom: Joi.number().min(0),
      totalPrizesTo: Joi.number().min(0),
      tco: Joi.boolean().default(false),
    })
    .unknown(true),
};

/**
 * Create challenge.
 * Fun challenges and challenges billed to configured Topgear accounts skip manual budget approval
 * and are auto-approved.
 * @param {Object} currentUser the user who perform operation
 * @param {Object} challenge the challenge to create; omitted `is_test_challenge` metadata defaults
 * to the exact string `false`
 * @param {String} userToken the user token
 * @returns {Object} the created challenge
 */
async function createChallenge(currentUser, challenge, userToken) {
  challenge.metadata = challengeHelper.applyTestChallengeMetadataDefault(challenge.metadata);
  const buildLogContext = () =>
    JSON.stringify({
      challengeName: challenge.name,
      challengeId: challenge.id,
      trackId: challenge.trackId,
      typeId: challenge.typeId,
      projectId: challenge.projectId,
      timelineTemplateId: challenge.timelineTemplateId,
      selfService: _.get(challenge, "legacy.selfService", false),
      userId: _.get(currentUser, "userId"),
      handle: _.get(currentUser, "handle"),
    });

  logger.info(`createChallenge: start ${buildLogContext()}`);
  logger.debug(`createChallenge: validating request payload ${buildLogContext()}`);
  await challengeHelper.validateCreateChallengeRequest(currentUser, challenge);
  logger.debug(`createChallenge: request payload validated ${buildLogContext()}`);
  const prizeTypeTmp = challengeHelper.validatePrizeSetsAndGetPrizeType(challenge.prizeSets);
  logger.debug(
    `createChallenge: initial prize validation complete (prizeType=${prizeTypeTmp}) ${buildLogContext()}`,
  );
  if (challenge.legacy && challenge.legacy.selfService) {
    // if self-service, create a new project (what about if projectId is provided in the payload? confirm with business!)
    if (!challenge.projectId && challengeHelper.isProjectIdRequired(challenge.timelineTemplateId)) {
      const selfServiceProjectName = `Self service - ${currentUser.handle} - ${challenge.name}`;
      logger.info(
        `createChallenge: creating self-service project (name=${selfServiceProjectName}) ${buildLogContext()}`,
      );
      challenge.projectId = await helper.createSelfServiceProject(
        selfServiceProjectName,
        "N/A",
        config.NEW_SELF_SERVICE_PROJECT_TYPE,
        userToken,
      );
      logger.info(
        `createChallenge: self-service project created (projectId=${
          challenge.projectId
        }) ${buildLogContext()}`,
      );
    }

    if (challenge.metadata && challenge.metadata.length > 0) {
      for (const entry of challenge.metadata) {
        if (challenge.description.includes(`{{${entry.name}}}`)) {
          challenge.description = challenge.description
            .split(`{{${entry.name}}}`)
            .join(entry.value);
        }
      }
    }
  }

  /** Ensure project exists, and set direct project id, billing account id & markup */
  if (challengeHelper.isProjectIdRequired(challenge.timelineTemplateId) || challenge.projectId) {
    const { projectId } = challenge;

    if (!projectId) {
      // fix of projectId undefined
      throw new errors.BadRequestError("Project id must be provided");
    }

    logger.debug(`createChallenge: fetching project details ${buildLogContext()}`);
    const { directProjectId } = await projectHelper.getProject(projectId, currentUser);
    let normalizedDirectProjectId = directProjectId;
    if (!_.isNil(directProjectId)) {
      normalizedDirectProjectId = _.toNumber(directProjectId);
      if (!Number.isInteger(normalizedDirectProjectId)) {
        throw new errors.BadRequestError(
          `Project with id: ${projectId} has invalid directProjectId: ${directProjectId}`,
        );
      }
    }
    logger.debug(
      `createChallenge: fetched project details (directProjectId=${normalizedDirectProjectId}) ${buildLogContext()}`,
    );
    logger.debug(`createChallenge: fetching billing information ${buildLogContext()}`);
    const { billingAccountId, markup } =
      await projectHelper.getProjectBillingInformation(projectId);
    logger.debug(
      `createChallenge: billing information retrieved (hasAccount=${
        billingAccountId !== null && billingAccountId !== undefined
      }, markup=${markup}) ${buildLogContext()}`,
    );

    _.set(challenge, "legacy.directProjectId", normalizedDirectProjectId);
    // Ensure billingAccountId is a string or null to match Prisma schema
    if (billingAccountId !== null && billingAccountId !== undefined) {
      _.set(challenge, "billing.billingAccountId", String(billingAccountId));
    } else {
      _.set(challenge, "billing.billingAccountId", null);
    }
    _.set(challenge, "billing.markup", _.isNil(markup) ? 0 : markup);
  }

  if (!_.isUndefined(_.get(challenge, "legacy.reviewType"))) {
    _.set(challenge, "legacy.reviewType", _.toUpper(_.get(challenge, "legacy.reviewType")));
  }

  if (!challenge.status) {
    challenge.status = ChallengeStatusEnum.NEW;
  }

  const approvalBillingAccountId = getApprovalFlowBillingAccountId(challenge);
  const skipsChallengeApprovalFlow = applyChallengeApprovalFlowBypass(
    challenge,
    approvalBillingAccountId,
    challenge.funChallenge === true,
  );

  if (!skipsChallengeApprovalFlow) {
    const requestedApprovalStatus = normalizeApprovalStatus(challenge.approvalStatus);
    const canApproveChallengeBudget = await userCanApproveChallengeBudget(currentUser, challenge);

    if (!requestedApprovalStatus) {
      challenge.approvalStatus = CHALLENGE_APPROVAL_STATUS.PENDING_APPROVAL;
    } else {
      challenge.approvalStatus = requestedApprovalStatus;
    }

    if (
      CHALLENGE_APPROVAL_ACTION_STATUSES.has(challenge.approvalStatus) &&
      !canApproveChallengeBudget
    ) {
      throw new errors.ForbiddenError(
        "Only admins or project managers with full access can approve or reject challenge budgets.",
      );
    }

    if (challenge.approvalStatus === CHALLENGE_APPROVAL_STATUS.REJECTED) {
      const rejectionReason = _.toString(challenge.approvalRejectionReason || "").trim();
      if (!rejectionReason) {
        throw new errors.BadRequestError(
          "Rejection reason is required when rejecting a challenge.",
        );
      }
      challenge.approvalRejectionReason = rejectionReason;
      challenge.approvalApprovedBy = null;
    } else if (challenge.approvalStatus === CHALLENGE_APPROVAL_STATUS.APPROVED) {
      challenge.approvalRejectionReason = null;
      challenge.approvalApprovedBy = _.toString(currentUser.handle || "").trim() || null;
    } else {
      challenge.approvalRejectionReason = null;
      challenge.approvalApprovedBy = null;
    }
  }

  if (!challenge.startDate) {
    challenge.startDate = new Date().toISOString();
  } else {
    challenge.startDate = convertToISOString(challenge.startDate);
  }

  logger.debug(`createChallenge: resolving challenge track/type ${buildLogContext()}`);
  const { track, type } = await challengeHelper.validateAndGetChallengeTypeAndTrack(challenge);
  logger.debug(
    `createChallenge: resolved challenge track/type (trackId=${_.get(track, "id")}, typeId=${_.get(
      type,
      "id",
    )}) ${buildLogContext()}`,
  );

  if (_.get(type, "isTask")) {
    _.set(challenge, "task.isTask", true);
    // this is only applicable for WorkType: Gig, i.e., Tasks created from Salesforce
    if (challenge.billing != null && challenge.billing.clientBillingRate != null) {
      _.set(challenge, "billing.clientBillingRate", challenge.billing.clientBillingRate);
    }

    if (_.isUndefined(_.get(challenge, "task.isAssigned"))) {
      _.set(challenge, "task.isAssigned", false);
    }
    if (_.isUndefined(_.get(challenge, "task.memberId"))) {
      _.set(challenge, "task.memberId", null);
    } else {
      throw new errors.BadRequestError(`Cannot assign a member before the challenge gets created.`);
    }
  }

  if (challenge.phases && challenge.phases.length > 0) {
    logger.debug(
      `createChallenge: validating provided phases (count=${
        challenge.phases.length
      }) ${buildLogContext()}`,
    );
    await phaseHelper.validatePhases(challenge.phases);
    logger.debug(`createChallenge: provided phases validated ${buildLogContext()}`);
  }

  // populate phases
  if (!challenge.timelineTemplateId) {
    if (challenge.typeId && challenge.trackId) {
      logger.debug(
        `createChallenge: fetching default timeline template (trackId=${
          challenge.trackId
        }, typeId=${challenge.typeId}) ${buildLogContext()}`,
      );
      const supportedTemplates =
        await ChallengeTimelineTemplateService.searchChallengeTimelineTemplates({
          typeId: challenge.typeId,
          trackId: challenge.trackId,
          isDefault: true,
        });
      logger.debug(
        `createChallenge: retrieved ${
          supportedTemplates.result.length
        } supported templates ${buildLogContext()}`,
      );
      const challengeTimelineTemplate = supportedTemplates.result[0];
      if (!challengeTimelineTemplate) {
        throw new errors.BadRequestError(
          `The selected trackId ${challenge.trackId} and typeId: ${challenge.typeId} does not have a default timeline template. Please provide a timelineTemplateId`,
        );
      }
      challenge.timelineTemplateId = challengeTimelineTemplate.timelineTemplateId;
      logger.debug(
        `createChallenge: using timelineTemplateId=${
          challenge.timelineTemplateId
        } ${buildLogContext()}`,
      );
    } else {
      throw new errors.BadRequestError(`trackId and typeId are required to create a challenge`);
    }
  }
  logger.debug(
    `createChallenge: populating phases for challenge creation (templateId=${
      challenge.timelineTemplateId
    }) ${buildLogContext()}`,
  );
  challenge.phases = await phaseHelper.populatePhasesForChallengeCreation(
    challenge.phases,
    challenge.startDate,
    challenge.timelineTemplateId,
  );
  logger.debug(
    `createChallenge: phases populated (count=${challenge.phases.length}) ${buildLogContext()}`,
  );

  // populate challenge terms
  // const projectTerms = await helper.getProjectDefaultTerms(challenge.projectId)
  // challenge.terms = await helper.validateChallengeTerms(_.union(projectTerms, challenge.terms))
  // TODO - challenge terms returned from projects api don't have a role associated
  // this will need to be updated to associate project terms with a roleId
  logger.debug(
    `createChallenge: validating challenge terms (count=${_.get(
      challenge.terms,
      "length",
      0,
    )}) ${buildLogContext()}`,
  );
  challenge.terms = await helper.validateChallengeTerms(challenge.terms || []);
  logger.debug(`createChallenge: challenge terms validated ${buildLogContext()}`);

  // default the descriptionFormat
  if (!challenge.descriptionFormat) {
    challenge.descriptionFormat = "markdown";
  }

  if (challenge.phases && challenge.phases.length > 0) {
    challenge.endDate = helper.calculateChallengeEndDate(challenge);
  }

  if (challenge.events == null) challenge.events = [];
  if (challenge.attachments == null) challenge.attachments = [];
  if (challenge.prizeSets == null) challenge.prizeSets = [];
  const hasProvidedReviewers = Array.isArray(challenge.reviewers) && challenge.reviewers.length > 0;
  if (challenge.reviewers == null) challenge.reviewers = [];
  if (challenge.metadata == null) challenge.metadata = [];
  if (challenge.groups == null) challenge.groups = [];
  if (challenge.tags == null) challenge.tags = [];
  if (challenge.startDate != null) challenge.startDate = challenge.startDate;
  if (challenge.endDate != null) challenge.endDate = challenge.endDate;
  if (challenge.discussions == null) challenge.discussions = [];
  if (challenge.skills == null) challenge.skills = [];

  challenge.metadata = challenge.metadata.map((m) => ({
    name: m.name,
    value: typeof m.value === "string" ? m.value : JSON.stringify(m.value),
  }));

  // No conversion needed - database stores values in dollars directly
  // The amountInCents field doesn't exist in the database schema
  const prizeType = challengeHelper.validatePrizeSetsAndGetPrizeType(challenge.prizeSets);
  logger.debug(
    `createChallenge: final prize validation complete (prizeType=${prizeType}) ${buildLogContext()}`,
  );

  // If reviewers are not provided, apply defaults for this challenge.
  const debugLog = (message) => logger.debug(`createChallenge: ${message} ${buildLogContext()}`);
  await challengeHelper.applyDefaultMemberReviewersForChallengeCreation(
    challenge,
    prisma,
    debugLog,
  );
  const aiReviewConfigsForCreation = !hasProvidedReviewers
    ? await challengeHelper.applyDefaultAIConfigForChallengeCreation(challenge, prisma, debugLog)
    : [];

  // AI screening phase will be added when challenge is launched (status changed to ACTIVE)

  const prismaModel = prismaHelper.convertChallengeSchemaToPrisma(currentUser, challenge);
  logger.info(
    `createChallenge: creating challenge record via prisma ${buildLogContext()} phaseCount=${_.get(
      challenge,
      "phases.length",
      0,
    )} prizeSetCount=${_.get(challenge, "prizeSets.length", 0)}`,
  );
  const ret = await prisma.challenge.create({
    data: prismaModel,
    include: includeReturnFields,
  });
  logger.info(`createChallenge: challenge record created (id=${ret.id}) ${buildLogContext()}`);

  if (!hasProvidedReviewers) {
    await challengeHelper.createAIReviewConfigsForChallengeCreation(
      ret.id,
      aiReviewConfigsForCreation,
      debugLog,
    );
  }

  ret.overview = { totalPrizes: ret.overviewTotalPrizes };
  // No conversion needed - values are already in dollars in the database

  prismaHelper.convertModelToResponse(ret);
  await enrichSkillsData(ret);
  enrichChallengeForResponse(ret, track, type);
  await syncChallengeBillingAccountLock(ret);

  // If the challenge is self-service, add the creating user as the "client manager", *not* the manager
  // This is necessary for proper handling of the vanilla embed on the self-service work item dashboard

  if (challenge.legacy.selfService) {
    if (currentUser.handle) {
      logger.debug(
        `createChallenge: assigning CLIENT_MANAGER role to creator (challengeId=${
          ret.id
        }) ${buildLogContext()}`,
      );
      await helper.createResource(ret.id, ret.createdBy, config.CLIENT_MANAGER_ROLE_ID);
      logger.debug(
        `createChallenge: CLIENT_MANAGER role assignment complete (challengeId=${
          ret.id
        }) ${buildLogContext()}`,
      );
    }
  } else {
    if (currentUser.handle) {
      logger.debug(
        `createChallenge: assigning MANAGER role to creator (challengeId=${
          ret.id
        }) ${buildLogContext()}`,
      );
      await helper.createResource(ret.id, ret.createdBy, config.MANAGER_ROLE_ID);
      logger.debug(
        `createChallenge: MANAGER role assignment complete (challengeId=${
          ret.id
        }) ${buildLogContext()}`,
      );
    }
  }

  // post bus event
  logger.info(
    `createChallenge: posting bus event ${constants.Topics.ChallengeCreated} (challengeId=${
      ret.id
    }) ${buildLogContext()}`,
  );
  await helper.postBusEvent(constants.Topics.ChallengeCreated, ret);
  logger.info(
    `createChallenge: bus event posted ${constants.Topics.ChallengeCreated} (challengeId=${
      ret.id
    }) ${buildLogContext()}`,
  );

  return helper.removeNullProperties(sanitizeBillingMarkupForCaller(currentUser, ret));
}
createChallenge.schema = {
  currentUser: Joi.any(),
  challenge: Joi.object()
    .keys({
      typeId: Joi.id(),
      trackId: Joi.id(),
      legacy: Joi.object().keys({
        reviewType: Joi.string()
          .valid(..._.values(ReviewTypeEnum))
          .insensitive()
          .default(ReviewTypeEnum.INTERNAL),
        confidentialityType: Joi.string().default(config.DEFAULT_CONFIDENTIALITY_TYPE),
        forumId: Joi.number().integer(),
        directProjectId: Joi.number().integer(),
        screeningScorecardId: Joi.number().integer(),
        reviewScorecardId: Joi.number().integer(),
        isTask: Joi.boolean(),
        useSchedulingAPI: Joi.boolean(),
        pureV5Task: Joi.boolean(),
        pureV5: Joi.boolean(),
        selfService: Joi.boolean(),
        selfServiceCopilot: Joi.string(),
      }),
      billing: Joi.object()
        .keys({
          billingAccountId: Joi.string(),
          markup: Joi.number().min(0).max(100),
          clientBillingRate: Joi.number().min(0).max(100),
        })
        .unknown(true),
      task: Joi.object().keys({
        isTask: Joi.boolean().default(false),
        isAssigned: Joi.boolean().default(false),
        memberId: Joi.string().allow(null),
      }),
      name: Joi.string().required(),
      description: Joi.string(),
      privateDescription: Joi.string(),
      descriptionFormat: Joi.string(),
      wiproAllowed: Joi.boolean().optional(),
      funChallenge: Joi.boolean().optional(),
      challengeSource: Joi.string(),
      numOfRegistrants: Joi.number().integer().min(0).optional(),
      numOfSubmissions: Joi.number().integer().min(0).optional(),
      numOfCheckpointSubmissions: Joi.number().integer().min(0).optional(),
      metadata: Joi.array()
        .items(
          Joi.object().keys({
            name: Joi.string().required(),
            value: Joi.when("name", {
              is: Joi.valid(
                constants.ChallengeMetadataNames
                  .ALLOW_ALL_REGISTRANTS_TO_DOWNLOAD_WINNING_SUBMISSIONS,
                constants.ChallengeMetadataNames.IS_TEST_CHALLENGE,
              ),
              then: Joi.string()
                .valid(...constants.BOOLEAN_METADATA_VALUES)
                .strict()
                .required(),
              otherwise: Joi.required(),
            }),
          }),
        )
        .unique((a, b) => a.name === b.name),
      timelineTemplateId: Joi.string(), // Joi.optionalId(),
      phases: Joi.array().items(
        Joi.object().keys({
          phaseId: Joi.id(),
          duration: Joi.number().integer().min(0),
          constraints: Joi.array()
            .items(
              Joi.object()
                .keys({
                  name: Joi.string(),
                  value: Joi.number().integer().min(0),
                })
                .optional(),
            )
            .optional(),
        }),
      ),
      events: Joi.array().items(
        Joi.object().keys({
          id: Joi.number().required(),
          name: Joi.string(),
          key: Joi.string(),
        }),
      ),
      discussions: Joi.array().items(
        Joi.object().keys({
          id: Joi.optionalId(),
          name: Joi.string().required(),
          type: Joi.string()
            .required()
            .valid(..._.values(DiscussionTypeEnum)),
          provider: Joi.string().required(),
          url: Joi.string(),
          options: Joi.array().items(Joi.object()),
        }),
      ),
      reviewers: Joi.array().items(
        Joi.object().keys({
          scorecardId: Joi.string().required(),
          isMemberReview: Joi.boolean().required(),
          shouldOpenOpportunity: Joi.boolean().default(true),
          memberReviewerCount: Joi.when("isMemberReview", {
            is: true,
            then: Joi.number().integer().min(1).required(),
            otherwise: Joi.forbidden(),
          }),
          phaseId: Joi.id().required(),
          type: Joi.when("isMemberReview", {
            is: true,
            then: Joi.string()
              .valid(..._.values(ReviewOpportunityTypeEnum))
              .insensitive(),
            otherwise: Joi.forbidden(),
          }),
          aiWorkflowId: Joi.when("isMemberReview", {
            is: false,
            then: Joi.string().required(),
            otherwise: Joi.forbidden(),
          }),
          fixedAmount: Joi.number().min(0).optional().allow(null),
          baseCoefficient: Joi.number().min(0).max(1).optional().allow(null),
          incrementalCoefficient: Joi.number().min(0).max(1).optional().allow(null),
        }),
      ),
      prizeSets: Joi.array().items(
        Joi.object().keys({
          type: Joi.string()
            .valid(..._.values(PrizeSetTypeEnum))
            .required(),
          description: Joi.string(),
          prizes: Joi.array()
            .items(
              Joi.object().keys({
                description: Joi.string(),
                type: Joi.string().required(),
                value: Joi.number().min(0).required(),
              }),
            )
            .min(1)
            .required(),
        }),
      ),
      tags: Joi.array().items(Joi.string()), // tag names
      projectId: Joi.number().integer().positive(),
      legacyId: Joi.number().integer().positive(),
      constraints: Joi.object()
        .keys({
          allowedRegistrants: Joi.array().items(Joi.string().trim().lowercase()).optional(),
        })
        .optional(),
      startDate: Joi.date().iso(),
      approvalStatus: Joi.string()
        .valid(...Object.values(CHALLENGE_APPROVAL_STATUS))
        .insensitive(),
      approvalRejectionReason: Joi.string().allow(null, ""),
      approvalApprovedBy: Joi.string().allow(null, ""),
      status: Joi.string().valid(
        ChallengeStatusEnum.ACTIVE,
        ChallengeStatusEnum.NEW,
        ChallengeStatusEnum.DRAFT,
        ChallengeStatusEnum.APPROVED,
      ),
      groups: Joi.array().items(Joi.optionalId()).unique(),
      // gitRepoURLs: Joi.array().items(Joi.string().uri()),
      terms: Joi.array().items(
        Joi.object().keys({
          id: Joi.id(),
          roleId: Joi.id(),
        }),
      ),
      skills: Joi.array()
        .items(
          Joi.object()
            .keys({
              id: Joi.id(),
            })
            .unknown(true),
        )
        .optional(),
    })
    .required(),
  userToken: Joi.string().required(),
};

/**
 * Get challenge.
 * @param {Object} currentUser the user who perform operation
 * @param {String} id the challenge id
 * @param {Boolean} checkIfExists flag to check if challenge exists
 * @returns {Object} the challenge with given id. Interactive callers keep
 * billing details only when they already have project write access.
 */
async function getChallenge(currentUser, id, checkIfExists?: any) {
  // Log the ID of the challenge being requested
  logger.info(`Requesting challenge by id: ${id}`);
  const challenge = await prisma.challenge.findUnique({
    where: { id },
    include: includeReturnFields,
  });
  if (_.isNil(challenge) || _.isNil(challenge.id)) {
    throw new errors.NotFoundError(`Challenge of id ${id} is not found.`);
  }
  await helper.ensureChallengeWhitelistAccess(currentUser, challenge.id);
  if (checkIfExists) {
    return _.pick(challenge, ["id", "legacyId"]);
  }
  await helper.ensureUserCanViewChallenge(currentUser, challenge);
  const taskInfo = helper.getTaskInfo(challenge);

  // Remove privateDescription for unregistered users
  if (currentUser) {
    if (!currentUser.isMachine && !hasAdminRole(currentUser)) {
      const hasProjectWriteAccess = await helper.userHasProjectWriteAccess(
        challenge.projectId,
        currentUser,
      );

      if (!hasProjectWriteAccess) {
        _.unset(challenge, "billing");
      }

      if (_.isEmpty(challenge.privateDescription)) {
        _.unset(challenge, "privateDescription");
      } else if (!taskInfo.isTask || !taskInfo.isAssigned) {
        if (!hasProjectWriteAccess) {
          const memberResources = await helper.listResourcesByMemberAndChallenge(
            currentUser.userId,
            challenge.id,
          );
          if (_.isEmpty(memberResources)) {
            _.unset(challenge, "privateDescription");
          }
        }
      }
    }
  } else {
    _.unset(challenge, "billing");
    _.unset(challenge, "privateDescription");
  }

  if (challenge.status !== ChallengeStatusEnum.COMPLETED) {
    if (shouldExposeCheckpointWinners(challenge)) {
      challenge.winners = _.filter(
        challenge.winners,
        (winner) => winner.type === PrizeSetTypeEnum.CHECKPOINT,
      );
    } else {
      _.unset(challenge, "winners");
    }
  }

  // TODO: in the long run we wanna do a finer grained filtering of the payments
  if (!hasAdminRole(currentUser) && !_.get(currentUser, "isMachine", false)) {
    _.unset(challenge, "payments");
  }

  await applyLatestSubmissionCounts([challenge]);

  prismaHelper.convertModelToResponse(challenge);

  // Enrich skills data with full details from standardized skills API
  await enrichSkillsData(challenge);

  enrichChallengeForResponse(challenge, challenge.track, challenge.type);

  // Note: numOfRegistrants and numOfSubmissions are no longer calculated here.

  return helper.removeNullProperties(sanitizeBillingMarkupForCaller(currentUser, challenge));
}
getChallenge.schema = {
  currentUser: Joi.any(),
  id: Joi.id(),
  checkIfExists: Joi.boolean(),
};

/**
 * Get challenge statistics
 * @param {Object} currentUser the user who perform operation
 * @param {String} id the challenge id
 * @returns {Object} the challenge statistics for the given challenge
 * @throws {NotFoundError} when the challenge does not exist
 * @throws {ForbiddenError} when the current user cannot view the challenge
 */
async function getChallengeStatistics(currentUser, id) {
  const challenge = await prisma.challenge.findUnique({
    where: { id },
  });
  if (_.isNil(challenge) || _.isNil(challenge.id)) {
    throw new errors.NotFoundError(`Challenge of id ${id} is not found.`);
  }
  await helper.ensureUserCanViewChallenge(currentUser, challenge);
  // get submissions
  console.log("Getting challenge submissions for challenge ID: " + id);
  const submissions = await helper.getChallengeSubmissions(id);
  console.log(`Found ${submissions.length} submissions`);
  if (submissions.length === 0) {
    return [];
  }
  // for each submission, load member profile
  const map = {};
  for (const submission of submissions) {
    if (!map[submission.memberId]) {
      console.log("Finding member ID: " + submission.memberId);
      // Load member profile and cache
      const member = await helper.getMemberById(submission.memberId);
      map[submission.memberId] = {
        photoUrl: member.photoURL,
        rating: _.get(member, "maxRating.rating", 0),
        ratingColor: _.get(member, "maxRating.ratingColor", "#9D9FA0"),
        homeCountryCode: member.homeCountryCode,
        handle: member.handle,
        submissions: [],
      };
    }
    // add submission
    map[submission.memberId].submissions.push({
      created: submission.createdAt,
      score: _.get(
        _.find(submission.review || [], (r) => r.metadata),
        "score",
        0,
      ),
    });
  }
  return _.map(_.keys(map), (userId) => map[userId]);
}
getChallengeStatistics.schema = {
  currentUser: Joi.any(),
  id: Joi.id(),
};

/**
 * Check whether given two PrizeSet Array are different.
 * @param {Array} prizeSets the first PrizeSet Array
 * @param {Array} otherPrizeSets the second PrizeSet Array
 * @returns {Boolean} true if different, false otherwise
 */
function isDifferentPrizeSets(prizeSets = [], otherPrizeSets = []) {
  const buildPrizeKeys = (sets) =>
    _.sortBy(
      _.flatMap(sets || [], (prizeSet) => {
        const normalizedType = _.toString(_.get(prizeSet, "type", ""))
          .trim()
          .toUpperCase();
        const prizes = Array.isArray(prizeSet && prizeSet.prizes) ? prizeSet.prizes : [];

        return prizes.map((prize) => {
          const normalizedValue = _.toString(_.get(prize, "value", "")).trim();
          return `${normalizedType}:${normalizedValue}`;
        });
      }),
    );

  return !_.isEqual(buildPrizeKeys(prizeSets), buildPrizeKeys(otherPrizeSets));
}

/**
 * Validate the winners array.
 * @param {Array} winners the Winner Array
 * @param {Array} challengeResources the challenge resources
 */
function buildCombinedWinnerPayload(data: any = {}) {
  const combined = [];
  if (Array.isArray(data.winners)) {
    combined.push(
      ...data.winners.map((winner) => ({
        ...winner,
        type: _.toUpper(winner.type || PrizeSetTypeEnum.PLACEMENT),
      })),
    );
  }
  if (Array.isArray(data.checkpointWinners)) {
    combined.push(
      ...data.checkpointWinners.map((winner) => ({
        ...winner,
        type: _.toUpper(winner.type || PrizeSetTypeEnum.CHECKPOINT),
      })),
    );
  }
  return combined;
}

async function validateWinners(winners, challengeResources) {
  const registrants = _.filter(challengeResources, (r) => r.roleId === config.SUBMITTER_ROLE_ID);
  for (const prizeType of _.values(PrizeSetTypeEnum)) {
    const filteredWinners = _.filter(winners, (w) => w.type === prizeType);
    for (const winner of filteredWinners) {
      if (!_.find(registrants, (r) => _.toString(r.memberId) === _.toString(winner.userId))) {
        throw new errors.BadRequestError(
          `Member with userId: ${winner.userId} is not registered on the challenge`,
        );
      }
      const diffWinners = _.differenceWith(filteredWinners, [winner], _.isEqual);
      if (diffWinners.length + 1 !== filteredWinners.length) {
        throw new errors.BadRequestError(
          `Duplicate member with placement: ${helper.toString(winner)}`,
        );
      }

      // find another member with the placement
      const placementExists = _.find(diffWinners, function (w) {
        return w.placement === winner.placement;
      });
      if (
        placementExists &&
        (placementExists.userId !== winner.userId || placementExists.handle !== winner.handle)
      ) {
        throw new errors.BadRequestError(
          `Only one member can have a placement: ${winner.placement}`,
        );
      }

      // find another placement for a member
      const memberExists = _.find(diffWinners, function (w) {
        return w.userId === winner.userId && w.type === winner.type;
      });
      if (memberExists && memberExists.placement !== winner.placement) {
        throw new errors.BadRequestError(
          `The same member ${winner.userId} cannot have multiple placements`,
        );
      }
    }
  }
}

/**
 * Task shouldn't be launched/completed when it is assigned to the current user self.
 * E.g: stop copilots from paying themselves, thus copilots will need to contact manager to launch/complete the task.
 * @param {Object} currentUser the user who perform operation
 * @param {Object} challenge the existing challenge
 * @param {Object} data the new input challenge data
 * @param {Array} challengeResources the challenge resources
 */
function validateTask(currentUser, challenge, data, challengeResources) {
  const isTask = helper.getTaskInfo(challenge).isTask || _.get(challenge, "legacy.pureV5Task");

  if (!isTask) {
    // Not a Task
    return;
  }

  // Status changed to ACTIVE, indicating launch a Task
  const isLaunchTask =
    data.status === ChallengeStatusEnum.ACTIVE && challenge.status !== ChallengeStatusEnum.ACTIVE;

  // Status changed to COMPLETED, indicating complete a Task
  const isCompleteTask =
    data.status === ChallengeStatusEnum.COMPLETED &&
    challenge.status !== ChallengeStatusEnum.COMPLETED;

  // When complete a Task, input data should have winners
  if (isCompleteTask && (!data.winners || !data.winners.length)) {
    throw new errors.BadRequestError("The winners is required to complete a Task");
  }

  if (!currentUser.isMachine && (isLaunchTask || isCompleteTask)) {
    // Whether task is assigned to current user
    const assignedToCurrentUser =
      _.filter(
        challengeResources,
        (r) =>
          r.roleId === config.SUBMITTER_ROLE_ID &&
          _.toString(r.memberId) === _.toString(currentUser.userId),
      ).length > 0;

    if (assignedToCurrentUser) {
      throw new errors.ForbiddenError(
        `You are not allowed to ${
          data.status === ChallengeStatusEnum.ACTIVE ? "lanuch" : "complete"
        } task assigned to yourself. Please contact manager to operate.`,
      );
    }
  }
}

/**
 * Normalizes optional text values used by launch validation.
 *
 * @param {unknown} value Raw upstream value.
 * @returns {string|undefined} Trimmed string or `undefined` when empty.
 */
function normalizeOptionalString(value) {
  if (_.isNil(value)) {
    return undefined;
  }

  const normalizedValue = _.toString(value).trim();

  return normalizedValue || undefined;
}

/**
 * Normalizes optional numeric values used by launch validation.
 *
 * @param {unknown} value Raw upstream value.
 * @returns {number|undefined} Parsed number or `undefined` when invalid.
 */
function normalizeOptionalNumber(value) {
  if (_.isNil(value) || value === "") {
    return undefined;
  }

  const normalizedValue = _.toNumber(value);

  return Number.isFinite(normalizedValue) ? normalizedValue : undefined;
}

/**
 * Resolves billing-account activity from either a boolean field or textual
 * status returned by upstream services.
 *
 * @param {object|undefined|null} billingAccount Billing-account metadata.
 * @returns {boolean|undefined} Billing-account activity flag when available.
 */
function resolveBillingAccountActive(billingAccount) {
  if (_.isBoolean(_.get(billingAccount, "active"))) {
    return billingAccount.active;
  }

  const normalizedStatus = normalizeOptionalString(_.get(billingAccount, "status"));

  if (!normalizedStatus) {
    return undefined;
  }

  if (normalizedStatus.toUpperCase() === "ACTIVE") {
    return true;
  }

  if (normalizedStatus.toUpperCase() === "INACTIVE") {
    return false;
  }

  return undefined;
}

/**
 * Determines whether a billing account should be treated as expired.
 *
 * @param {boolean|undefined} active Billing-account activity flag.
 * @param {string|undefined} endDate Billing-account end date.
 * @returns {boolean} `true` when the billing account has expired.
 */
function isBillingAccountExpired(active, endDate) {
  if (active === false) {
    return true;
  }

  if (!endDate) {
    return false;
  }

  const endDateTimestamp = Date.parse(endDate);

  if (Number.isNaN(endDateTimestamp)) {
    return false;
  }

  return Date.now() >= endDateTimestamp;
}

/**
 * Determines whether challenge billing funds checks should be skipped for a
 * billing account.
 *
 * Missing, inactive, and not-found checks still apply. The bypass is intended
 * for specific accounts that must remain launchable despite expired dates or
 * depleted remaining budget, and that should not call the budget-lock endpoint
 * because it enforces the same remaining-funds constraint.
 *
 * @param {string|number|null|undefined} billingAccountId Billing-account identifier.
 * @returns {boolean} `true` when expiry/funds validation should be skipped.
 */
function shouldIgnoreChallengeActivationBillingValidation(billingAccountId) {
  const normalizedBillingAccountId = normalizeOptionalString(billingAccountId);

  if (!normalizedBillingAccountId) {
    return false;
  }

  return _.includes(
    normalizeConfiguredBillingAccountIds(config.IGNORED_CHALLENGE_ACTIVATION_BILLING_ACCOUNT_IDS),
    normalizedBillingAccountId,
  );
}

/**
 * Validates the project billing account before activating a challenge.
 *
 * @param {object} params Validation inputs.
 * @param {boolean|undefined|null} params.active Billing-account activity returned by Projects API.
 * @param {string|number|null|undefined} params.billingAccountId Project billing-account identifier.
 * @param {object} params.challenge Existing challenge model.
 * @param {string|undefined|null} params.endDate Billing-account end date returned by Projects API.
 * @returns {Promise<void>} Resolves when the billing account can be used for launch.
 * @throws {errors.BadRequestError} When the billing account is missing, inactive, or not found, or
 * for non-ignored billing accounts, expired or depleted.
 */
async function validateChallengeActivationBillingAccount({
  active,
  billingAccountId,
  challenge,
  endDate,
}) {
  if (!challengeHelper.isProjectIdRequired(challenge.timelineTemplateId)) {
    return;
  }

  const normalizedBillingAccountId = normalizeOptionalString(billingAccountId);
  const shouldIgnoreExpiryAndFundsValidation = shouldIgnoreChallengeActivationBillingValidation(
    normalizedBillingAccountId,
  );

  if (!normalizedBillingAccountId) {
    throw new errors.BadRequestError(
      "Cannot activate challenge because the project has no billing account.",
    );
  }

  const resolvedProjectActive = _.isBoolean(active) ? active : undefined;
  const resolvedProjectEndDate = normalizeOptionalString(endDate);

  if (resolvedProjectActive === false) {
    throw new errors.BadRequestError(
      "Cannot activate challenge because the project billing account is inactive.",
    );
  }

  if (
    !shouldIgnoreExpiryAndFundsValidation &&
    isBillingAccountExpired(resolvedProjectActive, resolvedProjectEndDate)
  ) {
    throw new errors.BadRequestError(
      "Cannot activate challenge because the project billing account is expired.",
    );
  }

  const billingAccountDetails = await projectHelper.getBillingAccountDetails(
    normalizedBillingAccountId,
  );
  const resolvedActive = resolveBillingAccountActive(billingAccountDetails);
  const resolvedEndDate = normalizeOptionalString(_.get(billingAccountDetails, "endDate"));

  if (!billingAccountDetails) {
    throw new errors.BadRequestError(
      "Cannot activate challenge because the project billing account could not be found.",
    );
  }

  if (resolvedActive === false) {
    throw new errors.BadRequestError(
      "Cannot activate challenge because the project billing account is inactive.",
    );
  }

  if (
    !shouldIgnoreExpiryAndFundsValidation &&
    isBillingAccountExpired(resolvedActive, resolvedEndDate)
  ) {
    throw new errors.BadRequestError(
      "Cannot activate challenge because the project billing account is expired.",
    );
  }

  const remainingBudget = normalizeOptionalNumber(billingAccountDetails.totalBudgetRemaining);

  if (!shouldIgnoreExpiryAndFundsValidation && !_.isNil(remainingBudget) && remainingBudget <= 0) {
    throw new errors.BadRequestError(
      "Cannot activate challenge because the project billing account has insufficient remaining funds.",
    );
  }
}

function prepareTaskCompletionData(challenge, challengeResources, data) {
  const isTask = helper.getTaskInfo(challenge).isTask || _.get(challenge, "legacy.pureV5Task");
  const isCompleteTask =
    data.status === ChallengeStatusEnum.COMPLETED &&
    challenge.status !== ChallengeStatusEnum.COMPLETED;

  if (!isTask || !isCompleteTask) {
    return null;
  }

  const submitters = _.filter(
    challengeResources,
    (resource) => resource.roleId === config.SUBMITTER_ROLE_ID,
  );

  if (!submitters || submitters.length === 0) {
    throw new errors.BadRequestError("Task has no submitter resource");
  }

  if (!data.winners || data.winners.length === 0) {
    const submitter = submitters[0];
    data.winners = [
      {
        userId: parseInt(submitter.memberId, 10),
        handle: submitter.memberHandle,
        placement: 1,
        type: PrizeSetTypeEnum.PLACEMENT,
      },
    ];
  }

  const completionTime = new Date().toISOString();
  const startTime = challenge.startDate || completionTime;

  const updatedPhases = _.map(challenge.phases || [], (phase) => ({
    id: phase.id,
    phaseId: phase.phaseId,
    name: phase.name,
    description: phase.description,
    duration: phase.duration,
    scheduledStartDate: phase.scheduledStartDate,
    scheduledEndDate: phase.scheduledEndDate,
    predecessor: phase.predecessor,
    constraints: _.cloneDeep(phase.constraints),
    actualStartDate: startTime,
    actualEndDate: completionTime,
    isOpen: false,
  }));

  data.phases = updatedPhases;

  return {
    shouldTriggerPayments: true,
    completionTime,
    startTime,
  };
}

/**
 * Update challenge.
 * When a challenge transitions to completed task status or a cancelled status,
 * payment generation is requested after the database update commits.
 * Fun challenges and challenges billed to configured Topgear accounts skip manual budget approval
 * and remain approved.
 * Updates that start in or transition to a completed/cancelled status may not change the effective
 * `is_test_challenge` metadata value.
 * @param {Object} currentUser the user who perform operation
 * @param {String} challengeId the challenge id
 * @param {Object} data the challenge data to be updated
 * @returns {Object} the updated challenge
 * @throws {BadRequestError} if an update starting or finishing terminal changes the test flag
 */
// Note: `options` may be a boolean for backward compatibility (emitEvent flag),
// or an object { emitEvent?: boolean }.
async function updateChallenge(currentUser, challengeId, data, options: any = {}) {
  // Backward compatibility for callers passing a boolean as the 4th arg
  let emitEvent = true;
  if (typeof options === "boolean") {
    emitEvent = options;
  } else if (options && Object.prototype.hasOwnProperty.call(options, "emitEvent")) {
    emitEvent = options.emitEvent !== false;
  }
  const challenge = await prisma.challenge.findUnique({
    where: { id: challengeId },
    include: includeReturnFields,
  });
  if (!challenge || !challenge.id) {
    throw new errors.NotFoundError(`Challenge with id: ${challengeId} doesn't exist`);
  }
  await helper.ensureChallengeWhitelistAccess(currentUser, challenge.id);
  enrichChallengeForResponse(challenge);
  prismaHelper.convertModelToResponse(challenge);
  ensureTerminalTestChallengeMetadataIsUnchanged(challenge, data);
  const originalChallengePhases = _.cloneDeep(challenge.phases || []);
  const auditUserId = _.toString(currentUser.userId);
  const payloadIncludesTerms =
    !_.isNil(data) && Object.prototype.hasOwnProperty.call(data, "terms");
  const originalTermsValue = payloadIncludesTerms ? data.terms : undefined;

  // No conversion needed - values are already in dollars in the database

  let projectId, billingAccountId, markup, billingAccountActive, billingAccountEndDate;
  if (challengeHelper.isProjectIdRequired(challenge.timelineTemplateId)) {
    projectId = _.get(challenge, "projectId");

    logger.debug(
      `updateChallenge(${challengeId}): requesting billing information for project ${projectId}`,
    );
    ({
      billingAccountId,
      markup,
      active: billingAccountActive,
      endDate: billingAccountEndDate,
    } = await projectHelper.getProjectBillingInformation(projectId));
    logger.debug(
      `updateChallenge(${challengeId}): billing lookup complete (hasAccount=${
        billingAccountId != null
      })`,
    );

    const existingBillingAccountId = normalizeOptionalString(
      _.get(challenge, "billing.billingAccountId"),
    );
    const projectBillingAccountId = normalizeOptionalString(billingAccountId);
    if (projectBillingAccountId && !existingBillingAccountId) {
      data.billing = {
        ..._.get(challenge, "billing", {}),
        ..._.get(data, "billing", {}),
        billingAccountId: projectBillingAccountId,
        markup: _.isNil(markup) ? 0 : markup,
      };
    }

    // Make sure the user cannot change the direct project ID
    if (data.legacy) {
      data.legacy = _.assign({}, challenge.legacy, data.legacy);
      _.set(data, "legacy.directProjectId", challenge.legacy.directProjectId);
    }
  }

  // Treat incoming `reviews` payloads as an alias for `reviewers`
  if (!_.isNil(data.reviews)) {
    if (!Array.isArray(data.reviews)) {
      throw new BadRequestError("reviews must be an array");
    }
    if (_.isNil(data.reviewers)) {
      data.reviewers = _.cloneDeep(data.reviews);
    }
    delete data.reviews;
  }

  data = preserveBillingMarkupForCopilotUpdate(currentUser, data, challenge);
  const effectiveFunChallenge = _.isBoolean(data.funChallenge)
    ? data.funChallenge
    : challenge.funChallenge === true;
  const rawApprovalRejectionReason = _.toString(_.get(data, "approvalRejectionReason", ""));

  // Remove fields from data that are not allowed to be updated and that match the existing challenge
  data = sanitizeData(sanitizeChallenge(data), challenge);
  const sanitizedIncludesTerms = Object.prototype.hasOwnProperty.call(data, "terms");
  const shouldReplaceTerms =
    sanitizedIncludesTerms || (payloadIncludesTerms && originalTermsValue === null);
  const canApproveChallengeBudget = await userCanApproveChallengeBudget(currentUser, challenge);
  const requestedApprovalStatus = normalizeApprovalStatus(data.approvalStatus);
  const prizeSetsUpdated =
    Array.isArray(data.prizeSets) && isDifferentPrizeSets(data.prizeSets, challenge.prizeSets);
  const approvalBillingAccountId = getApprovalFlowBillingAccountId(
    challenge,
    data,
    billingAccountId,
  );
  const skipsChallengeApprovalFlow = applyChallengeApprovalFlowBypass(
    data,
    approvalBillingAccountId,
    effectiveFunChallenge,
  );

  if (!skipsChallengeApprovalFlow) {
    if (
      requestedApprovalStatus != null &&
      requestedApprovalStatus !== challenge.approvalStatus &&
      !canApproveChallengeBudget
    ) {
      throw new errors.ForbiddenError(
        "Only admins or project managers with full access can change the challenge budget approval status.",
      );
    }

    if (requestedApprovalStatus === CHALLENGE_APPROVAL_STATUS.REJECTED) {
      const rejectionReason = rawApprovalRejectionReason.trim();
      if (!rejectionReason) {
        throw new errors.BadRequestError(
          "Rejection reason is required when rejecting a challenge.",
        );
      }
      data.approvalRejectionReason = rejectionReason;
      data.approvalApprovedBy = null;
    } else if (requestedApprovalStatus === CHALLENGE_APPROVAL_STATUS.APPROVED) {
      data.approvalRejectionReason = null;
      data.approvalApprovedBy = _.toString(currentUser.handle || "").trim() || null;
    } else if (requestedApprovalStatus === CHALLENGE_APPROVAL_STATUS.PENDING_APPROVAL) {
      data.approvalRejectionReason = null;
      data.approvalApprovedBy = null;
    }

    if (
      prizeSetsUpdated &&
      challenge.status !== ChallengeStatusEnum.ACTIVE &&
      (requestedApprovalStatus == null || !canApproveChallengeBudget)
    ) {
      data.approvalStatus = CHALLENGE_APPROVAL_STATUS.PENDING_APPROVAL;
      data.approvalRejectionReason = null;
      data.approvalApprovedBy = null;
    }
  }

  if (
    challenge.status === ChallengeStatusEnum.ACTIVE &&
    prizeSetsUpdated &&
    !canApproveChallengeBudget
  ) {
    throw new errors.ForbiddenError(
      "Prizes and copilot fee are locked after launch. Contact the Project Manager for updates.",
    );
  }

  const resolvedApprovalStatus =
    normalizeApprovalStatus(data.approvalStatus) ||
    normalizeApprovalStatus(challenge.approvalStatus) ||
    CHALLENGE_APPROVAL_STATUS.PENDING_APPROVAL;
  logger.debug(`Sanitized Data: ${JSON.stringify(data)}`);

  logger.debug(`updateChallenge(${challengeId}): fetching challenge resources`);
  const challengeResources = await helper.getChallengeResources(challengeId);
  logger.debug(
    `updateChallenge(${challengeId}): fetched ${challengeResources.length} challenge resources`,
  );

  logger.debug(`updateChallenge(${challengeId}): validating update payload`);
  await challengeHelper.validateChallengeUpdateRequest(
    currentUser,
    challenge,
    data,
    challengeResources,
  );
  logger.debug(`updateChallenge(${challengeId}): payload validation complete`);
  validateTask(currentUser, challenge, data, challengeResources);
  const taskCompletionInfo = prepareTaskCompletionData(challenge, challengeResources, data);

  const isStatusChangingToActive =
    data.status === ChallengeStatusEnum.ACTIVE && challenge.status !== ChallengeStatusEnum.ACTIVE;
  const isStatusChangingToCompleted =
    data.status === ChallengeStatusEnum.COMPLETED &&
    challenge.status !== ChallengeStatusEnum.COMPLETED;

  if (
    isStatusChangingToActive &&
    shouldBlockChallengeLaunchForApproval(
      resolvedApprovalStatus,
      approvalBillingAccountId,
      effectiveFunChallenge,
    )
  ) {
    throw new errors.BadRequestError(
      "Challenge launch is blocked until budget approval is Approved.",
    );
  }

  let sendActivationEmail = false;
  let sendSubmittedEmail = false;
  let sendCompletedEmail = false;
  let sendRejectedEmail = false;

  /* BEGIN self-service stuffs */

  // TODO: At some point in the future this should be moved to a Self-Service Challenge Helper

  if (challenge.legacy.selfService) {
    // prettier-ignore
    sendSubmittedEmail = data.status === ChallengeStatusEnum.DRAFT && challenge.status !== ChallengeStatusEnum.DRAFT;

    if (data.metadata && data.metadata.length > 0) {
      let dynamicDescription = _.cloneDeep(data.description || challenge.description);
      for (const entry of data.metadata) {
        const regexp = new RegExp(`{{${entry.name}}}`, "g");
        dynamicDescription = dynamicDescription.replace(regexp, entry.value);
      }
      data.description = dynamicDescription;
    }

    // check if it's a self service challenge and project needs to be activated first
    if (
      (data.status === ChallengeStatusEnum.APPROVED ||
        data.status === ChallengeStatusEnum.ACTIVE) &&
      challenge.status !== ChallengeStatusEnum.ACTIVE &&
      challengeHelper.isProjectIdRequired(challenge.timelineTemplateId)
    ) {
      try {
        const selfServiceProjectName = `Self service - ${challenge.createdBy} - ${challenge.name}`;
        const workItemSummary = _.get(
          _.find(_.get(challenge, "metadata", []), (m) => m.name === "websitePurpose.description"),
          "value",
          "N/A",
        );
        logger.debug(
          `updateChallenge(${challengeId}): activating self-service project ${projectId}`,
        );
        await helper.activateProject(
          projectId,
          currentUser,
          selfServiceProjectName,
          workItemSummary,
        );

        sendActivationEmail = data.status === ChallengeStatusEnum.ACTIVE;
      } catch (e) {
        await updateChallenge(
          currentUser,
          challengeId,
          {
            ...data,
            status: ChallengeStatusEnum.CANCELLED_PAYMENT_FAILED,
            cancelReason: `Failed to activate project. Error: ${e.message}. JSON: ${JSON.stringify(
              e,
            )}`,
          },
          false,
        );
        throw new errors.BadRequestError(
          "Failed to activate the challenge! The challenge has been canceled!",
        );
      }
    }

    if (
      data.status === ChallengeStatusEnum.DRAFT &&
      challengeHelper.isProjectIdRequired(challenge.timelineTemplateId)
    ) {
      try {
        logger.debug(
          `updateChallenge(${challengeId}): updating self-service project info for project ${projectId}`,
        );
        await helper.updateSelfServiceProjectInfo(
          projectId,
          data.endDate || challenge.endDate,
          currentUser,
        );
      } catch (e) {
        logger.debug(`There was an error trying to update the project: ${e.message}`);
      }
    }

    if (
      (data.status === ChallengeStatusEnum.CANCELLED_REQUIREMENTS_INFEASIBLE ||
        data.status === ChallengeStatusEnum.CANCELLED_PAYMENT_FAILED) &&
      challengeHelper.isProjectIdRequired(challenge.timelineTemplateId)
    ) {
      try {
        logger.debug(
          `updateChallenge(${challengeId}): cancelling self-service project ${challenge.projectId}`,
        );
        await helper.cancelProject(challenge.projectId, data.cancelReason, currentUser);
      } catch (e) {
        logger.debug(`There was an error trying to cancel the project: ${e.message}`);
      }
      sendRejectedEmail = true;
    }
  }

  /* END self-service stuffs */

  const isChallengeBeingActivated = isStatusChangingToActive;
  let isChallengeBeingCancelled = false;
  const allowActivePhaseShortening = phaseHelper.isDesignTrack(challenge.track);
  const preventPhaseShortening =
    challenge.status === ChallengeStatusEnum.ACTIVE && !allowActivePhaseShortening;
  const isStatusChangingToCancelled =
    isCancelledChallengeStatus(data.status) && !isCancelledChallengeStatus(challenge.status);
  if (data.status) {
    if (data.status === ChallengeStatusEnum.ACTIVE) {
      await validateChallengeActivationBillingAccount({
        active: billingAccountActive,
        billingAccountId,
        challenge,
        endDate: billingAccountEndDate,
      });
    }

    if (isCancelledChallengeStatus(data.status)) {
      isChallengeBeingCancelled = true;
    }

    if (data.status === ChallengeStatusEnum.COMPLETED) {
      if (
        !_.get(challenge, "legacy.pureV5Task") &&
        !_.get(challenge, "legacy.pureV5") &&
        challenge.status !== ChallengeStatusEnum.ACTIVE
      ) {
        throw new errors.BadRequestError("You cannot mark a DRAFT challenge as COMPLETED");
      }
      sendCompletedEmail = true;
    }
  }

  // Only M2M can update url and options of discussions
  if (data.discussions && data.discussions.length > 0) {
    if (challenge.discussions && challenge.discussions.length > 0) {
      for (let i = 0; i < data.discussions.length; i += 1) {
        if (_.isUndefined(data.discussions[i].id)) {
          data.discussions[i].id = uuid();
          if (!currentUser.isMachine) {
            _.unset(data.discussions, "url");
            _.unset(data.discussions, "options");
          }
        } else if (!currentUser.isMachine) {
          const existingDiscussion = _.find(
            _.get(challenge, "discussions", []),
            (d) => d.id === data.discussions[i].id,
          );
          if (existingDiscussion) {
            _.assign(data.discussions[i], _.pick(existingDiscussion, ["url", "options"]));
          } else {
            _.unset(data.discussions, "url");
            _.unset(data.discussions, "options");
          }
        }
      }
    } else {
      for (let i = 0; i < data.discussions.length; i += 1) {
        data.discussions[i].id = uuid();
        data.discussions[i].name = data.discussions[i].name.substring(
          0,
          config.FORUM_TITLE_LENGTH_LIMIT,
        );
      }
    }
  }

  // Auto-select the AI Only timeline template for AI_ONLY challenges, and revert to the
  // default template when the AI_ONLY config is removed. Runs on draft saves and activation.
  const isDraftSave = [ChallengeStatusEnum.NEW, ChallengeStatusEnum.DRAFT].includes(challenge.status) && !isStatusChangingToActive;
  let cachedActivationAiConfig = null;
  let aiConfigFetched = false;
  if (isStatusChangingToActive || isDraftSave) {
    try {
      cachedActivationAiConfig = await helper.getAIReviewConfigByChallengeId(challengeId);
      aiConfigFetched = true;
      const currentTemplateId = data.timelineTemplateId || challenge.timelineTemplateId;
      if (cachedActivationAiConfig?.mode === 'AI_ONLY') {
        if (currentTemplateId !== config.AI_ONLY_TIMELINE_TEMPLATE_ID) {
          logger.debug(
            `updateChallenge: AI_ONLY mode detected, switching to AI Only timeline template (challengeId=${challengeId})`,
          );
          data.timelineTemplateId = config.AI_ONLY_TIMELINE_TEMPLATE_ID;
        }
      } else if (isDraftSave && currentTemplateId === config.AI_ONLY_TIMELINE_TEMPLATE_ID) {
        // AI_ONLY config was removed; revert to the default template for this challenge's type+track
        const defaultTemplates = await ChallengeTimelineTemplateService.searchChallengeTimelineTemplates({
          typeId: challenge.typeId,
          trackId: challenge.trackId,
          isDefault: true,
        });
        const defaultTemplate = defaultTemplates.result[0];
        if (defaultTemplate) {
          logger.debug(
            `updateChallenge: AI_ONLY config removed, reverting to default timeline template ${defaultTemplate.timelineTemplateId} (challengeId=${challengeId})`,
          );
          data.timelineTemplateId = defaultTemplate.timelineTemplateId;
        } else {
          logger.debug(
            `updateChallenge: AI_ONLY config removed but no default template found for typeId=${challenge.typeId} trackId=${challenge.trackId}; keeping current template (challengeId=${challengeId})`,
          );
        }
      }
    } catch (_err) {
      // non-fatal: if AI config fetch fails, proceed without template override
      logger.debug(
        `updateChallenge: failed to fetch AI review config for template auto-select (challengeId=${challengeId}): ${_err.message}`,
      );
    }
  }

  // TODO: Fix this Tech Debt once legacy is turned off
  const finalStatus = data.status || challenge.status;
  const finalTimelineTemplateId = data.timelineTemplateId || challenge.timelineTemplateId;
  let timelineTemplateChanged = false;
  const isAiOnlyTemplateSwitch = cachedActivationAiConfig?.mode === 'AI_ONLY';
  // True when the AI_ONLY config was removed and we are auto-reverting the template back to default.
  // Requires a confirmed fetch (aiConfigFetched) so we don't revert on transient API failures.
  const isAiOnlyTemplateRevert =
    aiConfigFetched &&
    isDraftSave &&
    challenge.timelineTemplateId === config.AI_ONLY_TIMELINE_TEMPLATE_ID &&
    cachedActivationAiConfig?.mode !== 'AI_ONLY';
  if (
    !currentUser.isMachine &&
    !hasAdminRole(currentUser) &&
    !_.get(data, "legacy.pureV5") &&
    !_.get(challenge, "legacy.pureV5")
  ) {
    if (
      finalStatus !== ChallengeStatusEnum.NEW &&
      finalTimelineTemplateId !== challenge.timelineTemplateId &&
      !isAiOnlyTemplateSwitch &&
      !isAiOnlyTemplateRevert
    ) {
      throw new errors.BadRequestError(
        `Cannot change the timelineTemplateId for challenges with status: ${finalStatus}`,
      );
    } else if (
      (isAiOnlyTemplateSwitch || isAiOnlyTemplateRevert) &&
      finalTimelineTemplateId !== challenge.timelineTemplateId
    ) {
      // Auto-managed template change: clear existing phases so they are re-populated from the new template
      challenge.phases = [];
      timelineTemplateChanged = true;
    }
  } else if (finalTimelineTemplateId !== challenge.timelineTemplateId) {
    // make sure there are no previous phases if the timeline template has changed
    challenge.phases = [];
    timelineTemplateChanged = true;
  }

  if (data.prizeSets) {
    if (
      isDifferentPrizeSets(data.prizeSets, challenge.prizeSets) &&
      finalStatus === ChallengeStatusEnum.COMPLETED
    ) {
      // Allow only M2M to update prizeSets for completed challenges
      if (!currentUser.isMachine || (challenge.task != null && challenge.task.isTask !== true)) {
        throw new errors.BadRequestError(
          `Cannot update prizeSets for challenges with status: ${finalStatus}!`,
        );
      }
    }

    const prizeSetsGroup = _.groupBy(data.prizeSets, "type");
    if (prizeSetsGroup[PrizeSetTypeEnum.PLACEMENT]) {
      const totalPrizes = helper.sumOfPrizes(prizeSetsGroup[PrizeSetTypeEnum.PLACEMENT][0].prizes);
      _.assign(data, { overview: { totalPrizes } });
    }
  }

  let phasesUpdated = false;
  let phasesForUpdate = null;
  if (
    ((data.phases && data.phases.length > 0) ||
      isChallengeBeingActivated ||
      timelineTemplateChanged) &&
    !isChallengeBeingCancelled
  ) {
    if (
      challenge.status === ChallengeStatusEnum.COMPLETED ||
      challenge.status.indexOf(ChallengeStatusEnum.CANCELLED) > -1
    ) {
      throw new BadRequestError(
        `Challenge phase/start date can not be modified for COMPLETED or CANCELLED challenges.`,
      );
    }
    const newStartDate = data.startDate || challenge.startDate;
    let newPhases;
    if (timelineTemplateChanged) {
      newPhases = await phaseHelper.populatePhasesForChallengeCreation(
        data.phases,
        newStartDate,
        finalTimelineTemplateId,
      );
    } else {
      newPhases = await phaseHelper.populatePhasesForChallengeUpdate(
        challenge.phases,
        data.phases,
        challenge.timelineTemplateId,
        isChallengeBeingActivated,
        { allowActivePhaseShortening, preventPhaseShortening },
      );
    }
    phasesUpdated = true;
    data.phases = newPhases;
    phasesForUpdate = _.cloneDeep(newPhases);
  }
  if (isChallengeBeingCancelled && challenge.phases && challenge.phases.length > 0) {
    data.phases = phaseHelper.handlePhasesAfterCancelling(challenge.phases);
    phasesUpdated = true;
    phasesForUpdate = _.cloneDeep(data.phases);
  }
  const hasAIReviewers = (reviewers) =>
    Array.isArray(reviewers) &&
    reviewers.some(
      (reviewer) =>
        reviewer &&
        reviewer.isMemberReview === false &&
        !_.isNil(reviewer.aiWorkflowId) &&
        _.toString(reviewer.aiWorkflowId).trim() !== "",
    );

  const hadAIReviewersBeforeUpdate = hasAIReviewers(challenge.reviewers);
  const hasAIReviewersAfterUpdate = hasAIReviewers(
    !_.isNil(data.reviewers) ? data.reviewers : challenge.reviewers,
  );
  logger.debug(
    `updateChallenge: AI reviewers - before=${hadAIReviewersBeforeUpdate}, after=${hasAIReviewersAfterUpdate}`,
  );
  logger.debug(
    `updateChallenge: reviewersPayloadPreview=${JSON.stringify(
      (!_.isNil(data.reviewers) ? data.reviewers : challenge.reviewers) || [],
    ).slice(0, 200)}`,
  );
  const isActiveWithNewAIReviewers =
    challenge.status === ChallengeStatusEnum.ACTIVE &&
    !hadAIReviewersBeforeUpdate &&
    hasAIReviewersAfterUpdate;
  logger.debug(`updateChallenge: isActiveWithNewAIReviewers=${isActiveWithNewAIReviewers}`);
  // AI_ONLY challenges use the AI Review phase instead of AI Screening; never add AI Screening for them
  const isAiOnlyActivation = isStatusChangingToActive && cachedActivationAiConfig?.mode === 'AI_ONLY';
  const shouldEnsureAIScreeningPhase =
    (isStatusChangingToActive && !isAiOnlyActivation) || isActiveWithNewAIReviewers;
  logger.debug(
    `updateChallenge: shouldEnsureAIScreeningPhase=${shouldEnsureAIScreeningPhase} isStatusChangingToActive=${isStatusChangingToActive} isAiOnlyActivation=${isAiOnlyActivation}`,
  );

  // Add AI screening phase when activating a challenge, or when AI reviewers are newly added
  // to an already ACTIVE challenge.
  if (shouldEnsureAIScreeningPhase) {
    logger.debug(
      `updateChallenge: checking if AI screening phase needs to be added (challengeId=${challengeId})`,
    );
    const tempChallenge = {
      phases: _.cloneDeep(phasesForUpdate || challenge.phases),
      reviewers: _.cloneDeep(data.reviewers || challenge.reviewers),
    };
    logger.debug(
      `updateChallenge: tempChallenge preview reviewers=${JSON.stringify(
        tempChallenge.reviewers || [],
      ).slice(0, 200)} phasesCount=${(tempChallenge.phases || []).length}`,
    );
    const debugLogForAI = (message) =>
      logger.debug(`updateChallenge(AI screening): ${message} (challengeId=${challengeId})`);
    await challengeHelper.addAIScreeningPhaseForChallenge(tempChallenge, prisma, debugLogForAI);
    logger.info(
      `updateChallenge: AI screening phase ensured (challengeId=${challengeId}) resultingPhases=${
        (tempChallenge.phases || []).length
      }`,
    );
    // Update phasesForUpdate with the updated phases after AI screening addition
    phasesForUpdate = tempChallenge.phases;
    phasesUpdated = true;
    data.phases = phasesForUpdate;
  }

  const phasesForDates = phasesUpdated ? data.phases : challenge.phases;

  if (phasesUpdated || data.startDate) {
    const startSource =
      phasesForDates && phasesForDates.length > 0
        ? _.min(_.map(phasesForDates, "scheduledStartDate"))
        : data.startDate || challenge.startDate;

    if (!_.isNil(startSource)) {
      data.startDate = convertToISOString(startSource);
    }
  }
  if (phasesUpdated || data.endDate) {
    const endSource =
      phasesForDates && phasesForDates.length > 0
        ? _.max(_.map(phasesForDates, "scheduledEndDate"))
        : data.endDate || challenge.endDate;

    if (!_.isNil(endSource)) {
      data.endDate = convertToISOString(endSource);
    }
  }

  if (taskCompletionInfo) {
    const { completionTime, startTime } = taskCompletionInfo;
    if (_.isNil(data.startDate)) {
      data.startDate = startTime;
    }
    data.endDate = completionTime;

    if (Array.isArray(phasesForUpdate) && phasesForUpdate.length > 0) {
      const normalizedStartDate = data.startDate || startTime;
      phasesForUpdate = phasesForUpdate.map((phase) => ({
        ...phase,
        actualStartDate: phase.actualStartDate || normalizedStartDate,
        actualEndDate: phase.actualEndDate || completionTime,
        isOpen: false,
      }));
      data.phases = phasesForUpdate;
    }
  }

  const combinedWinnerPayload = buildCombinedWinnerPayload(data);
  if (combinedWinnerPayload.length > 0) {
    await validateWinners(combinedWinnerPayload, challengeResources);
  }

  const isTaskChallenge =
    helper.getTaskInfo(challenge).isTask || _.get(challenge, "legacy.pureV5Task");

  if (isTaskChallenge && !_.isUndefined(data.winners)) {
    _.each(data.winners, (w) => {
      w.type = PrizeSetTypeEnum.PLACEMENT;
    });
  }

  // Only m2m tokens are allowed to modify the `task.*` information on a challenge
  if (!_.isUndefined(_.get(data, "task")) && !currentUser.isMachine) {
    if (!_.isUndefined(_.get(challenge, "task"))) {
      logger.info(
        `User ${
          currentUser.handle || currentUser.sub
        } is not allowed to modify the task information on challenge ${challengeId}`,
      );
      data.task = challenge.task;
      logger.info(
        `Task information on challenge ${challengeId} is reset to ${JSON.stringify(
          challenge.task,
        )}. Original data: ${JSON.stringify(data.task)}`,
      );
    } else {
      delete data.task;
    }
  }

  // task.memberId goes out of sync due to another processor setting "task.memberId" but subsequent immediate update to the task
  // will not have the memberId set. So we need to set it using winners to ensure it is always in sync. The proper fix is to correct
  // the sync issue in the processor. However this is quick fix that works since winner.userId is task.memberId.
  if (isTaskChallenge && !_.isUndefined(data.winners)) {
    const winnerMemberId = _.get(data.winners, "[0].userId");
    logger.info(
      `Setting task.memberId to ${winnerMemberId} for challenge ${challengeId}. Task ${_.get(
        data,
        "task",
      )} - ${_.get(challenge, "task")}`,
    );

    if (winnerMemberId != null && _.get(data, "task.memberId") !== winnerMemberId) {
      logger.info(`Task ${challengeId} has a winner ${winnerMemberId}`);
      data.task = {
        isTask: true,
        isAssigned: true,
        memberId: winnerMemberId,
      };
      logger.warn(
        `task.memberId mismatched with winner memberId. task.memberId is updated to ${winnerMemberId}`,
      );
    } else {
      logger.info(`task ${challengeId} has no winner set yet.`);
    }
  } else {
    logger.info(`${challengeId} is not a task challenge or has no winners set yet.`);
  }

  const finalTypeId = data.typeId || challenge.typeId;
  const finalTrackId = data.trackId || challenge.trackId;
  const { track, type } = await challengeHelper.validateAndGetChallengeTypeAndTrack({
    typeId: finalTypeId,
    trackId: finalTrackId,
    timelineTemplateId: timelineTemplateChanged
      ? finalTimelineTemplateId
      : challenge.timelineTemplateId,
  });
  const isStandardTaskType =
    _.isString(_.get(type, "name")) && _.get(type, "name").trim().toLowerCase() === "task";

  if (_.get(type, "isTask")) {
    if (!_.isEmpty(_.get(data, "task.memberId"))) {
      const registrants = _.filter(
        challengeResources,
        (r) => r.roleId === config.SUBMITTER_ROLE_ID,
      );
      if (
        !_.find(
          registrants,
          (r) => _.toString(r.memberId) === _.toString(_.get(data, "task.memberId")),
        )
      ) {
        throw new errors.BadRequestError(
          `Member ${_.get(
            data,
            "task.memberId",
          )} is not a submitter resource of challenge ${challengeId}`,
        );
      }
    }
  }

  if (!_.isUndefined(data.terms)) {
    data.terms = await helper.validateChallengeTerms(data.terms);
  }

  if (data.phases && data.phases.length > 0) {
    if (deepEqual(data.phases, challenge.phases)) {
      delete data.phases;
    }
  }
  if (_.isNil(data.phases)) {
    phasesForUpdate = null;
  }

  // Normalize and validate reviewers' phase references before converting to Prisma input
  if (!_.isNil(data.reviewers)) {
    try {
      // Build maps from the existing challenge phases
      const challengePhaseIdToPhaseId = new Map(); // ChallengePhase.id -> Phase.id
      const phaseIdsOnChallenge = new Set(); // Phase.id present on this challenge
      if (challenge && Array.isArray(challenge.phases)) {
        for (const p of challenge.phases) {
          if (p && p.id && p.phaseId) {
            challengePhaseIdToPhaseId.set(p.id, p.phaseId);
            phaseIdsOnChallenge.add(p.phaseId);
          }
        }
      }

      // First pass: map any reviewer.phaseId that actually points to a ChallengePhase.id
      for (const r of data.reviewers) {
        if (r && r.phaseId && challengePhaseIdToPhaseId.has(r.phaseId)) {
          r.phaseId = challengePhaseIdToPhaseId.get(r.phaseId);
        }
      }

      // Validate all referenced Phase ids exist
      const uniquePhaseIds = _.uniq(
        data.reviewers.filter((r) => r && r.phaseId).map((r) => r.phaseId),
      );
      if (uniquePhaseIds.length > 0) {
        const foundPhases = await prisma.phase.findMany({ where: { id: { in: uniquePhaseIds } } });
        const foundIds = new Set(foundPhases.map((p) => p.id));
        const missing = uniquePhaseIds.filter((id) => !foundIds.has(id));
        if (missing.length > 0) {
          throw new errors.BadRequestError(
            `Invalid reviewer.phaseId value(s); Phase not found: ${missing.join(", ")}`,
          );
        }
      }
    } catch (e) {
      // Re-throw as BadRequest to avoid nested Prisma errors later
      if (!(e instanceof errors.BadRequestError)) {
        throw new errors.BadRequestError(e.message || "Invalid reviewer phase reference");
      }
      throw e;
    }
  }

  if (!_.isNil(data.reviewers)) {
    await ensureScorecardChangeDoesNotConflict({
      challengeId,
      originalReviewers: challenge.reviewers || [],
      updatedReviewers: data.reviewers,
      originalChallengePhases,
    });
  }

  if (
    isStatusChangingToActive &&
    !isStandardTaskType &&
    (challenge.status === ChallengeStatusEnum.NEW || challenge.status === ChallengeStatusEnum.DRAFT)
  ) {
    // For AI_ONLY review mode, manual reviewers are not required; skip validation
    let isAiOnlyReviewMode = false;
    try {
      // Reuse the config fetched earlier for template auto-select if available
      const activationAiConfig = cachedActivationAiConfig ?? await helper.getAIReviewConfigByChallengeId(challengeId);
      isAiOnlyReviewMode = activationAiConfig?.mode === 'AI_ONLY';
    } catch (_err) {
      // non-fatal: proceed with standard reviewer validation if AI config fetch fails
    }

    if (!isAiOnlyReviewMode) {
      const effectiveReviewers = Array.isArray(data.reviewers)
        ? data.reviewers
        : Array.isArray(challenge.reviewers)
          ? challenge.reviewers
          : [];

      const reviewersMissingFields = [];
      effectiveReviewers.forEach((reviewer, index) => {
        const hasScorecardId =
          reviewer && !_.isNil(reviewer.scorecardId) && String(reviewer.scorecardId).trim() !== "";
        const hasPhaseId =
          reviewer && !_.isNil(reviewer.phaseId) && String(reviewer.phaseId).trim() !== "";

        if (!hasScorecardId || !hasPhaseId) {
          const missing = [];
          if (!hasScorecardId) missing.push("scorecardId");
          if (!hasPhaseId) missing.push("phaseId");
          reviewersMissingFields.push(`reviewer[${index}] missing ${missing.join(" and ")}`);
        }
      });

      if (reviewersMissingFields.length > 0) {
        throw new errors.BadRequestError(
          `Cannot activate challenge; reviewers are missing required fields: ${reviewersMissingFields.join(
            "; ",
          )}`,
        );
      }

      const reviewerPhaseIds = new Set(
        effectiveReviewers
          .filter((reviewer) => reviewer && reviewer.phaseId)
          .map((reviewer) => String(reviewer.phaseId)),
      );

      if (reviewerPhaseIds.size === 0) {
        throw new errors.BadRequestError(
          "Cannot activate a challenge without at least one reviewer configured",
        );
      }

      const normalizePhaseName = (name) =>
        String(name || "")
          .trim()
          .toLowerCase();
      const effectivePhases =
        (Array.isArray(phasesForUpdate) && phasesForUpdate.length > 0
          ? phasesForUpdate
          : challenge.phases) || [];

      const missingPhaseNames = new Set();
      for (const phase of effectivePhases) {
        if (!phase) {
          continue;
        }
        const normalizedName = normalizePhaseName(phase.name);
        if (!REQUIRED_REVIEW_PHASE_NAME_SET.has(normalizedName)) {
          continue;
        }
        const phaseId = _.get(phase, "phaseId");
        if (!phaseId || !reviewerPhaseIds.has(String(phaseId))) {
          missingPhaseNames.add(phase.name || "Unknown phase");
        }
      }

      if (missingPhaseNames.size > 0) {
        throw new errors.BadRequestError(
          `Cannot activate challenge; missing reviewers for phase(s): ${Array.from(
            missingPhaseNames,
          ).join(", ")}`,
        );
      }
    }
  }

  // convert data to prisma models
  const updateData = prismaHelper.convertChallengeSchemaToPrisma(
    currentUser,
    _.omit(data, ["cancelReason"]),
  );
  updateData.updatedBy = _.toString(currentUser.userId);
  // reset createdBy
  delete updateData.createdBy;
  if (!_.isNil(updateData.phases)) {
    delete updateData.phases;
  }

  const updatedChallenge = await prisma.$transaction(async (tx) => {
    if (Array.isArray(phasesForUpdate)) {
      await syncChallengePhases(
        tx,
        challengeId,
        phasesForUpdate,
        auditUserId,
        originalChallengePhases,
      );
    }
    // drop nested data if updated
    if (!_.isNil(updateData.legacyRecord)) {
      await tx.challengeLegacy.deleteMany({ where: { challengeId } });
    }
    if (!_.isNil(updateData.billingRecord)) {
      await tx.challengeBilling.deleteMany({ where: { challengeId } });
    }
    if (!_.isNil(updateData.constraintRecord)) {
      await tx.challengeConstraint.deleteMany({ where: { challengeId } });
    }
    if (!_.isNil(updateData.events)) {
      await tx.challengeEvent.deleteMany({ where: { challengeId } });
    }
    if (!_.isNil(updateData.discussions)) {
      await tx.challengeDiscussion.deleteMany({ where: { challengeId } });
    }
    if (!_.isNil(updateData.metadata)) {
      await tx.challengeMetadata.deleteMany({ where: { challengeId } });
    }
    if (!_.isNil(updateData.prizeSets)) {
      await tx.challengePrizeSet.deleteMany({ where: { challengeId } });
    }
    if (!_.isNil(updateData.reviewers)) {
      await tx.challengeReviewer.deleteMany({ where: { challengeId } });
    }
    if (!_.isNil(updateData.winners)) {
      await tx.challengeWinner.deleteMany({ where: { challengeId } });
    }
    if (shouldReplaceTerms) {
      await tx.challengeTerm.deleteMany({ where: { challengeId } });
    }
    if (!_.isNil(updateData.skills)) {
      await tx.challengeSkill.deleteMany({ where: { challengeId } });
    }

    return await tx.challenge.update({
      data: updateData,
      where: { id: challengeId },
      include: includeReturnFields,
    });
  });
  await syncChallengeBillingAccountLock(updatedChallenge);
  if (taskCompletionInfo && taskCompletionInfo.shouldTriggerPayments) {
    logger.info(`Triggering payment generation for Task challenge ${challengeId}`);
    try {
      const paymentSuccess = await helper.generateChallengePayments(challengeId);
      if (!paymentSuccess) {
        logger.warn(`Failed to generate payments for Task challenge ${challengeId}`);
      }
    } catch (err) {
      logger.error(`Error generating payments for Task challenge ${challengeId}: ${err.message}`);
    }
  }
  if (isStatusChangingToCancelled) {
    logger.info(`Triggering payment generation for cancelled challenge ${challengeId}`);
    try {
      const paymentSuccess = await helper.generateChallengePayments(challengeId);
      if (!paymentSuccess) {
        logger.warn(`Failed to generate payments for cancelled challenge ${challengeId}`);
      }
    } catch (err) {
      logger.error(
        `Error generating payments for cancelled challenge ${challengeId}: ${err.message}`,
      );
    }
  }
  // Re-fetch the challenge outside the transaction to ensure we publish
  // only after the commit succeeds and using the committed snapshot.
  if (emitEvent) {
    const committed = await prisma.challenge.findUnique({
      where: { id: challengeId },
      include: includeReturnFields,
    });
    await indexChallengeAndPostToKafka(committed, track, type);
  }

  if (isStatusChangingToCompleted) {
    logger.info(`Triggering member rating updates for completed challenge ${challengeId}`);
    void helper.rerateChallengeSubmitterRatings(challengeId);
  }

  // Convert to response shape before any business-logic checks that expect it
  prismaHelper.convertModelToResponse(updatedChallenge);
  await enrichSkillsData(updatedChallenge);
  enrichChallengeForResponse(updatedChallenge);

  if (_.get(updatedChallenge, "legacy.selfService")) {
    const creator = await helper.getMemberByHandle(updatedChallenge.createdBy);
    if (sendSubmittedEmail) {
      await helper.sendSelfServiceNotification(
        constants.SelfServiceNotificationTypes.WORK_REQUEST_SUBMITTED,
        [{ email: creator.email }],
        {
          handle: creator.handle,
          workItemName: updatedChallenge.name,
        },
      );
    }
    if (sendActivationEmail) {
      await helper.sendSelfServiceNotification(
        constants.SelfServiceNotificationTypes.WORK_REQUEST_STARTED,
        [{ email: creator.email }],
        {
          handle: creator.handle,
          workItemName: updatedChallenge.name,
          workItemUrl: `${config.SELF_SERVICE_APP_URL}/work-items/${updatedChallenge.id}`,
        },
      );
    }
    if (sendCompletedEmail) {
      await helper.sendSelfServiceNotification(
        constants.SelfServiceNotificationTypes.WORK_COMPLETED,
        [{ email: creator.email }],
        {
          handle: creator.handle,
          workItemName: updatedChallenge.name,
          workItemUrl: `${config.SELF_SERVICE_APP_URL}/work-items/${updatedChallenge.id}?tab=solutions`,
        },
      );
    }
    if (sendRejectedEmail || data.cancelReason) {
      logger.debug("Should send redirected email");
      await helper.sendSelfServiceNotification(
        constants.SelfServiceNotificationTypes.WORK_REQUEST_REDIRECTED,
        [{ email: creator.email }],
        {
          handle: creator.handle,
          workItemName: updatedChallenge.name,
        },
      );
    }
  }

  return helper.removeNullProperties(sanitizeBillingMarkupForCaller(currentUser, updatedChallenge));
}

updateChallenge.schema = {
  currentUser: Joi.any(),
  challengeId: Joi.id(),
  data: Joi.object()
    .keys({
      legacy: Joi.object()
        .keys({
          track: Joi.string(),
          subTrack: Joi.string(),
          reviewType: Joi.string()
            .valid(..._.values(ReviewTypeEnum))
            .insensitive()
            .default(ReviewTypeEnum.INTERNAL),
          confidentialityType: Joi.string()
            .allow(null, "")
            .empty(null, "")
            .default(config.DEFAULT_CONFIDENTIALITY_TYPE),
          directProjectId: Joi.number(),
          forumId: Joi.number().integer(),
          isTask: Joi.boolean(),
          useSchedulingAPI: Joi.boolean(),
          pureV5Task: Joi.boolean(),
          pureV5: Joi.boolean(),
          selfService: Joi.boolean(),
          selfServiceCopilot: Joi.string().allow(null),
        })
        .unknown(true),
      cancelReason: Joi.string().optional(),
      task: Joi.object()
        .keys({
          isTask: Joi.boolean().default(false),
          isAssigned: Joi.boolean().default(false),
          memberId: Joi.alternatives().try(Joi.string().allow(null), Joi.number().allow(null)),
        })
        .optional(),
      billing: Joi.object()
        .keys({
          billingAccountId: Joi.string(),
          markup: Joi.number().min(0).max(100),
        })
        .unknown(true),
      trackId: Joi.optionalId(),
      typeId: Joi.optionalId(),
      name: Joi.string().optional(),
      description: Joi.string().optional(),
      privateDescription: Joi.string().allow("").optional(),
      descriptionFormat: Joi.string().optional(),
      wiproAllowed: Joi.boolean().optional(),
      funChallenge: Joi.boolean().optional(),
      challengeSource: Joi.string().optional(),
      numOfRegistrants: Joi.number().integer().min(0).optional(),
      numOfSubmissions: Joi.number().integer().min(0).optional(),
      numOfCheckpointSubmissions: Joi.number().integer().min(0).optional(),
      metadata: Joi.array()
        .items(
          Joi.object()
            .keys({
              name: Joi.string().required(),
              value: Joi.when("name", {
                is: Joi.valid(
                  constants.ChallengeMetadataNames
                    .ALLOW_ALL_REGISTRANTS_TO_DOWNLOAD_WINNING_SUBMISSIONS,
                  constants.ChallengeMetadataNames.IS_TEST_CHALLENGE,
                ),
                then: Joi.string()
                  .valid(...constants.BOOLEAN_METADATA_VALUES)
                  .strict()
                  .required(),
                otherwise: Joi.required(),
              }),
            })
            .unknown(true),
        )
        .unique((a, b) => a.name === b.name),
      timelineTemplateId: Joi.string().optional(), // changing this to update migrated challenges
      phases: Joi.array()
        .items(
          Joi.object()
            .keys({
              phaseId: Joi.id(),
              duration: Joi.number().integer().min(0),
              isOpen: Joi.boolean(),
              actualEndDate: Joi.date().allow(null),
              scheduledStartDate: Joi.date().allow(null),
              scheduledEndDate: Joi.date().allow(null),
              constraints: Joi.array()
                .items(
                  Joi.object()
                    .keys({
                      name: Joi.string(),
                      value: Joi.number().integer().min(0),
                    })
                    .optional(),
                )
                .optional(),
            })
            .unknown(true),
        )
        .min(1)
        .optional(),
      events: Joi.array().items(
        Joi.object()
          .keys({
            id: Joi.number().required(),
            name: Joi.string(),
            key: Joi.string(),
          })
          .unknown(true)
          .optional(),
      ),
      discussions: Joi.array()
        .items(
          Joi.object().keys({
            id: Joi.optionalId(),
            name: Joi.string().required(),
            type: Joi.string()
              .required()
              .valid(..._.values(DiscussionTypeEnum)),
            provider: Joi.string().required(),
            url: Joi.string(),
            options: Joi.array().items(Joi.object()),
          }),
        )
        .optional(),
      reviewers: Joi.array()
        .items(
          Joi.object().keys({
            scorecardId: Joi.string().required(),
            isMemberReview: Joi.boolean().required(),
            shouldOpenOpportunity: Joi.boolean().default(true),
            memberReviewerCount: Joi.when("isMemberReview", {
              is: true,
              then: Joi.number().integer().min(1).required(),
              otherwise: Joi.forbidden(),
            }),
            phaseId: Joi.id().required(),
            type: Joi.when("isMemberReview", {
              is: true,
              then: Joi.string()
                .valid(..._.values(ReviewOpportunityTypeEnum))
                .insensitive(),
              otherwise: Joi.forbidden(),
            }),
            aiWorkflowId: Joi.when("isMemberReview", {
              is: false,
              then: Joi.string().required(),
              otherwise: Joi.forbidden(),
            }),
            fixedAmount: Joi.number().min(0).optional().allow(null),
            baseCoefficient: Joi.number().min(0).max(1).optional().allow(null),
            incrementalCoefficient: Joi.number().min(0).max(1).optional().allow(null),
          }),
        )
        .optional(),
      startDate: Joi.date().iso(),
      prizeSets: Joi.array()
        .items(
          Joi.object()
            .keys({
              type: Joi.string()
                .valid(..._.values(PrizeSetTypeEnum))
                .required(),
              description: Joi.string(),
              prizes: Joi.array()
                .items(
                  Joi.object().keys({
                    description: Joi.string(),
                    type: Joi.string().required(),
                    value: Joi.number().min(0).required(),
                  }),
                )
                .min(1)
                .required(),
            })
            .unknown(true),
        )
        .min(1),
      tags: Joi.array().items(Joi.string()), // tag names
      projectId: Joi.number().integer().positive(),
      legacyId: Joi.number().integer().positive(),
      constraints: Joi.object()
        .keys({
          allowedRegistrants: Joi.array().items(Joi.string().trim().lowercase()).optional(),
        })
        .optional(),
      status: Joi.string()
        .valid(..._.values(ChallengeStatusEnum))
        .insensitive(),
      approvalStatus: Joi.string()
        .valid(...Object.values(CHALLENGE_APPROVAL_STATUS))
        .insensitive(),
      approvalRejectionReason: Joi.string().allow(null, ""),
      approvalApprovedBy: Joi.string().allow(null, ""),
      attachments: Joi.array().items(
        Joi.object().keys({
          id: Joi.id(),
          challengeId: Joi.id(),
          name: Joi.string().required(),
          url: Joi.string().uri().required(),
          fileSize: Joi.fileSize(),
          description: Joi.string(),
        }),
      ),
      groups: Joi.array().items(Joi.optionalId()).unique(),
      // gitRepoURLs: Joi.array().items(Joi.string().uri()),
      winners: Joi.array()
        .items(
          Joi.object()
            .keys({
              userId: Joi.number().integer().positive().required(),
              handle: Joi.string().required(),
              placement: Joi.number().integer().positive().required(),
              type: Joi.string().valid(..._.values(PrizeSetTypeEnum)),
            })
            .unknown(true),
        )
        .optional(),
      checkpointWinners: Joi.array()
        .items(
          Joi.object()
            .keys({
              userId: Joi.number().integer().positive().required(),
              handle: Joi.string().required(),
              placement: Joi.number().integer().positive().required(),
              type: Joi.string().valid(..._.values(PrizeSetTypeEnum)),
            })
            .unknown(true),
        )
        .optional(),
      terms: Joi.array().items(
        Joi.object().keys({
          id: Joi.id(),
          roleId: Joi.id(),
        }),
      ),
      skills: Joi.array()
        .items(
          Joi.object()
            .keys({
              id: Joi.id(),
            })
            .unknown(true),
        )
        .optional(),
      overview: Joi.any().forbidden(),
    })
    .unknown(true)
    .required(),
};

/**
 * Send notifications
 * @param {Object} currentUser the current use
 * @param {String} challengeId the challenge id
 */
async function sendNotifications(currentUser, challengeId) {
  const challenge = await getChallenge(currentUser, challengeId);
  const creator = await helper.getMemberByHandle(challenge.createdBy);
  if (challenge.status === ChallengeStatusEnum.COMPLETED) {
    await helper.sendSelfServiceNotification(
      constants.SelfServiceNotificationTypes.WORK_COMPLETED,
      [{ email: creator.email }],
      {
        handle: creator.handle,
        workItemName: challenge.name,
        workItemUrl: `${config.SELF_SERVICE_APP_URL}/work-items/${challenge.id}?tab=solutions`,
      },
    );
    return { type: constants.SelfServiceNotificationTypes.WORK_COMPLETED };
  }
}

sendNotifications.schema = {
  currentUser: Joi.any(),
  challengeId: Joi.id(),
};

async function ensureScorecardChangeDoesNotConflict({
  challengeId,
  originalReviewers = [],
  updatedReviewers = [],
  originalChallengePhases = [],
}) {
  if (!Array.isArray(originalReviewers) || originalReviewers.length === 0) {
    return;
  }

  const originalByPhase = new Map();
  for (const reviewer of originalReviewers) {
    if (!reviewer || _.isNil(reviewer.phaseId)) {
      continue;
    }
    const phaseKey = String(reviewer.phaseId);
    if (!originalByPhase.has(phaseKey)) {
      originalByPhase.set(phaseKey, []);
    }
    originalByPhase.get(phaseKey).push(reviewer);
  }

  if (originalByPhase.size === 0) {
    return;
  }

  const updatedByPhase = new Map();
  if (Array.isArray(updatedReviewers)) {
    for (const reviewer of updatedReviewers) {
      if (!reviewer || _.isNil(reviewer.phaseId)) {
        continue;
      }
      const phaseKey = String(reviewer.phaseId);
      if (!updatedByPhase.has(phaseKey)) {
        updatedByPhase.set(phaseKey, []);
      }
      updatedByPhase.get(phaseKey).push(reviewer);
    }
  }

  const removedScorecardsByPhase = new Map();
  for (const [phaseKey, originalList] of originalByPhase.entries()) {
    const updatedList = updatedByPhase.get(phaseKey) || [];

    const originalScorecards = Array.from(
      new Set(
        originalList
          .map((r) => (!_.isNil(r) && !_.isNil(r.scorecardId) ? String(r.scorecardId) : null))
          .filter((scorecardId) => !_.isNil(scorecardId)),
      ),
    );

    if (originalScorecards.length === 0) {
      continue;
    }

    const updatedScorecards = Array.from(
      new Set(
        updatedList
          .map((r) => (!_.isNil(r) && !_.isNil(r.scorecardId) ? String(r.scorecardId) : null))
          .filter((scorecardId) => !_.isNil(scorecardId)),
      ),
    );

    const removedScorecards = originalScorecards.filter(
      (scorecardId) => !updatedScorecards.includes(scorecardId),
    );

    if (removedScorecards.length > 0) {
      removedScorecardsByPhase.set(phaseKey, Array.from(new Set(removedScorecards)));
    }
  }

  if (removedScorecardsByPhase.size === 0) {
    return;
  }

  const phaseIdToChallengePhaseIds = new Map();
  for (const phase of originalChallengePhases || []) {
    if (!phase || _.isNil(phase.phaseId) || _.isNil(phase.id)) {
      continue;
    }
    const phaseKey = String(phase.phaseId);
    if (!phaseIdToChallengePhaseIds.has(phaseKey)) {
      phaseIdToChallengePhaseIds.set(phaseKey, new Set());
    }
    phaseIdToChallengePhaseIds.get(phaseKey).add(String(phase.id));
  }

  if (!config.REVIEW_DB_URL) {
    logger.debug(
      `Skipping scorecard change guard for challenge ${challengeId} because REVIEW_DB_URL is not configured`,
    );
    return;
  }

  let reviewClient;
  try {
    reviewClient = getReviewClient();
  } catch (error) {
    logger.warn(
      `Unable to initialize review Prisma client for challenge ${challengeId}: ${error.message}`,
    );
    throw new errors.ServiceUnavailableError(
      "Cannot change the scorecard because review status could not be verified. Please try again later.",
    );
  }

  if (!reviewClient || typeof reviewClient.$queryRaw !== "function") {
    logger.warn(`Prisma review client does not support raw queries for challenge ${challengeId}`);
    throw new errors.ServiceUnavailableError(
      "Cannot change the scorecard because review status could not be verified. Please try again later.",
    );
  }

  const openReviewPhaseNameByKey = new Map();
  for (const phase of originalChallengePhases || []) {
    if (!phase || !phase.isOpen) {
      continue;
    }
    const phaseName = String(phase.name || "").trim();
    if (!phaseName) {
      continue;
    }
    const normalizedName = phaseName.toLowerCase();
    if (!REVIEW_PHASE_NAME_SET.has(normalizedName)) {
      continue;
    }
    const phaseKey = phase.phaseId ? String(phase.phaseId) : null;
    if (!phaseKey) {
      continue;
    }
    openReviewPhaseNameByKey.set(phaseKey, phaseName);
  }

  const reviewPhaseKeysToCheck = Array.from(removedScorecardsByPhase.keys()).filter((phaseKey) =>
    openReviewPhaseNameByKey.has(phaseKey),
  );

  const reviewPhaseKeysSet = new Set(removedScorecardsByPhase.keys());
  const challengePhaseIdsToInspect = new Set();
  for (const phaseKey of reviewPhaseKeysSet) {
    const challengePhaseIds = phaseIdToChallengePhaseIds.get(phaseKey);
    if (!challengePhaseIds) {
      continue;
    }
    for (const challengePhaseId of challengePhaseIds) {
      if (!_.isNil(challengePhaseId)) {
        challengePhaseIdsToInspect.add(String(challengePhaseId));
      }
    }
  }

  const blockingCountByPhase = new Map();
  const blockingCountByPhaseAndScorecard = new Map();

  const challengePhaseIdList = Array.from(challengePhaseIdsToInspect);
  if (challengePhaseIdList.length > 0) {
    const reviewSchema = String(config.REVIEW_DB_SCHEMA || "").trim();
    const reviewTableIdentifier = Prisma.raw(
      reviewSchema ? `"${reviewSchema.replace(/"/g, '""')}"."review"` : '"review"',
    );

    let blockingReviewRows = [];
    try {
      blockingReviewRows = await reviewClient.$queryRaw`
        SELECT "phaseId", "scorecardId", COUNT(*)::int AS "count"
        FROM ${reviewTableIdentifier}
        WHERE "phaseId" IN (${Prisma.join(challengePhaseIdList)})
          AND "status"::text IN (${Prisma.join(REVIEW_STATUS_BLOCKING)})
        GROUP BY "phaseId", "scorecardId"
      `;
    } catch (error) {
      logger.warn(
        `Failed to query the review database for challenge ${challengeId}: ${error.message}`,
      );
      throw new errors.ServiceUnavailableError(
        "Cannot change the scorecard because review status could not be verified. Please try again later.",
      );
    }

    for (const row of blockingReviewRows || []) {
      const phaseId = _.isNil(row?.phaseId) ? null : String(row.phaseId);
      if (!phaseId) {
        continue;
      }
      const countValue = Number(_.get(row, "count", 0));
      if (!Number.isFinite(countValue) || countValue <= 0) {
        continue;
      }

      blockingCountByPhase.set(phaseId, (blockingCountByPhase.get(phaseId) || 0) + countValue);

      const scorecardId = _.isNil(row?.scorecardId) ? null : String(row.scorecardId);
      if (scorecardId) {
        const scorecardKey = `${phaseId}|${scorecardId}`;
        blockingCountByPhaseAndScorecard.set(
          scorecardKey,
          (blockingCountByPhaseAndScorecard.get(scorecardKey) || 0) + countValue,
        );
      }
    }
  }

  if (reviewPhaseKeysToCheck.length > 0) {
    for (const phaseKey of reviewPhaseKeysToCheck) {
      const challengePhaseIds = Array.from(phaseIdToChallengePhaseIds.get(phaseKey) || []);
      if (challengePhaseIds.length === 0) {
        logger.debug(
          `Skipping active phase scorecard guard for challenge ${challengeId} phase ${phaseKey} because no matching challenge phases were found`,
        );
        continue;
      }

      let activePhaseReviewCount = 0;
      for (const challengePhaseId of challengePhaseIds) {
        activePhaseReviewCount += blockingCountByPhase.get(challengePhaseId) || 0;
      }

      if (activePhaseReviewCount > 0) {
        const phaseName = openReviewPhaseNameByKey.get(phaseKey) || "phase";
        throw new BadRequestError(
          `Cannot change the scorecard for phase '${phaseName}' because reviews are already in progress or completed`,
        );
      }
    }
  }

  for (const [phaseKey, scorecardIds] of removedScorecardsByPhase.entries()) {
    const challengePhaseIds = Array.from(phaseIdToChallengePhaseIds.get(phaseKey) || []);

    if (challengePhaseIds.length === 0) {
      logger.debug(
        `Skipping scorecard change guard for challenge ${challengeId} phase ${phaseKey} because no matching challenge phases were found`,
      );
      continue;
    }

    for (const scorecardId of scorecardIds) {
      if (!scorecardId) {
        continue;
      }

      const normalizedScorecardId = String(scorecardId);
      let conflictingReviews = 0;
      for (const challengePhaseId of challengePhaseIds) {
        const scorecardKey = `${challengePhaseId}|${normalizedScorecardId}`;
        conflictingReviews += blockingCountByPhaseAndScorecard.get(scorecardKey) || 0;
      }

      if (conflictingReviews > 0) {
        throw new BadRequestError(
          "Can't change the scorecard at this time because at least one review has already started with the old scorecard",
        );
      }
    }
  }
}

/**
 * Remove unwanted properties from the challenge object
 * @param {Object} challenge the challenge object
 */
function sanitizeChallenge(challenge) {
  const sanitized = _.pick(challenge, [
    "trackId",
    "typeId",
    "name",
    "description",
    "privateDescription",
    "descriptionFormat",
    "challengeSource",
    "timelineTemplateId",
    "tags",
    "projectId",
    "legacyId",
    "startDate",
    "status",
    "approvalStatus",
    "task",
    "groups",
    "cancelReason",
    "constraints",
    "skills",
    "reviewers",
    "wiproAllowed",
    "funChallenge",
    "numOfRegistrants",
    "numOfSubmissions",
    "numOfCheckpointSubmissions",
  ]);
  if (!_.isUndefined(sanitized.name)) {
    sanitized.name = xss(sanitized.name);
  }
  // Only Sanitize description if it is in HTML format
  // Otherwise, it is in Markdown format and we don't want to sanitize it - a future enhancement can be
  // using a markdown sanitizer
  if (challenge.descriptionFormat === "html" && !_.isUndefined(sanitized.description)) {
    sanitized.description = xss(sanitized.description);
  }
  if (challenge.legacy) {
    sanitized.legacy = _.pick(challenge.legacy, [
      "track",
      "subTrack",
      "reviewType",
      "confidentialityType",
      "forumId",
      "directProjectId",
      "screeningScorecardId",
      "reviewScorecardId",
      "isTask",
      "useSchedulingAPI",
      "pureV5Task",
      "pureV5",
      "selfService",
      "selfServiceCopilot",
    ]);
  }
  if (challenge.billing) {
    sanitized.billing = _.pick(challenge.billing, [
      "billingAccountId",
      "markup",
      "clientBillingRate",
    ]);
  }
  if (challenge.metadata) {
    sanitized.metadata = _.map(challenge.metadata, (meta) => _.pick(meta, ["name", "value"]));
  }
  if (challenge.phases) {
    sanitized.phases = _.map(challenge.phases, (phase) =>
      _.pick(phase, [
        "phaseId",
        "duration",
        "scheduledStartDate",
        "scheduledEndDate",
        "constraints",
      ]),
    );
  }
  if (challenge.prizeSets) {
    sanitized.prizeSets = _.map(challenge.prizeSets, (prizeSet) => ({
      ..._.pick(prizeSet, ["type", "description"]),
      prizes: _.map(prizeSet.prizes, (prize) => _.pick(prize, ["description", "type", "value"])),
    }));
  }
  if (challenge.reviewers) {
    sanitized.reviewers = _.map(challenge.reviewers, (rv) =>
      _.pick(rv, [
        "scorecardId",
        "isMemberReview",
        "memberReviewerCount",
        "phaseId",
        "fixedAmount",
        "baseCoefficient",
        "incrementalCoefficient",
        "shouldOpenOpportunity",
        "type",
        "aiWorkflowId",
      ]),
    );
  }
  if (challenge.events) {
    sanitized.events = _.map(challenge.events, (event) => _.pick(event, ["id", "name", "key"]));
  }
  if (challenge.winners) {
    sanitized.winners = _.map(challenge.winners, (winner) =>
      _.pick(winner, ["userId", "handle", "placement", "type"]),
    );
  }
  if (challenge.checkpointWinners) {
    sanitized.checkpointWinners = _.map(challenge.checkpointWinners, (winner) =>
      _.pick(winner, ["userId", "handle", "placement", "type"]),
    );
  }
  if (challenge.discussions) {
    sanitized.discussions = _.map(challenge.discussions, (discussion) => ({
      ..._.pick(discussion, ["id", "provider", "name", "type", "url", "options"]),
      name: _.get(discussion, "name", "").substring(0, config.FORUM_TITLE_LENGTH_LIMIT),
    }));
  }
  if (challenge.terms) {
    const uniqueTerms = helper.dedupeChallengeTerms(challenge.terms || []);
    sanitized.terms = _.map(uniqueTerms, (term) => _.pick(term, ["id", "roleId"]));
  }
  if (challenge.attachments) {
    sanitized.attachments = _.map(challenge.attachments, (attachment) =>
      _.pick(attachment, ["id", "name", "url", "fileSize", "description", "challengeId"]),
    );
  }

  return sanitized;
}

async function syncChallengePhases(
  tx,
  challengeId,
  updatedPhases,
  auditUserId,
  originalPhases = [],
) {
  if (!Array.isArray(updatedPhases)) {
    return;
  }

  const originalById = new Map((originalPhases || []).map((phase) => [phase.id, phase]));
  const originalByPhaseId = new Map();
  for (const original of originalPhases || []) {
    if (!_.isNil(original.phaseId)) {
      originalByPhaseId.set(original.phaseId, original);
    }
  }
  const retainedIds = new Set();

  for (const phase of updatedPhases) {
    if (!phase) continue;

    let recordId = !_.isNil(phase.id) ? phase.id : undefined;
    let phaseDefinitionId = !_.isNil(phase.phaseId) ? phase.phaseId : undefined;

    if (!phaseDefinitionId && recordId && originalById.has(recordId)) {
      phaseDefinitionId = originalById.get(recordId).phaseId;
    }
    if (!recordId && phaseDefinitionId && originalByPhaseId.has(phaseDefinitionId)) {
      recordId = originalByPhaseId.get(phaseDefinitionId).id;
    }
    if (!phaseDefinitionId && recordId && originalById.has(recordId)) {
      phaseDefinitionId = originalById.get(recordId).phaseId;
    }
    if (!phaseDefinitionId) {
      throw new BadRequestError("Cannot update challenge phases without phaseId");
    }
    if (!recordId) {
      recordId = uuid();
    }

    const existing = originalById.get(recordId);
    retainedIds.add(recordId);

    const scalarKeys = [
      "name",
      "description",
      "isOpen",
      "duration",
      "scheduledStartDate",
      "scheduledEndDate",
      "actualStartDate",
      "actualEndDate",
      "challengeSource",
    ];
    const phaseData: any = {};
    for (const key of scalarKeys) {
      if (!_.isUndefined(phase[key])) {
        phaseData[key] = phase[key];
      }
    }
    phaseData.predecessor = _.isNil(phase.predecessor) ? null : phase.predecessor;

    phaseData.phaseId = phaseDefinitionId;

    if (existing) {
      await tx.challengePhase.update({
        where: { id: recordId },
        data: {
          ...phaseData,
          updatedBy: auditUserId,
        },
      });
      await tx.challengePhaseConstraint.deleteMany({ where: { challengePhaseId: recordId } });
    } else {
      await tx.challengePhase.create({
        data: {
          id: recordId,
          challengeId,
          ...phaseData,
          createdBy: auditUserId,
          updatedBy: auditUserId,
        },
      });
    }

    if (Array.isArray(phase.constraints) && phase.constraints.length > 0) {
      for (const constraint of phase.constraints) {
        if (_.isNil(constraint.name) || _.isNil(constraint.value)) {
          continue;
        }

        const constraintData: any = {
          challengePhaseId: recordId,
          name: constraint.name,
          value: constraint.value,
          createdBy: auditUserId,
          updatedBy: auditUserId,
        };

        if (!_.isNil(constraint.id)) {
          constraintData.id = constraint.id;
        }

        await tx.challengePhaseConstraint.create({ data: constraintData });
      }
    }
  }

  for (const phase of originalPhases || []) {
    if (!retainedIds.has(phase.id)) {
      await tx.challengePhase.delete({ where: { id: phase.id } });
    }
  }
}

function sanitizeData(data, challenge) {
  for (const key in data) {
    if (key === "phases") continue;

    if (challenge.hasOwnProperty(key)) {
      if (key === "skills" && deepEqual(_.map(data.skills, "id"), _.map(challenge.skills, "id"))) {
        delete data[key];
        continue;
      }

      if (
        (typeof data[key] === "object" || Array.isArray(data[key])) &&
        deepEqual(data[key], challenge[key])
      ) {
        delete data[key];
      } else if (
        typeof data[key] !== "object" &&
        !Array.isArray(data[key]) &&
        data[key] === challenge[key]
      ) {
        delete data[key];
      }
    }
  }
  return data;
}

/**
 * Delete a challenge in NEW status or terminal test data after completion/cancellation.
 * The terminal-status bypass requires both a COMPLETED/CANCELLED* status and the exact metadata
 * pair `is_test_challenge: "true"`. Draft, approved, and active challenges cannot use the bypass.
 * Missing, false, or malformed values are disabled. Existing modification authorization checks
 * are applied before deletion.
 *
 * @param {Object} currentUser the user who perform operation
 * @param {String} challengeId the challenge id
 * @returns {Object} the deleted challenge
 * @throws {NotFoundError} if the challenge does not exist or is not eligible for deletion
 * @throws {ForbiddenError} if the caller cannot modify the challenge
 */
async function deleteChallenge(currentUser, challengeId) {
  // Use findFirst for compound filters; findUnique only supports unique fields
  const challenge = await prisma.challenge.findFirst({
    where: {
      id: challengeId,
      OR: [
        { status: ChallengeStatusEnum.NEW },
        {
          status: { in: Array.from(TERMINAL_CHALLENGE_STATUSES) },
          metadata: {
            some: {
              name: constants.ChallengeMetadataNames.IS_TEST_CHALLENGE,
              value: "true",
            },
          },
        },
      ],
    },
    include: { metadata: true },
  });
  if (_.isNil(challenge) || _.isNil(challenge.id)) {
    throw new errors.NotFoundError(
      `Challenge with id: ${challengeId} doesn't exist or is not eligible for deletion; deletion requires NEW status or a COMPLETED/CANCELLED status with is_test_challenge set to the exact string true`,
    );
  }
  // ensure user can modify challenge
  await helper.ensureUserCanModifyChallenge(currentUser, challenge);
  // delete DB record
  await prisma.challenge.delete({ where: { id: challengeId } });

  await helper.postBusEvent(constants.Topics.ChallengeDeleted, {
    id: challengeId,
  });
  prismaHelper.convertModelToResponse(challenge);
  return helper.removeNullProperties(challenge);
}

deleteChallenge.schema = {
  currentUser: Joi.any(),
  challengeId: Joi.id(),
};

async function advancePhase(currentUser, challengeId, data) {
  logger.info(`Advance Phase Request - ${challengeId} - ${JSON.stringify(data)}`);
  const machineOrAdmin = currentUser && (currentUser.isMachine || hasAdminRole(currentUser));
  if (!machineOrAdmin) {
    throw new errors.ForbiddenError(
      `Admin role or an M2M token is required to advance the challenge phase.`,
    );
  }
  const challenge = await prisma.challenge.findUnique({
    where: { id: challengeId },
    include: includeReturnFields,
  });

  if (_.isNil(challenge) || _.isNil(challenge.id)) {
    throw new errors.NotFoundError(`Challenge with id: ${challengeId} doesn't exist.`);
  }
  await helper.ensureChallengeWhitelistAccess(currentUser, challenge.id);
  if (challenge.status !== ChallengeStatusEnum.ACTIVE) {
    throw new errors.BadRequestError(`Challenge with id: ${challengeId} is not in ACTIVE status.`);
  }

  const isClosingAIScreeningOrReviewPhase =
    data.operation === "close" &&
    (normalizePhaseNameForComparison(data.phase) === AI_SCREENING_PHASE_NAME || normalizePhaseNameForComparison(data.phase) === AI_REVIEW_PHASE_NAME);
  if (isClosingAIScreeningOrReviewPhase) {
    await ensureAIPhaseCanBeClosed(challenge.id, data.phase);
  }

  const phaseAdvancerResult = await phaseAdvancer.advancePhase(
    challenge.id,
    challenge.legacyId,
    challenge.phases,
    data.operation,
    data.phase,
  );

  const auditFields = {
    createdBy: _.toString(currentUser.userId),
    updatedBy: _.toString(currentUser.userId),
  };
  if (!phaseAdvancerResult.success) {
    return phaseAdvancerResult;
  }
  // update phase if result is successful
  const challengeData = {};
  // Reuse converter only to compute derived fields (currentPhaseNames, start/end dates)
  prismaHelper.convertChallengePhaseSchema(
    { phases: phaseAdvancerResult.updatedPhases },
    challengeData,
    auditFields,
  );
  // Persist phases based on the raw updated phases array from PhaseAdvancer
  const newPhases = phaseAdvancerResult.updatedPhases;
  const newChallengeData = _.pick(challengeData, [
    "currentPhaseNames",
    "registrationStartDate",
    "registrationEndDate",
    "submissionStartDate",
    "submissionEndDate",
  ]);

  // TODO: This is a temporary solution to update the challenge status to COMPLETED; We currently do not have a way to get winner list using v5 data
  // TODO: With the implementation of v5 review API we'll develop a mechanism to maintain the winner list in v5 data that challenge-api can use to create the winners list
  if (phaseAdvancerResult.hasWinningSubmission === true) {
    newChallengeData.status = ChallengeStatusEnum.COMPLETED;
  }
  await prisma.$transaction(async (tx) => {
    // upsert phases one by one (by id when present)
    for (const p of newPhases || []) {
      const phaseData = _.pick(p, [
        "name",
        "description",
        "isOpen",
        "predecessor",
        "duration",
        "scheduledStartDate",
        "scheduledEndDate",
        "actualStartDate",
        "actualEndDate",
      ]);
      // Ensure dates are either Date or null; assume incoming are ISO strings, Prisma accepts JS Date or string
      try {
        const existing = p.id ? await tx.challengePhase.findUnique({ where: { id: p.id } }) : null;
        if (existing) {
          await tx.challengePhase.update({
            where: { id: p.id },
            data: {
              ...phaseData,
              updatedBy: auditFields.updatedBy,
            },
          });
          // For simplicity, do not modify constraints on update here
        } else {
          await tx.challengePhase.create({
            data: {
              id: p.id || uuid(),
              challengeId,
              phaseId: p.phaseId,
              ...phaseData,
              createdBy: auditFields.createdBy,
              updatedBy: auditFields.updatedBy,
            },
          });
          if (Array.isArray(p.constraints) && p.constraints.length > 0) {
            for (const c of p.constraints) {
              await tx.challengePhaseConstraint.create({
                data: {
                  challengePhaseId: p.id,
                  name: c.name,
                  value: c.value,
                  createdBy: auditFields.createdBy,
                  updatedBy: auditFields.updatedBy,
                },
              });
            }
          }
        }
      } catch (e) {
        logger.error(
          `Failed to upsert phase ${p.name} (${p.phaseId}) for ${challengeId}: ${e.message}`,
        );
        throw e;
      }
    }
    await tx.challenge.update({
      where: { id: challengeId },
      data: newChallengeData,
    });
  });
  const updatedChallenge = await prisma.challenge.findUnique({ where: { id: challengeId } });
  await indexChallengeAndPostToKafka(updatedChallenge);

  return {
    success: true,
    message: phaseAdvancerResult.message,
    next: phaseAdvancerResult.next,
  };
}

async function closeMarathonMatch(currentUser, challengeId) {
  logger.info(`Close Marathon Match Request - ${challengeId}`);
  const machineOrAdmin = currentUser && (currentUser.isMachine || hasAdminRole(currentUser));
  if (!machineOrAdmin) {
    throw new errors.ForbiddenError(
      `Admin role or an M2M token is required to close the marathon match.`,
    );
  }

  const challenge = await prisma.challenge.findUnique({
    where: { id: challengeId },
    include: includeReturnFields,
  });

  if (_.isNil(challenge) || _.isNil(challenge.id)) {
    throw new errors.NotFoundError(`Challenge with id: ${challengeId} doesn't exist.`);
  }
  await helper.ensureChallengeWhitelistAccess(currentUser, challenge.id);

  if (!challenge.type || challenge.type.name !== "Marathon Match") {
    throw new errors.BadRequestError(
      `Challenge with id: ${challengeId} is not a Marathon Match challenge.`,
    );
  }

  const reviewSummations = await helper.getReviewSummations(challengeId);
  const finalSummations = (reviewSummations || []).filter(
    (summation) => summation.isFinal === true,
  );
  const latestSubmissions = await getLatestMarathonMatchSubmissions(challengeId);
  const winnerSummations = selectMarathonMatchWinnerSummations(
    challengeId,
    reviewSummations,
    finalSummations,
    latestSubmissions,
  );

  const orderedSummations = _.orderBy(
    winnerSummations,
    ["aggregateScore", "createdAt"],
    ["desc", "asc"],
  );

  const winners = orderedSummations.map((summation, index) => {
    const parsedUserId = Number(summation.submitterId);
    if (!Number.isFinite(parsedUserId) || !Number.isInteger(parsedUserId)) {
      throw new errors.BadRequestError(
        `Invalid submitterId ${summation.submitterId} for review summation winner`,
      );
    }

    return {
      userId: parsedUserId,
      handle: summation.submitterHandle,
      placement: index + 1,
      type: PrizeSetTypeEnum.PLACEMENT,
    };
  });

  if (winners.length > 0) {
    const challengeResources = await helper.getChallengeResources(challengeId);
    const submitterResources = challengeResources.filter(
      (resource) => resource.roleId === config.SUBMITTER_ROLE_ID,
    );
    const missingResources = winners.filter(
      (winner) =>
        !submitterResources.some(
          (resource) => _.toString(resource.memberId) === _.toString(winner.userId),
        ),
    );
    if (missingResources.length > 0) {
      throw new errors.BadRequestError(
        `Submitter resources are required to close Marathon Match challenge ${challengeId}. Missing submitter resources for userIds: ${missingResources
          .map((winner) => winner.userId)
          .join(", ")}`,
      );
    }
  }

  const closedAt = new Date().toISOString();
  const updatedPhases = (challenge.phases || []).map((phase) => ({
    ...phase,
    isOpen: false,
    actualEndDate: closedAt,
  }));

  const updatedChallenge = await updateChallenge(
    currentUser,
    challengeId,
    {
      winners,
      phases: updatedPhases,
      status: ChallengeStatusEnum.COMPLETED,
    },
    { emitEvent: true },
  );

  return updatedChallenge;
}

advancePhase.schema = {
  currentUser: Joi.any(),
  challengeId: Joi.id(),
  data: Joi.object()
    .keys({
      phase: Joi.string().required(),
      operation: Joi.string().lowercase().valid("open", "close").required(),
    })
    .required(),
};

closeMarathonMatch.schema = {
  currentUser: Joi.any(),
  challengeId: Joi.id(),
};

async function indexChallengeAndPostToKafka(updatedChallenge, track?: any, type?: any) {
  const prizeType = challengeHelper.validatePrizeSetsAndGetPrizeType(updatedChallenge.prizeSets);

  // No conversion needed - values are already in dollars in the database

  if (track == null || type == null) {
    const trackAndTypeData = await challengeHelper.validateAndGetChallengeTypeAndTrack({
      typeId: updatedChallenge.typeId,
      trackId: updatedChallenge.trackId,
      timelineTemplateId: updatedChallenge.timelineTemplateId,
    });

    if (trackAndTypeData != null) {
      track = trackAndTypeData.track;
      type = trackAndTypeData.type;
    }
  }

  // post bus event
  logger.debug(
    `Post Bus Event: ${constants.Topics.ChallengeUpdated} ${JSON.stringify(updatedChallenge)}`,
  );

  prismaHelper.convertModelToResponse(updatedChallenge);
  // Keep legacy string values for bus event payload to avoid breaking consumers
  enrichChallengeForResponse(updatedChallenge, track, type, { asString: true });

  await helper.postBusEvent(constants.Topics.ChallengeUpdated, updatedChallenge, {
    key:
      updatedChallenge.status === ChallengeStatusEnum.COMPLETED
        ? `${updatedChallenge.id}:${updatedChallenge.status}`
        : undefined,
  });
}

module.exports = {
  __testables: {
    shouldBlockChallengeLaunchForApproval,
    shouldSkipChallengeApprovalFlow,
    syncChallengeBillingAccountLock,
    validateChallengeActivationBillingAccount,
    getLatestSubmissionCountsByChallenge,
    applyLatestSubmissionCounts,
  },
  searchChallenges,
  createChallenge,
  getChallenge,
  updateChallenge,
  deleteChallenge,
  getChallengeStatistics,
  sendNotifications,
  advancePhase,
  closeMarathonMatch,
  getDefaultReviewers,
  setDefaultReviewers,
  indexChallengeAndPostToKafka,
  ensureAIPhaseCanBeClosed,
};

logger.buildService(module.exports);