Uecko_ERP/modules/customers/src/web/create/controllers/use-customer-create.controller.ts

import { useHookForm } from "@erp/core/hooks";
import { showErrorToast, showSuccessToast, showWarningToast } from "@repo/rdx-ui/helpers";
import { useId } from "react";
import type { FieldErrors } from "react-hook-form";

import { useTranslation } from "../../i18n";
import type { CreateCustomerParams, Customer } from "../../shared";
import { useCustomerCreateMutation } from "../../shared/hooks/use-customer-create-mutation";
import { mapCustomerToCustomerCreateForm } from "../adapters";
import {
  type CustomerCreateForm,
  CustomerCreateFormSchema,
  defaultCustomerCreateForm,
} from "../entities";
import { buildCreateCustomerParams } from "../utils";

export interface UseCustomerCreateControllerOptions {
  onCreated?(created: Customer): void;
  successToasts?: boolean; // mostrar o no toast automáticcamente

  onError?(error: Error, inputPayload: CreateCustomerParams): void;
  errorToasts?: boolean; // mostrar o no toast automáticcamente
}

export const useCustomerCreateController = (options?: UseCustomerCreateControllerOptions) => {
  const { t } = useTranslation();
  const formId = useId(); // id único por instancia

  // 1) Estado de creación (mutación)
  const {
    mutateAsync,
    isPending: isCreating,
    isError: isCreateError,
    error: createError,
  } = useCustomerCreateMutation();

  // 2) Form hook
  const form = useHookForm<CustomerCreateForm>({
    resolverSchema: CustomerCreateFormSchema,
    initialValues: defaultCustomerCreateForm,
    disabled: isCreating,
  });

  /** Handlers */

  const resetForm = () => {
    form.reset(defaultCustomerCreateForm, { keepDirty: false });
  };

  const submitHandler = form.handleSubmit(
    async (formData: CustomerCreateForm) => {
      const params: CreateCustomerParams = buildCreateCustomerParams(formData);

      try {
        // Enviamos cambios al servidor
        const created = await mutateAsync(params); // payload es CustomerCreatePayload

        // Ha ido bien -> actualizamos form con datos reales
        // keepDirty = false -> deja el formulario sin cambios sin tener que esperar al siguiente render.
        form.reset(mapCustomerToCustomerCreateForm(created), {
          keepDirty: false,
        });

        if (options?.successToasts !== false) {
          showSuccessToast(
            t("create.feedback.success.title"),
            t("create.feedback.success.message")
          );
        }
        options?.onCreated?.(created);
      } catch (error: unknown) {
        const normalizedError =
          error instanceof Error ? error : new Error(t("create.errors.unknown"));

        if (options?.errorToasts !== false) {
          showErrorToast(t("create.errors.title"), normalizedError.message);
        }

        options?.onError?.(normalizedError, params);
      }
    },
    (errors: FieldErrors<CustomerCreateForm>) => {
      const firstKey = Object.keys(errors)[0] as keyof CustomerCreateForm | undefined;

      if (firstKey) {
        document.querySelector<HTMLElement>(`[name="${String(firstKey)}"]`)?.focus();
      }

      showWarningToast(
        t("common.feedback.validation.title"),
        t("common.feedback.validation.message")
      );
    }
  );

  // Evento onSubmit ya preparado para el <form>
  const onSubmit = (event: React.FormEvent<HTMLFormElement>) => {
    event.stopPropagation(); // <-- evita que el submit se propage por los padre en el árbol DOM
    submitHandler(event);
  };

  return {
    // form
    form,
    formId,

    // handlers del form
    onSubmit,
    resetForm,

    // mutation
    isCreating,
    isCreateError,
    createError,

    // No devolver FormProvider, así el controller es más
    // flexible y reusable (p.ej. para un modal)
    // FormProvider,
  };
};