"use client";

/**
 * use-forms — wire DTOs + TanStack Query hooks for public forms.
 *
 * A Form belongs to a database (submissions create records there), has a
 * unique `slug` (public URL `/f/:slug`), a status and an ordered list of
 * questions. There are NO per-question routes: questions are managed inline —
 * create/update send the WHOLE questions array (the server deletes + rebuilds
 * in the given order, regenerating fractional positions).
 *
 * Endpoints (verified against apps/api/src/modules/forms/*, no core formApi):
 *   GET    /databases/:databaseId/forms        (list for a database → { data: […] })
 *   POST   /databases/:databaseId/forms        (create — questions optional)
 *   GET    /forms/:id                          (auth, full form + questions + properties)
 *   PATCH  /forms/:id                          (update; questions? rebuilds)
 *   DELETE /forms/:id
 *   GET    /public/forms/:slug                 (public, PUBLISHED only → { form, questions })
 *   POST   /public/forms/:slug/submit          (public submit — { answers })
 *
 * The public payload's `status` is LOWERCASE ("published"/"closed" — the
 * TASK-0107 whitelist deliberately does not echo the internal enum); the
 * in-app payload is UPPERCASE (DRAFT/PUBLISHED/CLOSED). Both are normalized
 * to the UPPERCASE FormStatus here so consumers (the renderer) handle one
 * shape. The public payload carries NO form id (leakage guarantee) — a
 * stable slug-keyed id is synthesized for React keys.
 *
 * Wire enums are UPPERCASE (Prisma schema + API zod + architecture doc agree):
 *   question type: SHORT_TEXT | LONG_TEXT | NUMBER | EMAIL | DATE | CHECKBOX
 *                  | SINGLE_SELECT | MULTI_SELECT | RATING | FILE
 *   status:        DRAFT | PUBLISHED | CLOSED
 *
 * select/rating options + bounds live in the question's `validation` object
 * (options → `validation.options`; min/max → `validation.min/max`).
 */
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { apiFetch } from "@/lib/api";

// ---------------------------------------------------------------------------
// Wire enums + types
// ---------------------------------------------------------------------------

export const FORM_QUESTION_TYPES = [
  "SHORT_TEXT",
  "LONG_TEXT",
  "NUMBER",
  "EMAIL",
  "DATE",
  "CHECKBOX",
  "SINGLE_SELECT",
  "MULTI_SELECT",
  "RATING",
  "FILE"
] as const;
export type FormQuestionType = (typeof FORM_QUESTION_TYPES)[number];

export const FORM_STATUSES = ["DRAFT", "PUBLISHED", "CLOSED"] as const;
export type FormStatus = (typeof FORM_STATUSES)[number];

export interface FormOption {
  /** Optional stable id; the display value (what's submitted) is `name`. */
  id?: string;
  name: string;
  color?: string;
}

/** `validation` carries per-type extras: options (selects), min/max (number/rating/text). */
export interface FormValidation extends Record<string, unknown> {
  /**
   * Select options. THE WIRE SHAPE IS A STRING ARRAY — the server validates
   * `SINGLE_SELECT`/`MULTI_SELECT` against `options: string[]`
   * (submit-schema.ts filters non-strings) and the shared contract tests
   * `{ options: ["a","b"] }`. The web's display model is `FormOption` objects
   * (`{ name }`), so `questionOptions` normalizes strings → `{ name: s }` on
   * read and the builder emits names (strings) on write.
   */
  options?: (FormOption | string)[];
  min?: number;
  max?: number;
  maxLength?: number;
}

/** What the client sends for a question (create/update). No id/position —
 *  the server assigns both (position from array order). */
export interface FormQuestionInput {
  type: FormQuestionType;
  label: string;
  description?: string;
  required?: boolean;
  propertyId?: string | null;
  validation?: FormValidation | null;
  placeholder?: string;
}

/** A persisted question (getForm / public) = input + server-assigned id/position. */
export interface FormQuestion extends FormQuestionInput {
  id: string;
  position: string;
  required: boolean;
}

export interface FormConfig extends Record<string, unknown> {
  /** Emoji (≤32) or a Phase-9 image file id (the public payload surfaces it as `iconUrl`). */
  icon?: string | null;
  /** Markdown, ≤2000 chars — the public payload returns sanitized HTML here. */
  intro?: string;
  /** One of FORM_ACCENTS (the builder + public CSS variable). */
  accent?: string;
  successMessage?: string;
  closedMessage?: string;
  /** "Powered by AI Software Factory" footer (default true). */
  poweredBy?: boolean;
  recaptcha?: { enabled?: boolean; siteKey?: string };
}

/** Normalized form used by both the in-app (by id) and public (by slug)
 *  surfaces — the two endpoints return different shapes, so both are folded
 *  into this one. */
export interface FormDto {
  id: string;
  name: string;
  slug: string;
  description?: string | null;
  status: FormStatus;
  config: FormConfig;
  /** Auth shape only (publicGet returns databaseName instead). */
  databaseId?: string;
  databaseName?: string;
  questions: FormQuestion[];
  createdAt?: string;
  updatedAt?: string;
}

// ---------------------------------------------------------------------------
// helpers
// ---------------------------------------------------------------------------

function unwrap<T>(body: unknown): T {
  const b = body as { data?: T } | null;
  if (b && typeof b === "object" && "data" in (b as Record<string, unknown>)) {
    return (b as { data: T }).data;
  }
  return body as T;
}

/**
 * Normalize the wire status to the UPPERCASE FormStatus enum. The in-app
 * payload is already UPPERCASE (DRAFT/PUBLISHED/CLOSED); the public payload
 * is lowercase ("published"/"closed" — TASK-0107 whitelist). Unknown/absent
 * → "DRAFT" (the renderer treats non-PUBLISHED as a draft affordance).
 */
function normalizeStatus(status: string | undefined | null): FormStatus {
  const s = (status ?? "").toUpperCase();
  return (FORM_STATUSES as readonly string[]).includes(s) ? (s as FormStatus) : "DRAFT";
}

/**
 * Options for a select question (stored under validation.options).
 *
 * Normalizes the wire shape — a STRING array (the server's + shared's
 * contract) — into the web's `FormOption` objects, so `form-field.tsx`'s
 * `<option value={o.name}>` renders the real name instead of `undefined`.
 * Passes object entries through (forward-compat).
 */
export function questionOptions(question: Pick<FormQuestion, "validation">): FormOption[] {
  const o = question.validation?.options;
  if (!Array.isArray(o)) return [];
  return o.map((entry) => (typeof entry === "string" ? { name: entry } : entry));
}

/** Build/replace a question's select options (kept in validation.options). */
export function withOptions(question: FormQuestionInput, options: FormOption[]): FormQuestionInput {
  const validation: FormValidation = { ...(question.validation ?? {}) };
  if (options.length) validation.options = options;
  else delete validation.options;
  return { ...question, validation: validation && Object.keys(validation).length ? validation : null };
}

const formKey = (id: string) => ["form", id] as const;

// ---------------------------------------------------------------------------
// Queries
// ---------------------------------------------------------------------------

export function useForm(id: string | undefined) {
  return useQuery({
    queryKey: formKey(id ?? "none"),
    enabled: !!id,
    queryFn: async (): Promise<FormDto> => {
      const f = await apiFetch<{
        id: string;
        databaseId: string;
        name: string;
        slug: string;
        description?: string | null;
        status: FormStatus;
        config: FormConfig;
        database: { id: string; title: string };
        questions: FormQuestion[];
        createdAt: string;
        updatedAt: string;
      }>(`/forms/${id}`);
      return {
        id: f.id,
        name: f.name,
        slug: f.slug,
        description: f.description,
        status: normalizeStatus(f.status),
        config: f.config ?? {},
        databaseId: f.databaseId,
        databaseName: f.database?.title,
        questions: f.questions ?? [],
        createdAt: f.createdAt,
        updatedAt: f.updatedAt
      };
    }
  });
}

/** Public lookup by slug (the /f/[slug] page — no auth). Only PUBLISHED forms
 *  resolve; anything else 404s. */
export function useFormBySlug(slug: string | undefined) {
  return useQuery({
    queryKey: ["form-by-slug", slug ?? "none"],
    enabled: !!slug,
    retry: false,
    queryFn: async (): Promise<FormDto> => {
      // The public surface: `status` is lowercase ("published"/"closed") and
      // there is NO form id (leakage guarantee) — normalize + synthesize a
      // slug-keyed id for React keys. `config.intro` is already sanitized HTML.
      const res = await apiFetch<{
        form: { name: string; slug: string; description?: string | null; status: string; config: FormConfig };
        questions: FormQuestion[];
      }>(`/public/forms/${encodeURIComponent(slug as string)}`, { noAuth: true });
      return {
        id: `public:${res.form.slug}`,
        name: res.form.name,
        slug: res.form.slug,
        description: res.form.description,
        status: normalizeStatus(res.form.status),
        config: res.form.config ?? {},
        questions: res.questions ?? []
      };
    }
  });
}

export function useListForms(databaseId: string | undefined) {
  return useQuery({
    queryKey: ["forms", databaseId ?? "none"],
    enabled: !!databaseId,
    queryFn: async (): Promise<{ id: string; databaseId: string; name: string; slug: string; status: FormStatus; questionCount: number; submissionCount: number }[]> => {
      const body = await apiFetch<{ data: { id: string; databaseId: string; name: string; slug: string; status: string; questionCount: number; submissionCount: number }[] }>(
        `/databases/${databaseId}/forms`
      );
      return (body.data ?? []).map((f) => ({ ...f, status: normalizeStatus(f.status) }));
    }
  });
}

// ---------------------------------------------------------------------------
// Mutations — form (questions are part of the payload)
// ---------------------------------------------------------------------------

export function useCreateForm(databaseId: string | undefined) {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: async (payload: {
      name: string;
      slug?: string;
      description?: string;
      config?: FormConfig;
      questions?: FormQuestionInput[];
    }): Promise<FormDto> => {
      const f = await apiFetch<{
        id: string;
        databaseId: string;
        name: string;
        slug: string;
        description?: string | null;
        status: FormStatus;
        config: FormConfig;
        database?: { id: string; title: string };
        questions: FormQuestion[];
      }>(`/databases/${databaseId}/forms`, { method: "POST", body: JSON.stringify(payload) });
      return {
        id: f.id,
        name: f.name,
        slug: f.slug,
        description: f.description,
        status: normalizeStatus(f.status),
        config: f.config ?? {},
        databaseId: f.databaseId,
        databaseName: f.database?.title,
        questions: f.questions ?? []
      };
    },
    onSuccess: (created) => {
      qc.setQueryData(formKey(created.id), created);
      qc.invalidateQueries({ queryKey: ["forms"] });
    }
  });
}

export function useUpdateForm(databaseId: string | undefined) {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: async (payload: {
      formId: string;
      name?: string;
      description?: string | null;
      status?: FormStatus;
      slug?: string;
      config?: FormConfig;
      questions?: FormQuestionInput[];
    }): Promise<FormDto> => {
      const { formId, ...body } = payload;
      const f = await apiFetch<{
        id: string;
        databaseId: string;
        name: string;
        slug: string;
        description?: string | null;
        status: FormStatus;
        config: FormConfig;
        database?: { id: string; title: string };
        questions: FormQuestion[];
      }>(`/forms/${formId}`, { method: "PATCH", body: JSON.stringify(body) });
      return {
        id: f.id,
        name: f.name,
        slug: f.slug,
        description: f.description,
        status: normalizeStatus(f.status),
        config: f.config ?? {},
        databaseId: f.databaseId,
        databaseName: f.database?.title,
        questions: f.questions ?? []
      };
    },
    onSuccess: (updated) => {
      qc.setQueryData(formKey(updated.id), updated);
      qc.invalidateQueries({ queryKey: ["forms"] });
      if (databaseId) qc.invalidateQueries({ queryKey: ["forms", databaseId] });
    }
  });
}

export function useDeleteForm(databaseId: string | undefined) {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: async (formId: string): Promise<void> => {
      await apiFetch(`/forms/${formId}`, { method: "DELETE" });
    },
    onSuccess: (_d, formId) => {
      qc.removeQueries({ queryKey: formKey(formId) });
      qc.invalidateQueries({ queryKey: ["forms"] });
      if (databaseId) qc.invalidateQueries({ queryKey: ["forms", databaseId] });
    }
  });
}

// ---------------------------------------------------------------------------
// Public submit — answers are RAW values keyed by question id; the server
// coerces (coerceAnswer) and maps onto the linked database record.
// ---------------------------------------------------------------------------

export function useSubmitForm(slug: string) {
  return useMutation({
    mutationFn: async (answers: Record<string, unknown>): Promise<{ success: boolean; submissionId?: string; message?: string | null }> =>
      unwrap(
        await apiFetch<{ success: boolean; submissionId?: string; message?: string | null }>(
          `/public/forms/${encodeURIComponent(slug)}/submit`,
          {
            method: "POST",
            body: JSON.stringify({ answers }),
            noAuth: true
          }
        )
      ),
  });
}

// ---------------------------------------------------------------------------
// Raw-answer empty check (client validation mirror of the server's required).
// ---------------------------------------------------------------------------

export function isAnswerEmpty(value: unknown): boolean {
  if (value == null) return true;
  if (typeof value === "string") return value.trim() === "";
  if (Array.isArray(value)) return value.length === 0;
  return false;
}

// ---------------------------------------------------------------------------
// TASK-0109 — submissions (the responses view).
//
//   GET    /forms/:formId/submissions[?q&from&to&anonymousOnly&limit&cursor]
//          → { items: SubmissionDto[], nextCursor: string | null }
//   DELETE /forms/:formId/submissions/:id?confirm=true → { deleted, recordDeleted, filesPurged }
//
// The row model mirrors the API's SubmissionView: answers keyed by question
// id + a server-joined questionLabels map (qid → { label, type }) + the
// submitter (or null = anonymous, "Former member" name when the user row is
// gone) + an IP that is masked for Member and full for Owner/Admin (ipMasked
// tells the UI which).
// ---------------------------------------------------------------------------

export interface SubmissionDto {
  id: string;
  formId: string;
  recordId: string | null;
  /** Raw answers (questionId → value) — the audit trail, unmasked. */
  answers: Record<string, unknown>;
  /** Server-joined question labels (questionId → { label, type }). */
  questionLabels: Record<string, { label: string; type: string }>;
  submittedBy: { id: string; name: string; avatarUrl: string | null; email: string | null } | null;
  /** Masked (`1.2.***.***`) unless the caller is a workspace Owner/Admin. */
  ip: string;
  ipMasked: boolean;
  createdAt: string;
}

export interface SubmissionsFilter {
  /** Free text — matches answer text + submitter name/email + IP. */
  q?: string;
  /** ISO datetime lower bound on createdAt (inclusive). */
  from?: string;
  /** ISO datetime upper bound on createdAt (inclusive). */
  to?: string;
  /** Only anonymous submissions. */
  anonymousOnly?: boolean;
  limit?: number;
  cursor?: string;
}

function submissionsPath(formId: string, f?: SubmissionsFilter): string {
  const params = new URLSearchParams();
  if (f?.q) params.set("q", f.q);
  if (f?.from) params.set("from", f.from);
  if (f?.to) params.set("to", f.to);
  if (f?.anonymousOnly) params.set("anonymousOnly", "true");
  if (f?.limit) params.set("limit", String(f.limit));
  if (f?.cursor) params.set("cursor", f.cursor);
  const qs = params.toString();
  return `/forms/${formId}/submissions${qs ? `?${qs}` : ""}`;
}

export function useSubmissions(formId: string | undefined, filter?: SubmissionsFilter) {
  return useQuery({
    queryKey: ["submissions", formId, filter?.q, filter?.from, filter?.to, filter?.anonymousOnly, filter?.cursor],
    enabled: !!formId,
    queryFn: async (): Promise<{ items: SubmissionDto[]; nextCursor: string | null }> =>
      apiFetch<{ items: SubmissionDto[]; nextCursor: string | null }>(submissionsPath(formId as string, filter)),
  });
}

export function useDeleteSubmission(formId: string | undefined) {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: async (submissionId: string): Promise<{ deleted: boolean; recordDeleted: boolean; filesPurged: number }> =>
      apiFetch(`/forms/${formId}/submissions/${submissionId}?confirm=true`, { method: "DELETE" }),
    onSuccess: () => {
      qc.invalidateQueries({ queryKey: ["submissions", formId] });
      // The cascade can delete a record + its files — refresh the database too.
      if (formId) qc.invalidateQueries({ queryKey: ["database"] });
    }
  });
}