package com.punchsettle.server.service.manager.impl;

import java.time.LocalDate;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;

import com.punchsettle.server.atomic.entity.PiMultiTask;
import com.punchsettle.server.atomic.entity.PiStatus;
import com.punchsettle.server.atomic.entity.PiTask;
import com.punchsettle.server.atomic.entity.PiTaskHistory;
import com.punchsettle.server.common.constant.CommonEnableStatusEnum;
import com.punchsettle.server.constant.CompareRuleEnum;
import com.punchsettle.server.constant.ContinueStageEnum;
import com.punchsettle.server.constant.PunchInMethodEnum;
import com.punchsettle.server.constant.PunchInResultEnum;
import com.punchsettle.server.constant.RepeatCategoryEnum;
import com.punchsettle.server.service.manager.IPunchInCoreManager;

/**
 * @author tyuio
 * @version 1.0.0
 * @date 2025/4/23 14:15
 * @description TODO
 */
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@ActiveProfiles(value={"dev", "test"})
class PunchInManagerImplTest {

    @Autowired
    private IPunchInCoreManager punchInManager;

    @Test
    void judgeRepeat() {
        PiTask piTask1 = new PiTask();
        piTask1.setRepeatCategory(RepeatCategoryEnum.EVERYDAY);
        Assertions.assertTrue(punchInManager.judgeRepeat(piTask1, "2025-04-23"));

        PiTask piTask2 = new PiTask();
        piTask2.setRepeatCategory(RepeatCategoryEnum.WORKDAY);
        Assertions.assertTrue(punchInManager.judgeRepeat(piTask2, "2025-04-23"));

        PiTask piTask3 = new PiTask();
        piTask3.setRepeatCategory(RepeatCategoryEnum.WORKDAY);
        Assertions.assertFalse(punchInManager.judgeRepeat(piTask3, "2025-04-26"));

        PiTask piTask4 = new PiTask();
        piTask4.setRepeatCategory(RepeatCategoryEnum.HOLIDAY);
        Assertions.assertFalse(punchInManager.judgeRepeat(piTask4, "2025-04-23"));

        PiTask piTask5 = new PiTask();
        piTask5.setRepeatCategory(RepeatCategoryEnum.HOLIDAY);
        Assertions.assertTrue(punchInManager.judgeRepeat(piTask5, "2025-04-26"));
    }

    @Test
    void judgePunchInResultInTask() {
        PiTask piTask1 = new PiTask();
        PunchInResultEnum punchInResult1 = punchInManager.judgePunchInResultInTask(piTask1, null);
        Assertions.assertEquals(PunchInResultEnum.UNDONE, punchInResult1);

        PiTask piTask2 = new PiTask();
        piTask2.setPunchInMethod(PunchInMethodEnum.SINGLE);
        PiTaskHistory piTaskHistory2 = new PiTaskHistory();
        PunchInResultEnum punchInResult2 = punchInManager.judgePunchInResultInTask(piTask2, piTaskHistory2);
        Assertions.assertEquals(PunchInResultEnum.UNDONE, punchInResult2);

        PiTask piTask3 = new PiTask();
        piTask3.setPunchInMethod(PunchInMethodEnum.SINGLE);
        PiTaskHistory piTaskHistory3 = new PiTaskHistory();
        piTaskHistory3.setCountTrack(2);
        PunchInResultEnum punchInResult3 = punchInManager.judgePunchInResultInTask(piTask3, piTaskHistory3);
        Assertions.assertEquals(PunchInResultEnum.DONE, punchInResult3);

        PiTask piTask4 = new PiTask();
        piTask4.setPunchInMethod(PunchInMethodEnum.COUNT);
        piTask4.setCompareRule(CompareRuleEnum.GTE);
        piTask4.setCountTrack(2);
        PiTaskHistory piTaskHistory4 = new PiTaskHistory();
        piTaskHistory4.setCountTrack(2);
        PunchInResultEnum punchInResult4 = punchInManager.judgePunchInResultInTask(piTask4, piTaskHistory4);
        Assertions.assertEquals(PunchInResultEnum.DONE, punchInResult4);

        PiTask piTask5 = new PiTask();
        piTask5.setPunchInMethod(PunchInMethodEnum.COUNT);
        piTask5.setCompareRule(CompareRuleEnum.GTE);
        piTask5.setCountTrack(2);
        PiTaskHistory piTaskHistory5 = new PiTaskHistory();
        piTaskHistory5.setCountTrack(1);
        PunchInResultEnum punchInResult5 = punchInManager.judgePunchInResultInTask(piTask5, piTaskHistory5);
        Assertions.assertEquals(PunchInResultEnum.UNDONE, punchInResult5);

        PiTask piTask6 = new PiTask();
        piTask6.setPunchInMethod(PunchInMethodEnum.COUNT);
        piTask6.setCompareRule(CompareRuleEnum.LTE);
        piTask6.setCountTrack(2);
        PiTaskHistory piTaskHistory6 = new PiTaskHistory();
        piTaskHistory6.setCountTrack(2);
        PunchInResultEnum punchInResult6 = punchInManager.judgePunchInResultInTask(piTask6, piTaskHistory6);
        Assertions.assertEquals(PunchInResultEnum.DONE, punchInResult6);

        PiTask piTask7 = new PiTask();
        piTask7.setPunchInMethod(PunchInMethodEnum.COUNT);
        piTask7.setCompareRule(CompareRuleEnum.LTE);
        piTask7.setCountTrack(2);
        PiTaskHistory piTaskHistory7 = new PiTaskHistory();
        piTaskHistory7.setCountTrack(3);
        PunchInResultEnum punchInResult7 = punchInManager.judgePunchInResultInTask(piTask7, piTaskHistory7);
        Assertions.assertEquals(PunchInResultEnum.UNDONE, punchInResult7);

        PiTask piTask8 = new PiTask();
        piTask8.setPunchInMethod(PunchInMethodEnum.TIMING);
        piTask8.setCompareRule(CompareRuleEnum.GTE);
        piTask8.setTimeTrack(LocalTime.parse("06:00:00.000"));
        PiTaskHistory piTaskHistory8 = new PiTaskHistory();
        piTaskHistory8.setTimeTrack(LocalTime.parse("06:00:00.000"));
        PunchInResultEnum punchInResult8 = punchInManager.judgePunchInResultInTask(piTask8, piTaskHistory8);
        Assertions.assertEquals(PunchInResultEnum.DONE, punchInResult8);

        PiTask piTask9 = new PiTask();
        piTask9.setPunchInMethod(PunchInMethodEnum.TIMING);
        piTask9.setCompareRule(CompareRuleEnum.GTE);
        piTask9.setTimeTrack(LocalTime.parse("06:00:00.000"));
        PiTaskHistory piTaskHistory9 = new PiTaskHistory();
        piTaskHistory9.setTimeTrack(LocalTime.parse("05:00:00.000"));
        PunchInResultEnum punchInResult9 = punchInManager.judgePunchInResultInTask(piTask9, piTaskHistory9);
        Assertions.assertEquals(PunchInResultEnum.UNDONE, punchInResult9);

        PiTask piTask10 = new PiTask();
        piTask10.setPunchInMethod(PunchInMethodEnum.TIMING);
        piTask10.setCompareRule(CompareRuleEnum.LTE);
        piTask10.setTimeTrack(LocalTime.parse("06:00:00.000"));
        PiTaskHistory piTaskHistory10 = new PiTaskHistory();
        piTaskHistory10.setTimeTrack(LocalTime.parse("06:00:00.000"));
        PunchInResultEnum punchInResult10 = punchInManager.judgePunchInResultInTask(piTask10, piTaskHistory10);
        Assertions.assertEquals(PunchInResultEnum.DONE, punchInResult10);

        PiTask piTask11 = new PiTask();
        piTask11.setPunchInMethod(PunchInMethodEnum.TIMING);
        piTask11.setCompareRule(CompareRuleEnum.LTE);
        piTask11.setTimeTrack(LocalTime.parse("06:00:00.000"));
        PiTaskHistory piTaskHistory11 = new PiTaskHistory();
        piTaskHistory11.setTimeTrack(LocalTime.parse("07:00:00.000"));
        PunchInResultEnum punchInResult11 = punchInManager.judgePunchInResultInTask(piTask11, piTaskHistory11);
        Assertions.assertEquals(PunchInResultEnum.UNDONE, punchInResult11);

        PiTask piTask12 = new PiTask();
        piTask12.setHolidayStatus(CommonEnableStatusEnum.ENABLED);
        piTask12.setPunchInMethod(PunchInMethodEnum.TIMING);
        piTask12.setCompareRule(CompareRuleEnum.GTE);
        piTask12.setTimeTrack(LocalTime.parse("06:00:00.000"));
        piTask12.setHolidayTimeTrack(LocalTime.parse("04:00:00.000"));
        PiTaskHistory piTaskHistory12 = new PiTaskHistory();
        piTaskHistory12.setPunchInDate("2025-04-26");
        piTaskHistory12.setTimeTrack(LocalTime.parse("04:00:00.000"));
        PunchInResultEnum punchInResult12 = punchInManager.judgePunchInResultInTask(piTask12, piTaskHistory12);
        Assertions.assertEquals(PunchInResultEnum.DONE, punchInResult12);

    }

    @Test
    void judgePunchInResultInMultiTask() {
        PiMultiTask piMultiTask1 = new PiMultiTask();
        piMultiTask1.setTaskPointsStatus(CommonEnableStatusEnum.ENABLED);
        List<PiTaskHistory> piTaskHistoryList1 = new ArrayList<>();
        PunchInResultEnum punchInResult1 = punchInManager.judgePunchInResultInMultiTask(piMultiTask1, piTaskHistoryList1);
        Assertions.assertEquals(PunchInResultEnum.UNDONE, punchInResult1);

        PiMultiTask piMultiTask11 = new PiMultiTask();
        piMultiTask11.setTaskPointsStatus(CommonEnableStatusEnum.DISABLED);
        List<PiTaskHistory> piTaskHistoryList11 = new ArrayList<>();
        PunchInResultEnum punchInResult11 = punchInManager.judgePunchInResultInMultiTask(piMultiTask11, piTaskHistoryList11);
        Assertions.assertEquals(PunchInResultEnum.UNDONE, punchInResult11);

        PiTaskHistory piTaskHistory1 = new PiTaskHistory();
        piTaskHistory1.setPunchInResult(PunchInResultEnum.DONE);
        PiTaskHistory piTaskHistory2 = new PiTaskHistory();
        piTaskHistory2.setPunchInResult(PunchInResultEnum.DONE);
        PiTaskHistory piTaskHistory3 = new PiTaskHistory();
        piTaskHistory3.setPunchInResult(PunchInResultEnum.DONE);
        PiTaskHistory piTaskHistory4 = new PiTaskHistory();
        piTaskHistory4.setPunchInResult(PunchInResultEnum.UNDONE);

        PiMultiTask piMultiTask2 = new PiMultiTask();
        piMultiTask2.setTaskPointsStatus(CommonEnableStatusEnum.ENABLED);
        piMultiTask2.setPunchInDoneCount(3);
        List<PiTaskHistory> piTaskHistoryList2 = Arrays.asList(piTaskHistory1, piTaskHistory2, piTaskHistory3, piTaskHistory4);
        PunchInResultEnum punchInResult2 = punchInManager.judgePunchInResultInMultiTask(piMultiTask2, piTaskHistoryList2);
        Assertions.assertEquals(PunchInResultEnum.DONE, punchInResult2);

        PiMultiTask piMultiTask3 = new PiMultiTask();
        piMultiTask3.setTaskPointsStatus(CommonEnableStatusEnum.ENABLED);
        piMultiTask3.setPunchInDoneCount(4);
        List<PiTaskHistory> piTaskHistoryList3 = Arrays.asList(piTaskHistory1, piTaskHistory2, piTaskHistory3, piTaskHistory4);
        PunchInResultEnum punchInResult3 = punchInManager.judgePunchInResultInMultiTask(piMultiTask3, piTaskHistoryList3);
        Assertions.assertEquals(PunchInResultEnum.UNDONE, punchInResult3);
    }

    @Test
    void getPunchInTotalCountInRange() {
        LocalDate today = LocalDate.parse("2025-04-23");
        LocalDate firstDayOfWeek = LocalDate.parse("2025-04-21");
        LocalDate lastDayOfWeek = LocalDate.parse("2025-04-27");

        int punchInTotalCount1 = punchInManager.getPunchInTotalCountInRange(RepeatCategoryEnum.EVERYDAY, null, firstDayOfWeek, lastDayOfWeek);
        Assertions.assertEquals(7, punchInTotalCount1);

        int punchInTotalCount2 = punchInManager.getPunchInTotalCountInRange(RepeatCategoryEnum.CUSTOM, "1,2,7,6", firstDayOfWeek, lastDayOfWeek);
        Assertions.assertEquals(4, punchInTotalCount2);

        int punchInTotalCount3 = punchInManager.getPunchInTotalCountInRange(RepeatCategoryEnum.WORKDAY, null, firstDayOfWeek, lastDayOfWeek);
        Assertions.assertEquals(6, punchInTotalCount3);

        int punchInTotalCount4 = punchInManager.getPunchInTotalCountInRange(RepeatCategoryEnum.HOLIDAY, null, firstDayOfWeek, lastDayOfWeek);
        Assertions.assertEquals(1, punchInTotalCount4);
    }

    @Test
    void judgeContinueStage() {
        PiTask piTask1 = new PiTask();
        piTask1.setContinueStatus(CommonEnableStatusEnum.DISABLED);
        ContinueStageEnum continueStage1 = punchInManager.judgeContinueStage(piTask1, null, null, null);
        Assertions.assertEquals(ContinueStageEnum.NONE, continueStage1);

        PiTask piTask = new PiTask();
        piTask.setContinueStatus(CommonEnableStatusEnum.ENABLED);
        piTask.setGraceDay(7);
        piTask.setContinueInterruptedCount(3);

        // 宽限期-还在宽限期限内
        PiStatus piStatus2 = new PiStatus();
        piStatus2.setContinueStage(ContinueStageEnum.GRACE_STAGE);
        piStatus2.setStageStartDate(LocalDate.parse("2025-04-23"));
        ContinueStageEnum continueStage2 = punchInManager.judgeContinueStage(piTask, null, piStatus2, LocalDate.parse("2025-04-25"));
        Assertions.assertEquals(ContinueStageEnum.GRACE_STAGE, continueStage2);

        // 宽限期-已超过宽限期限，但是未完成打卡
        PiStatus piStatus3 = new PiStatus();
        piStatus3.setContinueStage(ContinueStageEnum.GRACE_STAGE);
        piStatus3.setStageStartDate(LocalDate.parse("2025-04-23"));
        ContinueStageEnum continueStage3 = punchInManager.judgeContinueStage(piTask, PunchInResultEnum.UNDONE, piStatus3, LocalDate.parse("2025-05-01"));
        Assertions.assertEquals(ContinueStageEnum.GRACE_STAGE, continueStage3);

        // 宽限期-已超过宽限期限，且已完成打卡，进入正常打卡期
        PiStatus piStatus4 = new PiStatus();
        piStatus4.setContinueStage(ContinueStageEnum.GRACE_STAGE);
        piStatus4.setStageStartDate(LocalDate.parse("2025-04-23"));
        ContinueStageEnum continueStage4 = punchInManager.judgeContinueStage(piTask, PunchInResultEnum.DONE, piStatus4, LocalDate.parse("2025-05-01"));
        Assertions.assertEquals(ContinueStageEnum.NORMAL_STAGE, continueStage4);

        // 正常打卡期-完成打卡则继续是正常打卡期
        PiStatus piStatus5 = new PiStatus();
        piStatus5.setContinueStage(ContinueStageEnum.NORMAL_STAGE);
        ContinueStageEnum continueStage5 = punchInManager.judgeContinueStage(piTask, PunchInResultEnum.DONE, piStatus5, LocalDate.parse("2025-05-01"));
        Assertions.assertEquals(ContinueStageEnum.NORMAL_STAGE, continueStage5);

        // 正常打卡期-连续中断次数小于等于设置的中断次数 进入惩罚期
        PiStatus piStatus6 = new PiStatus();
        piStatus6.setContinueStage(ContinueStageEnum.NORMAL_STAGE);
        piStatus6.setContinueInterruptedCount(2);
        ContinueStageEnum continueStage6 = punchInManager.judgeContinueStage(piTask, PunchInResultEnum.UNDONE, piStatus6, LocalDate.parse("2025-05-01"));
        Assertions.assertEquals(ContinueStageEnum.PENALTY_STAGE, continueStage6);

        // 正常打卡期-连续中断次数大于等于设置的中断次数 重新进入宽限期
        PiStatus piStatus7 = new PiStatus();
        piStatus7.setContinueStage(ContinueStageEnum.NORMAL_STAGE);
        piStatus7.setContinueInterruptedCount(3);
        ContinueStageEnum continueStage7 = punchInManager.judgeContinueStage(piTask, PunchInResultEnum.UNDONE, piStatus7, LocalDate.parse("2025-05-01"));
        Assertions.assertEquals(ContinueStageEnum.GRACE_STAGE, continueStage7);

        // 惩罚期-仍处于惩罚期
        PiStatus piStatus8 = new PiStatus();
        piStatus8.setContinueStage(ContinueStageEnum.PENALTY_STAGE);
        piStatus8.setStageEndDate(LocalDate.parse("2025-04-27"));
        ContinueStageEnum continueStage8 = punchInManager.judgeContinueStage(piTask, PunchInResultEnum.UNDONE, piStatus8, LocalDate.parse("2025-04-23"));
        Assertions.assertEquals(ContinueStageEnum.PENALTY_STAGE, continueStage8);

        // 惩罚期-超出惩罚期，进入正常打卡期
        PiStatus piStatus9 = new PiStatus();
        piStatus9.setContinueStage(ContinueStageEnum.PENALTY_STAGE);
        piStatus9.setStageEndDate(LocalDate.parse("2025-04-27"));
        ContinueStageEnum continueStage9 = punchInManager.judgeContinueStage(piTask, PunchInResultEnum.UNDONE, piStatus9, LocalDate.parse("2025-04-28"));
        Assertions.assertEquals(ContinueStageEnum.NORMAL_STAGE, continueStage9);
    }
}