package com.kamco.cd.kamcoback.postgres.repository.label;

import static com.kamco.cd.kamcoback.postgres.entity.QLabelingAssignmentEntity.labelingAssignmentEntity;
import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalDataInferenceEntity.mapSheetAnalDataInferenceEntity;
import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalDataInferenceGeomEntity.mapSheetAnalDataInferenceGeomEntity;
import static com.kamco.cd.kamcoback.postgres.entity.QMapSheetAnalEntity.mapSheetAnalEntity;
import static com.kamco.cd.kamcoback.postgres.entity.QMemberEntity.memberEntity;

import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto;
import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.AllocateInfoDto;
import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.InferenceDetail;
import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.InspectState;
import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.LabelState;
import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.LabelerDetail;
import com.kamco.cd.kamcoback.label.dto.LabelAllocateDto.UserList;
import com.kamco.cd.kamcoback.label.dto.WorkerStatsDto.WorkProgressInfo;
import com.kamco.cd.kamcoback.label.dto.WorkerStatsDto.WorkerStatistics;
import com.kamco.cd.kamcoback.postgres.entity.LabelingAssignmentEntity;
import com.kamco.cd.kamcoback.postgres.entity.MapSheetAnalDataInferenceEntity;
import com.kamco.cd.kamcoback.postgres.entity.MapSheetAnalEntity;
import com.kamco.cd.kamcoback.postgres.entity.QMemberEntity;
import com.querydsl.core.types.Projections;
import com.querydsl.core.types.dsl.BooleanExpression;
import com.querydsl.core.types.dsl.CaseBuilder;
import com.querydsl.core.types.dsl.Expressions;
import com.querydsl.core.types.dsl.NumberExpression;
import com.querydsl.core.types.dsl.StringExpression;
import com.querydsl.jpa.impl.JPAQueryFactory;
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityNotFoundException;
import jakarta.persistence.PersistenceContext;
import jakarta.transaction.Transactional;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.List;
import java.util.Objects;
import java.util.UUID;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Repository;

@Slf4j
@Repository
@RequiredArgsConstructor
public class LabelAllocateRepositoryImpl implements LabelAllocateRepositoryCustom {

  private final JPAQueryFactory queryFactory;

  @PersistenceContext private EntityManager em;

  @Override
  public List<AllocateInfoDto> fetchNextIds(
      Long lastId, Long batchSize, Integer compareYyyy, Integer targetYyyy, Integer stage) {

    return queryFactory
        .select(
            Projections.constructor(
                AllocateInfoDto.class,
                mapSheetAnalDataInferenceGeomEntity.geoUid,
                mapSheetAnalDataInferenceGeomEntity.mapSheetNum))
        .from(mapSheetAnalDataInferenceGeomEntity)
        .where(
            lastId == null ? null : mapSheetAnalDataInferenceGeomEntity.geoUid.gt(lastId),
            mapSheetAnalDataInferenceGeomEntity.compareYyyy.eq(compareYyyy),
            mapSheetAnalDataInferenceGeomEntity.targetYyyy.eq(targetYyyy),
            mapSheetAnalDataInferenceGeomEntity.stage.eq(stage),
            mapSheetAnalDataInferenceGeomEntity.labelState.isNull())
        .orderBy(mapSheetAnalDataInferenceGeomEntity.mapSheetNum.asc())
        .limit(batchSize)
        .fetch();
  }

  @Override
  public void assignOwner(
      List<AllocateInfoDto> ids,
      String userId,
      Integer compareYyyy,
      Integer targetYyyy,
      Integer stage) {

    // analUid로 분석 정보 조회
    MapSheetAnalDataInferenceEntity analEntity =
        queryFactory
            .selectFrom(mapSheetAnalDataInferenceEntity)
            .where(
                mapSheetAnalDataInferenceEntity.compareYyyy.eq(compareYyyy),
                mapSheetAnalDataInferenceEntity.targetYyyy.eq(targetYyyy),
                mapSheetAnalDataInferenceEntity.stage.eq(stage))
            .orderBy(mapSheetAnalDataInferenceEntity.analUid.asc())
            .limit(1)
            .fetchOne();

    if (Objects.isNull(analEntity)) {
      throw new EntityNotFoundException("MapSheetAnalEntity not found for analUid: ");
    }

    // data_geom 테이블에 label state 를 ASSIGNED 로 update
    List<Long> geoUidList =
        ids.stream().map(AllocateInfoDto::getGeoUid).filter(Objects::nonNull).toList();

    queryFactory
        .update(mapSheetAnalDataInferenceGeomEntity)
        .set(mapSheetAnalDataInferenceGeomEntity.labelState, LabelState.ASSIGNED.getId())
        .set(mapSheetAnalDataInferenceGeomEntity.labelStateDttm, ZonedDateTime.now())
        .set(mapSheetAnalDataInferenceGeomEntity.testState, InspectState.UNCONFIRM.getId())
        .set(mapSheetAnalDataInferenceGeomEntity.testStateDttm, ZonedDateTime.now())
        .where(mapSheetAnalDataInferenceGeomEntity.geoUid.in(geoUidList))
        .execute();

    // 라벨러 할당 테이블에 insert
    String sql =
        """
        insert into tb_labeling_assignment
        (assignment_uid, inference_geom_uid, worker_uid,
         work_state, assign_group_id, anal_uid)
        values (?, ?, ?, ?, ?, ?)
        """;

    for (AllocateInfoDto info : ids) {
      em.createNativeQuery(sql)
          .setParameter(1, UUID.randomUUID())
          .setParameter(2, info.getGeoUid())
          .setParameter(3, userId)
          .setParameter(4, LabelState.ASSIGNED.getId())
          .setParameter(5, info.getMapSheetNum())
          .setParameter(6, analEntity.getAnalUid())
          .executeUpdate();
    }

    em.flush();
    em.clear();
  }

  @Override
  public List<LabelingAssignmentEntity> findAssignedLabelerList(
      Integer compareYyyy, Integer targetYyyy, Integer stage) {
    // analUid로 분석 정보 조회
    MapSheetAnalDataInferenceEntity analEntity =
        queryFactory
            .selectFrom(mapSheetAnalDataInferenceEntity)
            .where(
                mapSheetAnalDataInferenceEntity.compareYyyy.eq(compareYyyy),
                mapSheetAnalDataInferenceEntity.targetYyyy.eq(targetYyyy),
                mapSheetAnalDataInferenceEntity.stage.eq(stage))
            .orderBy(mapSheetAnalDataInferenceEntity.analUid.asc())
            .limit(1)
            .fetchOne();

    if (Objects.isNull(analEntity)) {
      throw new EntityNotFoundException("MapSheetAnalEntity not found for analUid: ");
    }

    return queryFactory
        .selectFrom(labelingAssignmentEntity)
        .where(
            labelingAssignmentEntity.analUid.eq(analEntity.getAnalUid()),
            labelingAssignmentEntity.workState.eq(LabelState.ASSIGNED.getId()),
            labelingAssignmentEntity.inspectorUid.isNull())
        .orderBy(labelingAssignmentEntity.workerUid.asc())
        .fetch();
  }

  @Override
  public Long findLabelUnAssignedCnt(Integer stage, Integer compareYyyy, Integer targetYyyy) {

    return queryFactory
        .select(mapSheetAnalDataInferenceGeomEntity.geoUid.count())
        .from(mapSheetAnalDataInferenceGeomEntity)
        .where(
            mapSheetAnalDataInferenceGeomEntity.compareYyyy.eq(compareYyyy),
            mapSheetAnalDataInferenceGeomEntity.targetYyyy.eq(targetYyyy),
            mapSheetAnalDataInferenceGeomEntity.stage.eq(stage),
            mapSheetAnalDataInferenceGeomEntity.labelState.isNull())
        .fetchOne();
  }

  @Override
  public void assignInspector(UUID assignmentUid, String inspectorUid) {
    queryFactory
        .update(labelingAssignmentEntity)
        .set(labelingAssignmentEntity.inspectorUid, inspectorUid)
        .where(labelingAssignmentEntity.assignmentUid.eq(assignmentUid))
        .execute();
  }

  @Override
  public List<UserList> availUserList(String role) {
    return queryFactory
        .select(
            Projections.constructor(
                LabelAllocateDto.UserList.class,
                memberEntity.userRole,
                memberEntity.employeeNo,
                memberEntity.name))
        .from(memberEntity)
        .where(
            memberEntity.userRole.eq(role),
            memberEntity.status.eq(com.kamco.cd.kamcoback.common.enums.StatusType.ACTIVE.getId()))
        .orderBy(memberEntity.name.asc())
        .fetch();
  }

  @Override
  public List<WorkerStatistics> findWorkerStatistics(
      Long analUid,
      String workerType,
      String searchName,
      String searchEmployeeNo,
      String sortType) {

    // 작업자 유형에 따른 필드 선택
    StringExpression workerIdField =
        "REVIEWER".equals(workerType)
            ? labelingAssignmentEntity.inspectorUid
            : labelingAssignmentEntity.workerUid;

    BooleanExpression workerCondition =
        "REVIEWER".equals(workerType)
            ? labelingAssignmentEntity.inspectorUid.isNotNull()
            : labelingAssignmentEntity.workerUid.isNotNull();

    // 검색 조건
    BooleanExpression searchCondition = null;
    if (searchName != null && !searchName.isEmpty()) {
      searchCondition = memberEntity.name.contains(searchName);
    }
    if (searchEmployeeNo != null && !searchEmployeeNo.isEmpty()) {
      BooleanExpression empCondition = memberEntity.employeeNo.contains(searchEmployeeNo);
      searchCondition = searchCondition == null ? empCondition : searchCondition.and(empCondition);
    }

    // 완료, 스킵, 남은 작업 계산
    NumberExpression<Long> completedSum =
        new CaseBuilder()
            .when(labelingAssignmentEntity.workState.eq("DONE"))
            .then(1L)
            .otherwise(0L)
            .sum();

    NumberExpression<Long> skippedSum =
        new CaseBuilder()
            .when(labelingAssignmentEntity.workState.eq("SKIP"))
            .then(1L)
            .otherwise(0L)
            .sum();

    NumberExpression<Long> remainingSum =
        new CaseBuilder()
            .when(
                labelingAssignmentEntity
                    .workState
                    .notIn("DONE", "SKIP")
                    .and(labelingAssignmentEntity.workState.isNotNull()))
            .then(1L)
            .otherwise(0L)
            .sum();

    // 기본 통계 조회 쿼리
    var baseQuery =
        queryFactory
            .select(
                workerIdField,
                memberEntity.name,
                workerIdField.count(),
                completedSum,
                skippedSum,
                remainingSum,
                labelingAssignmentEntity.stagnationYn.max())
            .from(labelingAssignmentEntity)
            .leftJoin(memberEntity)
            .on(
                "REVIEWER".equals(workerType)
                    ? memberEntity.employeeNo.eq(labelingAssignmentEntity.inspectorUid)
                    : memberEntity.employeeNo.eq(labelingAssignmentEntity.workerUid))
            .where(labelingAssignmentEntity.analUid.eq(analUid), workerCondition, searchCondition)
            .groupBy(workerIdField, memberEntity.name);

    // 정렬 조건 적용
    if (sortType != null) {
      switch (sortType) {
        case "REMAINING_DESC":
          baseQuery.orderBy(remainingSum.desc());
          break;
        case "REMAINING_ASC":
          baseQuery.orderBy(remainingSum.asc());
          break;
        case "NAME_ASC":
          baseQuery.orderBy(memberEntity.name.asc());
          break;
        case "NAME_DESC":
          baseQuery.orderBy(memberEntity.name.desc());
          break;
        default:
          baseQuery.orderBy(memberEntity.name.asc());
      }
    } else {
      baseQuery.orderBy(memberEntity.name.asc());
    }

    // 결과를 DTO로 변환
    return baseQuery.fetch().stream()
        .map(
            tuple -> {
              Character maxStagnationYn = tuple.get(labelingAssignmentEntity.stagnationYn.max());
              return WorkerStatistics.builder()
                  .workerId(tuple.get(workerIdField))
                  .workerName(tuple.get(memberEntity.name))
                  .workerType(workerType)
                  .totalAssigned(tuple.get(workerIdField.count()))
                  .completed(tuple.get(completedSum))
                  .skipped(tuple.get(skippedSum))
                  .remaining(tuple.get(remainingSum))
                  .history(null) // 3일 이력은 Service에서 채움
                  .isStagnated(maxStagnationYn != null && maxStagnationYn == 'Y')
                  .build();
            })
        .toList();
  }

  @Override
  public WorkProgressInfo findWorkProgressInfo(Long analUid) {
    // 전체 배정 건수
    Long totalAssigned =
        queryFactory
            .select(labelingAssignmentEntity.count())
            .from(labelingAssignmentEntity)
            .where(labelingAssignmentEntity.analUid.eq(analUid))
            .fetchOne();

    // 완료 + 스킵 건수
    Long completedCount =
        queryFactory
            .select(labelingAssignmentEntity.count())
            .from(labelingAssignmentEntity)
            .where(
                labelingAssignmentEntity.analUid.eq(analUid),
                labelingAssignmentEntity.workState.in("DONE", "SKIP"))
            .fetchOne();

    // 투입된 라벨러 수 (고유한 worker_uid 수)
    Long labelerCount =
        queryFactory
            .select(labelingAssignmentEntity.workerUid.countDistinct())
            .from(labelingAssignmentEntity)
            .where(
                labelingAssignmentEntity.analUid.eq(analUid),
                labelingAssignmentEntity.workerUid.isNotNull())
            .fetchOne();

    // 남은 라벨링 작업 데이터 수
    Long remainingLabelCount =
        queryFactory
            .select(labelingAssignmentEntity.count())
            .from(labelingAssignmentEntity)
            .where(
                labelingAssignmentEntity.analUid.eq(analUid),
                labelingAssignmentEntity.workerUid.isNotNull(),
                labelingAssignmentEntity.workState.notIn("DONE", "SKIP"))
            .fetchOne();

    // 투입된 검수자 수 (고유한 inspector_uid 수)
    Long inspectorCount =
        queryFactory
            .select(labelingAssignmentEntity.inspectorUid.countDistinct())
            .from(labelingAssignmentEntity)
            .where(
                labelingAssignmentEntity.analUid.eq(analUid),
                labelingAssignmentEntity.inspectorUid.isNotNull())
            .fetchOne();

    // 남은 검수 작업 데이터 수
    Long remainingInspectCount =
        queryFactory
            .select(labelingAssignmentEntity.count())
            .from(labelingAssignmentEntity)
            .where(
                labelingAssignmentEntity.analUid.eq(analUid),
                labelingAssignmentEntity.inspectorUid.isNotNull(),
                labelingAssignmentEntity.workState.notIn("DONE"))
            .fetchOne();

    // 진행률 계산
    double progressRate = 0.0;
    if (totalAssigned != null && totalAssigned > 0) {
      progressRate =
          (completedCount != null ? completedCount.doubleValue() : 0.0) / totalAssigned * 100;
    }

    // 작업 상태 판단 (간단하게 진행률 100%면 종료, 아니면 진행중)
    String workStatus = (progressRate >= 100.0) ? "종료" : "진행중";

    return WorkProgressInfo.builder()
        .labelingProgressRate(progressRate)
        .workStatus(workStatus)
        .completedCount(completedCount != null ? completedCount : 0L)
        .totalAssignedCount(totalAssigned != null ? totalAssigned : 0L)
        .labelerCount(labelerCount != null ? labelerCount : 0L)
        .remainingLabelCount(remainingLabelCount != null ? remainingLabelCount : 0L)
        .inspectorCount(inspectorCount != null ? inspectorCount : 0L)
        .remainingInspectCount(remainingInspectCount != null ? remainingInspectCount : 0L)
        .build();
  }

  @Override
  public Long findDailyProcessedCount(
      String workerId, String workerType, LocalDate date, Long analUid) {

    // 해당 날짜의 시작과 끝 시간
    ZonedDateTime startOfDay = date.atStartOfDay(ZoneId.systemDefault());
    ZonedDateTime endOfDay = date.atTime(LocalTime.MAX).atZone(ZoneId.systemDefault());

    BooleanExpression workerCondition =
        "REVIEWER".equals(workerType)
            ? labelingAssignmentEntity.inspectorUid.eq(workerId)
            : labelingAssignmentEntity.workerUid.eq(workerId);

    Long count =
        queryFactory
            .select(labelingAssignmentEntity.count())
            .from(labelingAssignmentEntity)
            .where(
                labelingAssignmentEntity.analUid.eq(analUid),
                workerCondition,
                labelingAssignmentEntity.workState.in(
                    LabelState.DONE.getId(), LabelState.SKIP.getId()),
                labelingAssignmentEntity.modifiedDate.between(startOfDay, endOfDay))
            .fetchOne();

    return count != null ? count : 0L;
  }

  @Override
  public void assignInspectorBulk(List<UUID> assignmentUids, String inspectorUid) {
    queryFactory
        .update(labelingAssignmentEntity)
        .set(labelingAssignmentEntity.inspectorUid, inspectorUid)
        .where(labelingAssignmentEntity.assignmentUid.in(assignmentUids))
        .execute();

    em.clear();
  }

  @Override
  public InferenceDetail findInferenceDetail(
      Integer compareYyyy, Integer targetYyyy, Integer stage) {
    // analUid로 분석 정보 조회
    MapSheetAnalDataInferenceEntity analEntity =
        queryFactory
            .selectFrom(mapSheetAnalDataInferenceEntity)
            .where(
                mapSheetAnalDataInferenceEntity.compareYyyy.eq(compareYyyy),
                mapSheetAnalDataInferenceEntity.targetYyyy.eq(targetYyyy),
                mapSheetAnalDataInferenceEntity.stage.eq(stage))
            .orderBy(mapSheetAnalDataInferenceEntity.analUid.asc())
            .limit(1)
            .fetchOne();

    return queryFactory
        .select(
            Projections.constructor(
                InferenceDetail.class,
                mapSheetAnalEntity.analTitle,
                Expressions.numberTemplate(Integer.class, "{0}", 4),
                mapSheetAnalEntity.gukyuinApplyDttm,
                mapSheetAnalEntity.detectingCnt,
                labelingAssignmentEntity.workerUid.countDistinct(),
                labelingAssignmentEntity.inspectorUid.countDistinct()))
        .from(mapSheetAnalEntity)
        .innerJoin(labelingAssignmentEntity)
        .on(mapSheetAnalEntity.id.eq(labelingAssignmentEntity.analUid))
        .where(mapSheetAnalEntity.id.eq(analEntity.getAnalUid()))
        .groupBy(
            mapSheetAnalEntity.analTitle,
            mapSheetAnalEntity.gukyuinApplyDttm,
            mapSheetAnalEntity.detectingCnt)
        .fetchOne();
  }

  @Override
  public List<Long> fetchNextMoveIds(
      Long lastId, Long batchSize, Integer compareYyyy, Integer targetYyyy, Integer stage) {

    return queryFactory
        .select(mapSheetAnalDataInferenceGeomEntity.geoUid)
        .from(mapSheetAnalDataInferenceGeomEntity)
        .where(
            //        mapSheetAnalDataGeomEntity.pnu.isNotNull(),   //TODO: Mockup 진행 이후 확인하기
            lastId == null ? null : mapSheetAnalDataInferenceGeomEntity.geoUid.gt(lastId),
            mapSheetAnalDataInferenceGeomEntity.compareYyyy.eq(compareYyyy),
            mapSheetAnalDataInferenceGeomEntity.targetYyyy.eq(targetYyyy),
            mapSheetAnalDataInferenceGeomEntity.stage.eq(stage),
            mapSheetAnalDataInferenceGeomEntity.labelState.in(
                LabelState.ASSIGNED.getId(), LabelState.SKIP.getId()))
        .orderBy(mapSheetAnalDataInferenceGeomEntity.mapSheetNum.asc())
        .limit(batchSize)
        .fetch();
  }

  @Override
  public Long findLabelUnCompleteCnt(Long analUid) {
    MapSheetAnalEntity entity =
        queryFactory
            .selectFrom(mapSheetAnalEntity)
            .where(mapSheetAnalEntity.id.eq(analUid))
            .fetchOne();

    if (Objects.isNull(entity)) {
      throw new EntityNotFoundException();
    }

    return queryFactory
        .select(mapSheetAnalDataInferenceGeomEntity.geoUid.count())
        .from(mapSheetAnalDataInferenceGeomEntity)
        .where(
            mapSheetAnalDataInferenceGeomEntity.compareYyyy.eq(entity.getCompareYyyy()),
            mapSheetAnalDataInferenceGeomEntity.targetYyyy.eq(entity.getTargetYyyy()),
            mapSheetAnalDataInferenceGeomEntity.stage.eq(4), // TODO: 회차 컬럼을 가져와야 할 듯?
            mapSheetAnalDataInferenceGeomEntity.labelState.in(
                LabelState.ASSIGNED.getId(), LabelState.SKIP.getId()))
        .fetchOne();
  }

  @Transactional
  @Override
  public void assignOwnerMove(List<Long> sub, String userId) {
    queryFactory
        .update(labelingAssignmentEntity)
        .set(labelingAssignmentEntity.workerUid, userId)
        .where(labelingAssignmentEntity.inferenceGeomUid.in(sub))
        .execute();

    em.clear();
  }

  @Override
  public LabelerDetail findLabelerDetail(
      String userId, Integer compareYyyy, Integer targetYyyy, Integer stage) {
    NumberExpression<Long> assignedCnt =
        new CaseBuilder()
            .when(labelingAssignmentEntity.workState.eq(LabelState.ASSIGNED.getId()))
            .then(1L)
            .otherwise((Long) null)
            .count();

    NumberExpression<Long> skipCnt =
        new CaseBuilder()
            .when(labelingAssignmentEntity.workState.eq(LabelState.SKIP.getId()))
            .then(1L)
            .otherwise((Long) null)
            .count();

    NumberExpression<Long> completeCnt =
        new CaseBuilder()
            .when(labelingAssignmentEntity.workState.eq(LabelState.COMPLETE.getId()))
            .then(1L)
            .otherwise((Long) null)
            .count();

    NumberExpression<Double> percent =
        new CaseBuilder()
            .when(completeCnt.eq(0L))
            .then(0.0)
            .otherwise(
                Expressions.numberTemplate(
                    Double.class,
                    "round({0} / {1}, 2)",
                    labelingAssignmentEntity.count(),
                    completeCnt));

    // analUid로 분석 정보 조회
    MapSheetAnalDataInferenceEntity analEntity =
        queryFactory
            .selectFrom(mapSheetAnalDataInferenceEntity)
            .where(
                mapSheetAnalDataInferenceEntity.compareYyyy.eq(compareYyyy),
                mapSheetAnalDataInferenceEntity.targetYyyy.eq(targetYyyy),
                mapSheetAnalDataInferenceEntity.stage.eq(stage))
            .orderBy(mapSheetAnalDataInferenceEntity.analUid.asc())
            .limit(1)
            .fetchOne();

    if (Objects.isNull(analEntity)) {
      throw new EntityNotFoundException("MapSheetAnalEntity not found for analUid: ");
    }

    QMemberEntity worker = QMemberEntity.memberEntity;
    QMemberEntity inspector = new QMemberEntity("inspector");

    return queryFactory
        .select(
            Projections.constructor(
                LabelerDetail.class,
                worker.userRole,
                worker.name,
                worker.employeeNo,
                assignedCnt,
                skipCnt,
                completeCnt,
                percent,
                Expressions.constant(0), // TODO: 순위, 꼭 해야할지?
                labelingAssignmentEntity.createdDate.min(),
                inspector.name.min()))
        .from(worker)
        .innerJoin(labelingAssignmentEntity)
        .on(
            worker.employeeNo.eq(labelingAssignmentEntity.workerUid),
            labelingAssignmentEntity.analUid.eq(analEntity.getAnalUid()))
        .leftJoin(inspector)
        .on(labelingAssignmentEntity.inspectorUid.eq(inspector.employeeNo))
        .where(worker.employeeNo.eq(userId))
        .groupBy(worker.userRole, worker.name, worker.employeeNo)
        .fetchOne();
  }
}
