package cn.iocoder.yudao.module.mes.service.qc.indicatorresult;

import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.map.MapUtil;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.test.core.ut.BaseDbUnitTest;
import cn.iocoder.yudao.module.mes.controller.admin.qc.indicatorresult.vo.MesQcIndicatorResultPageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.indicatorresult.vo.MesQcIndicatorResultSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.indicator.MesQcIndicatorDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.indicatorresult.MesQcIndicatorResultDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.iqc.MesQcIqcDO;
import cn.iocoder.yudao.module.mes.dal.mysql.qc.indicatorresult.MesQcIndicatorResultMapper;
import cn.iocoder.yudao.module.mes.enums.qc.MesQcResultValueTypeEnum;
import cn.iocoder.yudao.module.mes.enums.qc.MesQcTypeEnum;
import cn.iocoder.yudao.module.mes.service.qc.indicator.MesQcIndicatorService;
import cn.iocoder.yudao.module.mes.service.qc.ipqc.MesQcIpqcService;
import cn.iocoder.yudao.module.mes.service.qc.iqc.MesQcIqcService;
import cn.iocoder.yudao.module.mes.service.qc.oqc.MesQcOqcService;
import cn.iocoder.yudao.module.mes.service.qc.rqc.MesQcRqcService;
import cn.iocoder.yudao.module.system.api.dict.DictDataApi;
import jakarta.annotation.Resource;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.bean.override.mockito.MockitoBean;

import static cn.iocoder.yudao.framework.common.util.object.ObjectUtils.cloneIgnoreId;
import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.assertPojoEquals;
import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.assertServiceException;
import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.randomLongId;
import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.randomPojo;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.anySet;
import static org.mockito.Mockito.*;

/**
 * {@link MesQcIndicatorResultServiceImpl} 的单元测试
 *
 * @author 芋道源码
 */
@Import(MesQcIndicatorResultServiceImpl.class)
public class MesQcIndicatorResultServiceImplTest extends BaseDbUnitTest {

    @Resource
    private MesQcIndicatorResultServiceImpl indicatorResultService;

    @Resource
    private MesQcIndicatorResultMapper resultMapper;

    @MockitoBean
    private MesQcIndicatorResultDetailService resultDetailService;
    @MockitoBean
    private MesQcIndicatorService indicatorService;
    @MockitoBean
    private MesQcIqcService iqcService;
    @MockitoBean
    private MesQcIpqcService ipqcService;
    @MockitoBean
    private MesQcOqcService oqcService;
    @MockitoBean
    private MesQcRqcService rqcService;
    @MockitoBean
    private DictDataApi dictDataApi;

    @Test
    public void testCreateIndicatorResult_success() {
        // 准备参数
        MesQcIndicatorResultSaveReqVO reqVO = buildReqVO("plain text value", MesQcResultValueTypeEnum.TEXT.getType());
        // mock 方法
        mockIqcAndIndicator(reqVO, MesQcResultValueTypeEnum.TEXT.getType());

        // 调用
        Long resultId = indicatorResultService.createIndicatorResult(reqVO);

        // 断言
        assertNotNull(resultId);
        MesQcIndicatorResultDO dbResult = resultMapper.selectById(resultId);
        assertNotNull(dbResult);
        assertEquals(reqVO.getCode(), dbResult.getCode());
        assertEquals(reqVO.getQcId(), dbResult.getQcId());
        assertEquals(reqVO.getQcType(), dbResult.getQcType());
        assertEquals(100L, dbResult.getItemId()); // 从 mock IQC 获取
        verify(resultDetailService).createDetailList(anyList());
    }

    @Test
    public void testCreateIndicatorResult_fileValueInvalid() {
        // 准备参数
        MesQcIndicatorResultSaveReqVO reqVO = buildReqVO("not-a-url", MesQcResultValueTypeEnum.FILE.getType());
        // mock 方法
        mockIqcAndIndicator(reqVO, MesQcResultValueTypeEnum.FILE.getType());

        // 调用，并断言异常
        assertServiceException(() -> indicatorResultService.createIndicatorResult(reqVO),
                QC_RESULT_VALUE_FORMAT_INVALID, "检测项[检测项A]要求文件 URL，实际值=not-a-url");

        // 断言：未入库
        assertEquals(0, resultMapper.selectCount());
        verify(resultDetailService, never()).createDetailList(anyList());
    }

    @Test
    public void testUpdateIndicatorResult_success() {
        // mock 数据
        MesQcIndicatorResultDO dbResult = randomPojo(MesQcIndicatorResultDO.class, o -> {
            o.setQcType(MesQcTypeEnum.IQC.getType());
        });
        resultMapper.insert(dbResult);
        // 准备参数
        MesQcIndicatorResultSaveReqVO reqVO = buildReqVO("updated text", MesQcResultValueTypeEnum.TEXT.getType());
        reqVO.setId(dbResult.getId());
        // mock 方法
        MesQcIndicatorDO indicator = new MesQcIndicatorDO();
        indicator.setId(reqVO.getItems().get(0).getIndicatorId());
        indicator.setName("检测项A");
        indicator.setResultType(MesQcResultValueTypeEnum.TEXT.getType());
        when(indicatorService.validateIndicatorListExists(anySet()))
                .thenReturn(MapUtil.of(indicator.getId(), indicator));

        // 调用
        indicatorResultService.updateIndicatorResult(reqVO);

        // 断言
        MesQcIndicatorResultDO updatedResult = resultMapper.selectById(dbResult.getId());
        assertEquals(reqVO.getCode(), updatedResult.getCode());
        // qcId/qcType/itemId 不允许改挂，应保持原值
        assertEquals(dbResult.getQcId(), updatedResult.getQcId());
        assertEquals(dbResult.getQcType(), updatedResult.getQcType());
        assertEquals(dbResult.getItemId(), updatedResult.getItemId());
        verify(resultDetailService).createOrUpdateDetailList(anyList());
    }

    @Test
    public void testUpdateIndicatorResult_notExists() {
        // 准备参数
        MesQcIndicatorResultSaveReqVO reqVO = buildReqVO("text", MesQcResultValueTypeEnum.TEXT.getType());
        reqVO.setId(randomLongId());

        // 调用，并断言异常
        assertServiceException(() -> indicatorResultService.updateIndicatorResult(reqVO),
                QC_RESULT_NOT_EXISTS);
    }

    @Test
    public void testDeleteIndicatorResult_success() {
        // mock 数据
        MesQcIndicatorResultDO dbResult = randomPojo(MesQcIndicatorResultDO.class);
        resultMapper.insert(dbResult);

        // 调用
        indicatorResultService.deleteIndicatorResult(dbResult.getId());

        // 断言
        assertNull(resultMapper.selectById(dbResult.getId()));
        verify(resultDetailService).deleteDetailByResultId(dbResult.getId());
    }

    @Test
    public void testDeleteIndicatorResult_notExists() {
        // 调用，并断言异常
        assertServiceException(() -> indicatorResultService.deleteIndicatorResult(randomLongId()),
                QC_RESULT_NOT_EXISTS);
    }

    @Test
    public void testGetIndicatorResult() {
        // mock 数据
        MesQcIndicatorResultDO dbResult = randomPojo(MesQcIndicatorResultDO.class);
        resultMapper.insert(dbResult);

        // 调用
        MesQcIndicatorResultDO result = indicatorResultService.getIndicatorResult(dbResult.getId());

        // 断言
        assertPojoEquals(dbResult, result);
    }

    @Test
    public void testGetIndicatorResultPage() {
        // mock 数据
        MesQcIndicatorResultDO dbResult = randomPojo(MesQcIndicatorResultDO.class, o -> {
            o.setQcId(1L);
            o.setQcType(MesQcTypeEnum.IQC.getType());
            o.setCode("SPL-001");
            o.setItemId(100L);
        });
        resultMapper.insert(dbResult);
        // 测试 qcId 不匹配
        resultMapper.insert(cloneIgnoreId(dbResult, o -> o.setQcId(2L)));
        // 测试 qcType 不匹配
        resultMapper.insert(cloneIgnoreId(dbResult, o -> o.setQcType(MesQcTypeEnum.IPQC.getType())));
        // 测试 code 不匹配
        resultMapper.insert(cloneIgnoreId(dbResult, o -> o.setCode("SPL-999")));
        // 测试 itemId 不匹配
        resultMapper.insert(cloneIgnoreId(dbResult, o -> o.setItemId(999L)));
        // 准备参数
        MesQcIndicatorResultPageReqVO pageReqVO = new MesQcIndicatorResultPageReqVO();
        pageReqVO.setQcId(1L);
        pageReqVO.setQcType(MesQcTypeEnum.IQC.getType());
        pageReqVO.setCode("SPL-001");
        pageReqVO.setItemId(100L);

        // 调用
        PageResult<MesQcIndicatorResultDO> pageResult = indicatorResultService.getIndicatorResultPage(pageReqVO);

        // 断言
        assertEquals(1, pageResult.getTotal());
        assertEquals(1, pageResult.getList().size());
        assertPojoEquals(dbResult, pageResult.getList().get(0));
    }

    @Test
    public void testGetIndicatorResultCountByQcIdAndType() {
        // mock 数据
        MesQcIndicatorResultDO result1 = randomPojo(MesQcIndicatorResultDO.class, o -> {
            o.setQcId(1L);
            o.setQcType(MesQcTypeEnum.IQC.getType());
        });
        resultMapper.insert(result1);
        MesQcIndicatorResultDO result2 = randomPojo(MesQcIndicatorResultDO.class, o -> {
            o.setQcId(1L);
            o.setQcType(MesQcTypeEnum.IQC.getType());
        });
        resultMapper.insert(result2);
        // 不匹配
        resultMapper.insert(randomPojo(MesQcIndicatorResultDO.class, o -> {
            o.setQcId(2L);
            o.setQcType(MesQcTypeEnum.IPQC.getType());
        }));

        // 调用
        Long count = indicatorResultService.getIndicatorResultCountByQcIdAndType(1L, MesQcTypeEnum.IQC.getType());

        // 断言
        assertEquals(2L, count);
    }

    @Test
    public void testValidateIndicatorResultExistsByQcIdAndType_success() {
        // mock 数据
        resultMapper.insert(randomPojo(MesQcIndicatorResultDO.class, o -> {
            o.setQcId(1L);
            o.setQcType(MesQcTypeEnum.IQC.getType());
        }));

        // 调用（不抛异常即通过）
        indicatorResultService.validateIndicatorResultExistsByQcIdAndType(1L, MesQcTypeEnum.IQC.getType());
    }

    @Test
    public void testValidateIndicatorResultExistsByQcIdAndType_notExists() {
        // 调用，并断言异常
        assertServiceException(
                () -> indicatorResultService.validateIndicatorResultExistsByQcIdAndType(randomLongId(), MesQcTypeEnum.IQC.getType()),
                QC_FINISH_INDICATOR_RESULT_REQUIRED);
    }

    // ==================== 辅助方法 ====================

    private void mockIqcAndIndicator(MesQcIndicatorResultSaveReqVO reqVO, Integer resultType) {
        MesQcIqcDO iqc = new MesQcIqcDO();
        iqc.setId(reqVO.getQcId());
        iqc.setItemId(100L);
        when(iqcService.validateIqcExists(reqVO.getQcId())).thenReturn(iqc);

        MesQcIndicatorDO indicator = new MesQcIndicatorDO();
        indicator.setId(reqVO.getItems().get(0).getIndicatorId());
        indicator.setName("检测项A");
        indicator.setResultType(resultType);
        when(indicatorService.validateIndicatorListExists(anySet()))
                .thenReturn(MapUtil.of(indicator.getId(), indicator));
    }

    private MesQcIndicatorResultSaveReqVO buildReqVO(String value, Integer resultType) {
        MesQcIndicatorResultSaveReqVO.Item item = new MesQcIndicatorResultSaveReqVO.Item();
        item.setIndicatorId(10L);
        item.setValue(value);

        MesQcIndicatorResultSaveReqVO reqVO = new MesQcIndicatorResultSaveReqVO();
        reqVO.setCode("SPL-001");
        reqVO.setQcId(1L);
        reqVO.setQcType(MesQcTypeEnum.IQC.getType());
        reqVO.setItems(ListUtil.of(item));
        return reqVO;
    }

}