"use server";

import { revalidatePath } from "next/cache";
import { z } from "zod";
import { getCurrentUser } from "@/data/auth";
import {
  deletePelanggan,
  insertPelanggan,
  updatePelanggan,
  type PelangganInput,
} from "@/data/pelanggan";

type PelangganField = keyof typeof pelangganSchema.shape;
export type SimpanPelangganState = {
  ok: boolean;
  error?: string;
  fieldErrors?: Partial<Record<PelangganField, string[]>>;
  values?: Partial<Record<PelangganField, string>>;
  kdCustomer?: string;
};

export type HapusPelangganState = { ok: boolean; error?: string };

const pelangganSchema = z.object({
  nama: z.string().trim().min(1, "Nama wajib diisi").max(100),
  alias: z.string().trim().max(11),
  ktp: z.string().trim().max(16),
  alamat: z.string().trim().min(1, "Alamat wajib diisi").max(100),
  wilayah: z.string().trim().max(200),
  telp: z.string().trim().max(15),
  ponsel: z.string().trim().max(15),
  email: z.string().trim().max(30),
  jenisCustomer: z.string().trim().max(1),
  upline: z.string().trim().max(11),
  btsBon: z.coerce.number().int().min(0).max(2_000_000_000),
});

function emptyStringToNull(value: string): string | null {
  return value === "" ? null : value;
}

export async function simpanPelanggan(
  _prevState: SimpanPelangganState,
  formData: FormData,
): Promise<SimpanPelangganState> {
  const user = await getCurrentUser();

  const fields = Object.keys(pelangganSchema.shape) as PelangganField[];
  const values = Object.fromEntries(
    fields.map((field) => [field, String(formData.get(field) ?? "")]),
  ) as Record<PelangganField, string>;

  const parsed = pelangganSchema.safeParse(values);
  if (!parsed.success) {
    return {
      ok: false,
      fieldErrors: z.flattenError(parsed.error).fieldErrors,
      values,
    };
  }

  const input: PelangganInput = {
    ...parsed.data,
    wilayah: emptyStringToNull(parsed.data.wilayah),
    telp: emptyStringToNull(parsed.data.telp),
    ponsel: emptyStringToNull(parsed.data.ponsel),
    email: emptyStringToNull(parsed.data.email),
    jenisCustomer: emptyStringToNull(parsed.data.jenisCustomer),
    upline: emptyStringToNull(parsed.data.upline),
  };
  const kdCustomer = String(formData.get("kdCustomer") ?? "").trim();

  try {
    if (kdCustomer === "") {
      const kdBaru = await insertPelanggan(input);
      revalidatePath("/master/pelanggan");
      return { ok: true, kdCustomer: kdBaru };
    }

    const updated = await updatePelanggan(kdCustomer, input);
    if (!updated) {
      return { ok: false, error: "Pelanggan tidak ditemukan", values };
    }
    revalidatePath("/master/pelanggan");
    return { ok: true, kdCustomer };
  } catch (error) {
    console.error(
      "[simpanPelanggan] gagal",
      { userId: user.id, kdCustomer: kdCustomer || "(baru)", nama: input.nama },
      error,
    );
    return {
      ok: false,
      error: "Gagal menyimpan pelanggan, coba simpan ulang",
      values,
    };
  }
}

export async function hapusPelanggan(
  _prevState: HapusPelangganState,
  formData: FormData,
): Promise<HapusPelangganState> {
  const user = await getCurrentUser();

  const kdCustomer = String(formData.get("kdCustomer") ?? "").trim();
  if (kdCustomer === "") {
    return { ok: false, error: "Kode pelanggan tidak ada" };
  }

  try {
    const deleted = await deletePelanggan(kdCustomer);
    if (!deleted) {
      return { ok: false, error: "Pelanggan tidak ditemukan" };
    }
    revalidatePath("/master/pelanggan");
    return { ok: true };
  } catch (error) {
    console.error(
      "[hapusPelanggan] gagal",
      { userId: user.id, kdCustomer },
      error,
    );
    return {
      ok: false,
      error: "Gagal menghapus pelanggan, coba hapus ulang",
    };
  }
}