import { vendorTypes } from "@/db/schema";
import { SQL, eq, inArray, sql,asc, desc } from "drizzle-orm";
import { PgTransaction } from "drizzle-orm/pg-core";

/**
 * 협력업체 타입 조회 (복잡한 where + order + limit + offset 지원)
 */
export async function selectVendorTypes(
  tx: PgTransaction<any, any, any>,
  params: {
    where?: any; // drizzle-orm의 조건식 (and, eq...) 등
    orderBy?: (ReturnType<typeof asc> | ReturnType<typeof desc>)[];
    offset?: number;
    limit?: number;
  }
) {
  const { where, orderBy, offset = 0, limit = 10 } = params;

  return tx
    .select()
    .from(vendorTypes)
    .where(where)
    .orderBy(...(orderBy ?? []))
    .offset(offset)
    .limit(limit);
}
/**
 * 전체 협력업체 타입 조회
 */
export async function findAllVendorTypes(tx: any) {
  return tx.select()
    .from(vendorTypes)
    .orderBy(vendorTypes.nameKo);
}

/**
 * 협력업체 타입 개수 카운트
 */
export async function countVendorTypes(tx: any, where?: SQL<unknown> | undefined) {
  const result = await tx
    .select({ count: sql`count(*)` })
    .from(vendorTypes)
    .where(where || undefined);

  return Number(result[0]?.count || 0);
}

/**
 * 협력업체 타입 추가
 */
export async function insertVendorType(
  tx: any,
  data: {
    code: string;
    nameKo: string;
    nameEn: string;
  }
) {
  const insertedRows = await tx
    .insert(vendorTypes)
    .values(data);
  
  // 삽입된 데이터 가져오기
  return tx.select()
    .from(vendorTypes)
    .where(eq(vendorTypes.code, data.code))
    .limit(1);
}

/**
 * 단일 협력업체 타입 업데이트
 */
export async function updateVendorType(
  tx: any,
  id: number,
  data: Partial<{
    code: string;
    nameKo: string;
    nameEn: string;
  }>
) {
  await tx
    .update(vendorTypes)
    .set({
      ...data,
      updatedAt: new Date()
    })
    .where(eq(vendorTypes.id, id));
  
  // 업데이트된 데이터 가져오기
  return tx.select()
    .from(vendorTypes)
    .where(eq(vendorTypes.id, id))
    .limit(1);
}

/**
 * ID로 단일 협력업체 타입 삭제
 */
export async function deleteVendorTypeById(tx: any, id: number) {
  // 삭제 전 데이터 가져오기 (필요한 경우)
  const deletedRecord = await tx.select()
    .from(vendorTypes)
    .where(eq(vendorTypes.id, id))
    .limit(1);
  
  // 데이터 삭제
  await tx
    .delete(vendorTypes)
    .where(eq(vendorTypes.id, id));
  
  return deletedRecord;
}

/**
 * 다수의 ID로 여러 협력업체 타입 삭제
 */
export async function deleteVendorTypesByIds(tx: any, ids: number[]) {
  // 삭제 전 데이터 가져오기 (필요한 경우)
  const deletedRecords = await tx.select()
    .from(vendorTypes)
    .where(inArray(vendorTypes.id, ids));
  
  // 데이터 삭제
  await tx
    .delete(vendorTypes)
    .where(inArray(vendorTypes.id, ids));
  
  return deletedRecords;
}