path: root/lib/evaluation-criteria/service.ts

/* eslint-disable @typescript-eslint/no-explicit-any */

'use server';

/* IMPORT */
import {
  and,
  asc,
  desc,
  ilike,
  or,count, eq
} from 'drizzle-orm';
import {
  countRegEvalCriteria,
  deleteRegEvalCriteria,
  deleteRegEvalCriteriaDetails,
  insertRegEvalCriteria,
  insertRegEvalCriteriaDetails,
  selectRegEvalCriteria,
  selectRegEvalCriteriaWithDetails,
  updateRegEvalCriteria,
  updateRegEvalCriteriaDetails,
} from './repository';
import db from '@/db/db';
import { filterColumns } from '@/lib/filter-columns';
import { 
  REG_EVAL_CRITERIA_CATEGORY2_ENUM,
  REG_EVAL_CRITERIA_CATEGORY_ENUM,
  REG_EVAL_CRITERIA_ITEM_ENUM,
  regEvalCriteria, regEvalCriteriaDetails, // regEvalCriteriaView 대신 regEvalCriteria 사용
  type NewRegEvalCriteria,
  type NewRegEvalCriteriaDetails,
  type RegEvalCriteria,
  type RegEvalCriteriaDetails,
  type RegEvalCriteriaView,
} from '@/db/schema';
import { type GetRegEvalCriteriaSchema } from './validations';

// ----------------------------------------------------------------------------------------------------

/* TYPES */

// ----------------------------------------------------------------------------------------------------

/* FUNCTION FOR GETTING CRITERIA - 메인 기준 목록만 가져오기 */
async function getRegEvalCriteria(input: GetRegEvalCriteriaSchema) {
  try {
    const offset = (input.page - 1) * input.perPage;
    const advancedWhere = filterColumns({
      table: regEvalCriteria, // view 대신 메인 테이블 사용
      filters: input.filters,
      joinOperator: input.joinOperator,
    });

    // Filtering - 메인 테이블 컬럼들 기준으로 검색
    let globalWhere;
    if (input.search) {
      const s = `%${input.search}%`;
      globalWhere = or(
        ilike(regEvalCriteria.category, s),
        ilike(regEvalCriteria.item, s),
        ilike(regEvalCriteria.classification, s),
        ilike(regEvalCriteria.range, s), // range 검색 추가
      );
    }
    const finalWhere = and(advancedWhere, globalWhere);

    // Sorting
    const orderBy = input.sort.length > 0
      ? input.sort.map((item) => {
          return item.desc
            ? desc(regEvalCriteria[item.id])
            : asc(regEvalCriteria[item.id]);
        })
      : [asc(regEvalCriteria.id)];

    // Getting Data - 메인 기준 데이터만 가져오기
    const { data, total } = await db.transaction(async (tx) => {
      const data = await tx
        .select()
        .from(regEvalCriteria)
        .where(finalWhere)
        .orderBy(...orderBy)
        .offset(offset)
        .limit(input.perPage);
      
      const totalResult = await tx
      .select({ count: count() })
        .from(regEvalCriteria)
        .where(finalWhere);
      
      const total = totalResult[0]?.count || 0;

      return { data, total };
    });
    const pageCount = Math.ceil(total / input.perPage);
    return { data, pageCount };
  } catch (err) {
    console.error('Error in Getting Regular Evaluation Criteria: ', err);
    return { data: [], pageCount: 0 };
  }
}

/* FUNCTION FOR GETTING CRITERIA WITH DETAILS */
async function getRegEvalCriteriaWithDetails(id: number) {
  try {
    return await db.transaction(async (tx) => {
      return await selectRegEvalCriteriaWithDetails(tx, id);
    });
  } catch (err) {
    console.error('Error in Getting Regular Evaluation Criteria with Details: ', err);
    return null;
  }
}

/* FUNCTION FOR GETTING CRITERIA DETAILS ONLY - 특정 기준의 상세 항목들만 가져오기 */
async function getRegEvalCriteriaDetails(criteriaId: number) {
  try {

    console.log(criteriaId,"criteriaId")
    return await db.transaction(async (tx) => {
      const details = await tx
        .select()
        .from(regEvalCriteriaDetails)
        .where(eq(regEvalCriteriaDetails.criteriaId, criteriaId))
        .orderBy(asc(regEvalCriteriaDetails.orderIndex));
      
      return details;
    });
  } catch (err) {
    console.error('Error in Getting Regular Evaluation Criteria Details: ', err);
    return [];
  }
}

// ----------------------------------------------------------------------------------------------------

/* FUNCTION FOR CREATING CRITERIA WITH DETAILS */
async function createRegEvalCriteriaWithDetails(
  criteriaData: NewRegEvalCriteria,
  detailList: Omit<NewRegEvalCriteriaDetails, 'criteriaId'>[],
) {
  try {
    return await db.transaction(async (tx) => {
      const criteria = await insertRegEvalCriteria(tx, criteriaData);
      const criteriaId = criteria.id;
      const newDetailList = detailList.map((detailItem, index) => ({
        ...detailItem,
        criteriaId,
        orderIndex: detailItem.orderIndex || index,
      }));

      const criteriaDetails: NewRegEvalCriteriaDetails[] = [];
      for (let idx = 0; idx < newDetailList.length; idx += 1) {
        criteriaDetails.push(await insertRegEvalCriteriaDetails(tx, newDetailList[idx]));
      }

      return { ...criteria, criteriaDetails };
    });
  } catch (error) {
    console.error('Error in Creating New Regular Evaluation Criteria with Details: ', error);
    throw new Error('Failed to Create New Regular Evaluation Criteria with Details');
  }
}

// ----------------------------------------------------------------------------------------------------

/* FUNCTION FOR MODIFYING CRITERIA WITH DETAILS */
async function modifyRegEvalCriteriaWithDetails(
  id: number,
  criteriaData: Partial<RegEvalCriteria>,
  detailList: Partial<RegEvalCriteriaDetails>[],
) {
  try {
    return await db.transaction(async (tx) => {

      console.log(id, criteriaData)

      const modifiedCriteria = await updateRegEvalCriteria(tx, id, criteriaData);
      const originCriteria = await getRegEvalCriteriaWithDetails(id);
      const originCriteriaDetails = originCriteria?.criteriaDetails || [];
      const detailIdList = detailList
        .filter(item => item.id !== undefined)
        .map(item => item.id);
      const toDeleteIdList = originCriteriaDetails.filter(
        (item) => !detailIdList.includes(item.id),
      );

      for (const item of toDeleteIdList) {
        await deleteRegEvalCriteriaDetails(tx, item.id);
      }

      const criteriaDetails = [];
      for (let idx = 0; idx < detailList.length; idx += 1) {
        const detailItem = detailList[idx];
        const isUpdate = detailItem.id;
        const isInsert = !detailItem.id && detailItem.detail;

        if (isUpdate) {
          const updatedDetail = await updateRegEvalCriteriaDetails(tx, detailItem.id!, detailItem);
          criteriaDetails.push(updatedDetail);
        } else if (isInsert) {
          const newDetailItem = {
            ...detailItem,
            criteriaId: id,
            detail: detailItem.detail!,
            orderIndex: detailItem.orderIndex || idx,
          };
          const insertedDetail = await insertRegEvalCriteriaDetails(tx, newDetailItem);
          criteriaDetails.push(insertedDetail);
        }
      }

      return { ...modifiedCriteria, criteriaDetails };
    });
  } catch (error) {
    console.error('Error in Modifying Regular Evaluation Criteria with Details: ', error);
    throw new Error('Failed to Modify Regular Evaluation Criteria with Details');
  }
}

// ----------------------------------------------------------------------------------------------------

/* FUNCTION FOR REMOVING CRITERIA WITH DETAILS */
async function removeRegEvalCriteria(id: number) {
  try {
    return await db.transaction(async (tx) => {
      return await deleteRegEvalCriteria(tx, id);
    });
  } catch (err) {
    console.error('Error in Removing Regular Evaluation Criteria with Details: ', err);
    throw new Error('Failed to Remove Regular Evaluation Criteria with Details');
  }
}

/* FUNCTION FOR REMOVING CRITERIA DETAILS */
async function removeRegEvalCriteriaDetails(id: number) {
  try {
    return await db.transaction(async (tx) => {
      return await deleteRegEvalCriteriaDetails(tx, id);
    });
  } catch (err) {
    console.error('Error in Removing Regular Evaluation Criteria Details: ', err);
    throw new Error('Failed to Remove Regular Evaluation Criteria Details');
  }
}

// ----------------------------------------------------------------------------------------------------

/* EXPORT */
export {
  createRegEvalCriteriaWithDetails,
  modifyRegEvalCriteriaWithDetails,
  getRegEvalCriteria,
  getRegEvalCriteriaWithDetails,
  getRegEvalCriteriaDetails, // 새로 추가
  removeRegEvalCriteria,
  removeRegEvalCriteriaDetails,
};