// lib/procurement/items/repository.ts
import db from "@/db/db";
import { ProcurementItem, procurementItems } from "@/db/schema/items";
import {
  eq,
  inArray,
  asc,
  desc,
  count,
} from "drizzle-orm";
import { PgTransaction } from "drizzle-orm/pg-core";

export type NewProcurementItem = typeof procurementItems.$inferInsert

/**
 * 단건/복수 조회 시 공통으로 사용 가능한 SELECT 함수
 * 트랜잭션(tx)을 받아서 사용하도록 구현
 */
export async function selectProcurementItems(
  tx: PgTransaction<any, any, any>,
  params: {
    where?: any;
    orderBy?: (ReturnType<typeof asc> | ReturnType<typeof desc>)[];
    offset?: number;
    limit?: number;
  }
) {
  const { where, orderBy, offset = 0, limit = 10 } = params;

  return tx
    .select()
    .from(procurementItems)
    .where(where)
    .orderBy(...(orderBy ?? []))
    .offset(offset)
    .limit(limit);
}

/** 총 개수 count */
export async function countProcurementItems(
  tx: PgTransaction<any, any, any>,
  where?: any
) {
  const res = await tx.select({ count: count() }).from(procurementItems).where(where);
  return res[0]?.count ?? 0;
}

/** 단건 Insert */
export async function insertProcurementItem(
  tx: PgTransaction<any, any, any>,
  data: NewProcurementItem
) {
  return tx
    .insert(procurementItems)
    .values(data)
    .returning({ id: procurementItems.id, createdAt: procurementItems.createdAt });
}

/** 복수 Insert */
export async function insertProcurementItems(
  tx: PgTransaction<any, any, any>,
  data: ProcurementItem[]
) {
  return tx.insert(procurementItems).values(data).onConflictDoNothing();
}

/** 단건 삭제 */
export async function deleteProcurementItemById(
  tx: PgTransaction<any, any, any>,
  itemId: number
) {
  return tx.delete(procurementItems).where(eq(procurementItems.id, itemId));
}

/** 복수 삭제 */
export async function deleteProcurementItemsByIds(
  tx: PgTransaction<any, any, any>,
  ids: number[]
) {
  return tx.delete(procurementItems).where(inArray(procurementItems.id, ids));
}

/** 전체 삭제 */
export async function deleteAllProcurementItems(
  tx: PgTransaction<any, any, any>,
) {
  return tx.delete(procurementItems);
}

/** 단건 업데이트 */
export async function updateProcurementItem(
  tx: PgTransaction<any, any, any>,
  itemId: number,
  data: Partial<ProcurementItem>
) {
  return tx
    .update(procurementItems)
    .set(data)
    .where(eq(procurementItems.id, itemId))
    .returning({ id: procurementItems.id, createdAt: procurementItems.createdAt });
}

/** 복수 업데이트 */
export async function updateProcurementItems(
  tx: PgTransaction<any, any, any>,
  ids: number[],
  data: Partial<ProcurementItem>
) {
  return tx
    .update(procurementItems)
    .set(data)
    .where(inArray(procurementItems.id, ids))
    .returning({ id: procurementItems.id, createdAt: procurementItems.createdAt });
}

export async function findAllProcurementItems(): Promise<ProcurementItem[]> {
  return db.select().from(procurementItems).orderBy(asc(procurementItems.itemCode));
}