function trimToUndefined(value) {
  return typeof value === "string" && value.trim() ? value.trim() : undefined;
}

function normalizeCompletionStatus(status) {
  if (status === "failed") return "failed";
  if (status === "needs_user_action") return "needs_user_action";
  return "completed";
}

function normalizeStringArray(value) {
  return Array.isArray(value)
    ? value.map((item) => String(item).trim()).filter(Boolean)
    : undefined;
}

export function buildRemoteExecutionCompletionPayload(task, payload) {
  return {
    taskId: task.taskId,
    status: normalizeCompletionStatus(payload.status),
    requestId: trimToUndefined(payload.requestId),
    replyBody: trimToUndefined(payload.replyBody),
    errorMessage: trimToUndefined(payload.errorMessage),
    kind: trimToUndefined(payload.kind),
    dialogId: trimToUndefined(payload.dialogId),
    appName: trimToUndefined(payload.appName),
    platform: trimToUndefined(payload.platform),
    risk: trimToUndefined(payload.risk),
    summary: trimToUndefined(payload.summary),
    recommendedAction: trimToUndefined(payload.recommendedAction),
    availableActions: normalizeStringArray(payload.availableActions),
    dispatchExecutionId: trimToUndefined(payload.dispatchExecutionId),
    targetProjectId: trimToUndefined(payload.targetProjectId),
    targetThreadId: trimToUndefined(payload.targetThreadId),
    targetUrl: trimToUndefined(payload.targetUrl),
    targetApp: trimToUndefined(payload.targetApp),
    rawThreadReply: trimToUndefined(payload.rawThreadReply),
    executionProgress:
      payload.executionProgress && typeof payload.executionProgress === "object"
        ? payload.executionProgress
        : undefined,
  };
}

export function buildComputerUseCompletionPayload(task, result) {
  if (result?.status === "needs_user_action") {
    return buildRemoteExecutionCompletionPayload(task, {
      status: "needs_user_action",
      requestId: result.requestId,
      kind: result.kind,
      dialogId: result.dialogId,
      appName: result.appName,
      platform: result.platform,
      risk: result.risk,
      summary: result.summary,
      recommendedAction: result.recommendedAction,
      availableActions: result.availableActions,
      dispatchExecutionId: task.dispatchExecutionId,
      targetProjectId: task.targetProjectId,
      targetThreadId: task.targetThreadId,
      targetApp: result.targetApp ?? result.appName,
    });
  }

  return buildRemoteExecutionCompletionPayload(task, {
    status: result?.status === "failed" ? "failed" : "completed",
    requestId: result?.requestId,
    replyBody: result?.replyBody,
    errorMessage: result?.errorMessage,
    dispatchExecutionId: task.dispatchExecutionId,
    targetProjectId: task.targetProjectId,
    targetThreadId: task.targetThreadId,
    targetApp: result?.targetApp,
  });
}

export function buildMasterAgentTaskCompletionRequestBody(config, payload) {
  return {
    deviceId: config.deviceId,
    status: payload.status,
    replyBody: payload.replyBody,
    errorMessage: payload.errorMessage,
    requestId: payload.requestId,
    kind: payload.kind,
    dialogId: payload.dialogId,
    appName: payload.appName,
    platform: payload.platform,
    risk: payload.risk,
    summary: payload.summary,
    recommendedAction: payload.recommendedAction,
    availableActions: payload.availableActions,
    dispatchExecutionId: payload.dispatchExecutionId,
    targetProjectId: payload.targetProjectId,
    targetThreadId: payload.targetThreadId,
    targetUrl: payload.targetUrl,
    targetApp: payload.targetApp,
    rawThreadReply: payload.rawThreadReply,
    executionProgress: payload.executionProgress,
  };
}