import "server-only";

import { asc, count, eq, like } from "drizzle-orm";
import { amigoDb } from "@/db/amigo";
import { no_barang, satuan_barang } from "@/db/amigo/schema";
import { PER_PAGE } from "@/lib/pagination";
import { escapeLike } from "@/lib/utils";

export type SatuanBarang = {
  idSatuanBarang: number;
  namaSatuanBarang: string | null;
};

export type SatuanBarangPage = {
  rows: SatuanBarang[];
  hasNext: boolean;
};

// Kolom DB nullable, tapi isian form wajib string.
export type SatuanBarangInput = {
  namaSatuanBarang: NonNullable<SatuanBarang["namaSatuanBarang"]>;
};

export async function insertSatuanBarang(
  input: SatuanBarangInput,
): Promise<number> {
  const [res] = await amigoDb.insert(satuan_barang).values({
    namaSatuanBarang: input.namaSatuanBarang,
  });

  return res.insertId;
}

export async function updateSatuanBarang(
  idSatuanBarang: number,
  input: SatuanBarangInput,
): Promise<boolean> {
  const [res] = await amigoDb
    .update(satuan_barang)
    .set({ namaSatuanBarang: input.namaSatuanBarang })
    .where(eq(satuan_barang.idSatuanBarang, idSatuanBarang));

  return res.affectedRows > 0;
}

// `no_barang.satuan` menyimpan idSatuanBarang sebagai varchar.
export async function countPemakaianSatuanBarang(
  idSatuanBarang: number,
): Promise<number> {
  const [row] = await amigoDb
    .select({ total: count() })
    .from(no_barang)
    .where(eq(no_barang.satuan, String(idSatuanBarang)));

  return row?.total ?? 0;
}

export async function deleteSatuanBarang(
  idSatuanBarang: number,
): Promise<boolean> {
  const [res] = await amigoDb
    .delete(satuan_barang)
    .where(eq(satuan_barang.idSatuanBarang, idSatuanBarang));

  return res.affectedRows > 0;
}

export async function listSatuanBarang(
  search?: string,
  page = 1,
): Promise<SatuanBarangPage> {
  const q = search?.trim();
  const pattern = q ? `%${escapeLike(q)}%` : "";

  const rows = await amigoDb
    .select({
      idSatuanBarang: satuan_barang.idSatuanBarang,
      namaSatuanBarang: satuan_barang.namaSatuanBarang,
    })
    .from(satuan_barang)
    .where(q ? like(satuan_barang.namaSatuanBarang, pattern) : undefined)
    .orderBy(
      asc(satuan_barang.namaSatuanBarang),
      asc(satuan_barang.idSatuanBarang),
    )
    .limit(PER_PAGE + 1)
    .offset((page - 1) * PER_PAGE);

  return {
    rows: rows.slice(0, PER_PAGE),
    hasNext: rows.length > PER_PAGE,
  };
}