package com.ruoyi.quality.controller;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.framework.web.domain.AjaxResult;
import com.ruoyi.quality.dto.QualityMetricDto;
import com.ruoyi.quality.mapper.QualityTestStandardBindingMapper;
import com.ruoyi.quality.mapper.QualityTestStandardParamMapper;
import com.ruoyi.quality.pojo.QualityTestStandard;
import com.ruoyi.quality.pojo.QualityTestStandardBinding;
import com.ruoyi.quality.pojo.QualityTestStandardParam;
import com.ruoyi.quality.service.IQualityTestStandardService;
import com.ruoyi.quality.service.QualityTestStandardBindingService;
import com.ruoyi.quality.service.QualityTestStandardParamService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.util.Arrays;
import java.util.Collections;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class QualityMetricControllerTest {

    @Mock
    private QualityTestStandardParamMapper paramMapper;
    @Mock
    private QualityTestStandardParamService paramService;
    @Mock
    private QualityTestStandardBindingService bindingService;
    @Mock
    private IQualityTestStandardService standardService;
    @Mock
    private QualityTestStandardBindingMapper bindingMapper;

    private QualityMetricController controller;

    @BeforeEach
    void setUp() {
        controller = new QualityMetricController(paramMapper, paramService,
                bindingService, standardService, bindingMapper);
    }

    @Test
    void addCreatesStandardAndBindingForFirstMetric() {
        QualityMetricDto metric = metric(10L, null, "硬度", "HRC", "50-55", "51-54");
        when(bindingService.list(any(Wrapper.class))).thenReturn(Collections.emptyList());
        when(standardService.save(any(QualityTestStandard.class))).thenAnswer(invocation -> {
            QualityTestStandard standard = invocation.getArgument(0);
            standard.setId(100L);
            return true;
        });
        when(bindingService.save(any(QualityTestStandardBinding.class))).thenReturn(true);
        when(paramService.save(any(QualityTestStandardParam.class))).thenReturn(true);

        AjaxResult result = controller.add(metric);

        assertTrue(result.isSuccess());
        ArgumentCaptor<QualityTestStandardBinding> bindingCaptor =
                ArgumentCaptor.forClass(QualityTestStandardBinding.class);
        verify(bindingService).save(bindingCaptor.capture());
        assertEquals(10L, bindingCaptor.getValue().getProductId());
        assertEquals(100, bindingCaptor.getValue().getTestStandardId());

        ArgumentCaptor<QualityTestStandardParam> parameterCaptor =
                ArgumentCaptor.forClass(QualityTestStandardParam.class);
        verify(paramService).save(parameterCaptor.capture());
        assertEquals(100L, parameterCaptor.getValue().getTestStandardId());
        assertEquals("硬度", parameterCaptor.getValue().getParameterItem());
        assertEquals("50-55", parameterCaptor.getValue().getStandardValue());
    }

    @Test
    void addReusesExistingProductBinding() {
        QualityTestStandardBinding existing = new QualityTestStandardBinding();
        existing.setProductId(10L);
        existing.setTestStandardId(88);
        when(bindingService.list(any(Wrapper.class))).thenReturn(Collections.singletonList(existing));
        QualityTestStandard matched = new QualityTestStandard();
        matched.setId(88L);
        matched.setInspectType(0);
        when(standardService.getOne(any(Wrapper.class))).thenReturn(matched);
        when(paramService.save(any(QualityTestStandardParam.class))).thenReturn(true);

        AjaxResult result = controller.add(metric(10L, null, "长度", "mm", "100", "99-101"));

        assertTrue(result.isSuccess());
        verify(standardService, never()).save(any(QualityTestStandard.class));
        verify(bindingService, never()).save(any(QualityTestStandardBinding.class));
        ArgumentCaptor<QualityTestStandardParam> captor =
                ArgumentCaptor.forClass(QualityTestStandardParam.class);
        verify(paramService).save(captor.capture());
        assertEquals(88L, captor.getValue().getTestStandardId());
    }

    @Test
    void addRejectsMissingProductWithoutWritingData() {
        AjaxResult result = controller.add(metric(null, null, "长度", "mm", "100", null));

        assertTrue(result.isError());
        assertEquals("请先选择产品", result.get(AjaxResult.MSG_TAG));
        verify(standardService, never()).save(any(QualityTestStandard.class));
        verify(paramService, never()).save(any(QualityTestStandardParam.class));
    }

    @Test
    void updateChangesOnlyEditableMetricFields() {
        QualityTestStandardParam stored = new QualityTestStandardParam();
        stored.setId(5L);
        stored.setTestStandardId(88L);
        stored.setParameterItem("旧指标");
        when(paramService.getById(5L)).thenReturn(stored);
        when(paramService.updateById(any(QualityTestStandardParam.class))).thenReturn(true);

        AjaxResult result = controller.update(metric(null, 5L, "新指标", "mm", "20", "19-21"));

        assertTrue(result.isSuccess());
        ArgumentCaptor<QualityTestStandardParam> captor =
                ArgumentCaptor.forClass(QualityTestStandardParam.class);
        verify(paramService).updateById(captor.capture());
        assertSame(stored, captor.getValue());
        assertEquals(88L, stored.getTestStandardId());
        assertEquals("新指标", stored.getParameterItem());
        assertEquals("20", stored.getStandardValue());
    }

    @Test
    void updateReportsMissingMetric() {
        when(paramService.getById(99L)).thenReturn(null);

        AjaxResult result = controller.update(metric(null, 99L, "指标", "mm", "1", null));

        assertTrue(result.isError());
        assertEquals("检测指标不存在", result.get(AjaxResult.MSG_TAG));
        verify(paramService, never()).updateById(any(QualityTestStandardParam.class));
    }

    @Test
    void deleteRejectsEmptySelectionAndDeletesSelectedMetrics() {
        AjaxResult emptyResult = controller.delete(Collections.emptyList());
        assertTrue(emptyResult.isError());
        verify(paramService, never()).removeBatchByIds(any());

        when(paramService.removeBatchByIds(Arrays.asList(1L, 2L))).thenReturn(true);
        AjaxResult deleteResult = controller.delete(Arrays.asList(1L, 2L));
        assertTrue(deleteResult.isSuccess());
    }

    @Test
    void listByProductReturnsMapperData() {
        QualityTestStandardParam parameter = new QualityTestStandardParam();
        parameter.setId(1L);
        when(paramMapper.selectListByProductId(10L, 0, null)).thenReturn(Collections.singletonList(parameter));

        AjaxResult result = controller.listByProduct(10L, 0, null);

        assertTrue(result.isSuccess());
        assertEquals(Collections.singletonList(parameter), result.get(AjaxResult.DATA_TAG));
    }

    @Test
    void listPageReturnsPagedMapperData() {
        Page<QualityTestStandardParam> expected = new Page<>(1, 10);
        expected.setRecords(Collections.singletonList(new QualityTestStandardParam()));
        when(paramMapper.selectPageByProductId(any(Page.class), any(Long.class), any(), any()))
                .thenReturn(expected);

        AjaxResult result = controller.listPage(new Page<>(1, 10), 10L, 0, null);

        assertTrue(result.isSuccess());
        assertSame(expected, result.get(AjaxResult.DATA_TAG));
        assertFalse(expected.getRecords().isEmpty());
    }

    private QualityMetricDto metric(Long productId, Long id, String name,
                                    String unit, String standardValue, String controlValue) {
        QualityMetricDto metric = new QualityMetricDto();
        metric.setProductId(productId);
        metric.setId(id);
        metric.setParameterItem(name);
        metric.setUnit(unit);
        metric.setStandardValue(standardValue);
        metric.setControlValue(controlValue);
        return metric;
    }
}