import {
  getStepsByInterventionId,
  updateStepValueLocally,
} from "./localDatabase";
import type {
  MobileStep,
  StepValue,
} from "../types/intervention";

export async function loadStepsLocally(interventionId: number): Promise<MobileStep[]> {
  return getStepsByInterventionId(interventionId);
}

function validateMeasurement(step: MobileStep, value: StepValue): string | null {
  const num = Number(value);
  if (Number.isNaN(num)) {
    return "Valeur numerique requise";
  }
  if (step.constraints?.min !== undefined && num < step.constraints.min) {
    return `Minimum: ${step.constraints.min}`;
  }
  if (step.constraints?.max !== undefined && num > step.constraints.max) {
    return `Maximum: ${step.constraints.max}`;
  }
  return null;
}

function validateText(step: MobileStep, value: StepValue): string | null {
  const str = typeof value === "string" ? value : "";
  if (step.constraints?.max_length && str.length > step.constraints.max_length) {
    return `Maximum ${step.constraints.max_length} caracteres`;
  }
  return null;
}

function validatePhoto(step: MobileStep, value: StepValue): string | null {
  if (step.required && (!Array.isArray(value) || value.length === 0)) {
    return "Au moins une photo requise";
  }
  return null;
}

function validateSignature(step: MobileStep, value: StepValue): string | null {
  const sig = value as { signed?: boolean; uri?: string } | null;
  if (step.required && (!sig?.signed || !sig?.uri)) {
    return "Signature requise";
  }
  return null;
}

export function validateStepValue(step: MobileStep, value: StepValue): string | null {
  switch (step.type) {
    case "measurement":
      return validateMeasurement(step, value);
    case "text":
      return validateText(step, value);
    case "photo":
      return validatePhoto(step, value);
    case "signature":
      return validateSignature(step, value);
    default:
      return null;
  }
}

export function allRequiredStepsDone(steps: MobileStep[]): boolean {
  return steps
    .filter((s) => s.required)
    .every((s) => s.status === "done");
}

/**
 * Marque une etape comme "done" en base LOCALE uniquement (SQLite), bump la
 * version, et retourne le step a jour pour le state UI.
 *
 * NE met PLUS rien en sync_queue : la persistance serveur de la VALEUR est
 * deja assuree par l'appelant (WorkflowInterventionScreen.persistSingleStep)
 * via /mobile/intervention_workflow.php action=save_step — online (appel
 * direct) ou offline (enqueue du meme endpoint reel). Les BINAIRES (photos,
 * signatures) sont uploades par leurs endpoints multipart dedies au moment de
 * la capture (uploadWorkflowStepPhoto) / de la finalisation (complete_workflow),
 * pas par cette file.
 *
 * Historique : cette fonction enfilait un POST vers /missions/{id}/steps/{id}/
 * complete (style REST herite du port coolcare). Cet endpoint n'existe pas
 * cote backend mobile (100% /mobile/*.php) -> chaque save creait un item 404
 * en double, qui restait 'pending' et bloquait toute la file de sync. Retire.
 * Limite connue assumee : l'upload des binaires hors-ligne n'est pas (encore)
 * rejouable via la file -> a couvrir cote backend si besoin (file multipart
 * par step_key).
 */
export async function completeStepLocally(
  step: MobileStep,
  value: StepValue
): Promise<MobileStep> {
  const newVersion = (step.version ?? 1) + 1;
  const now = new Date().toISOString();

  await updateStepValueLocally(step.intervention_id, step.id, {
    status: "done",
    value,
    version: newVersion,
  });

  return { ...step, status: "done", value, version: newVersion, updated_at: now };
}