package jnpf.dmsService;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import jnpf.dmsEntity.DmsWenjianFushenJihuaFenpeiEntity;
import jnpf.dmsEntity.DmsWenjianFushenJihuaFenpeiZixiangEntity;
import jnpf.dmsMapper.DmsWenjianFushenJihuaFenpeiMapper;
import jnpf.dmsMapper.DmsWenjianFushenJihuaFenpeiZixiangMapper;
import jnpf.dmsService.impl.DmsWenjianFushenJihuaFenpeiSyncServiceImpl;
import jnpf.exception.DataException;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.apache.ibatis.session.Configuration;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;

import java.util.Arrays;
import java.util.Date;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

class DmsWenjianFushenJihuaFenpeiSyncServiceTest {

    @BeforeEach
    void setUp() {
        initTableInfo(DmsWenjianFushenJihuaFenpeiEntity.class);
        initTableInfo(DmsWenjianFushenJihuaFenpeiZixiangEntity.class);
    }

    @Test
    void syncsEveryChildWithTheAssignmentValuesFromThePlan() throws Exception {
        DmsWenjianFushenJihuaFenpeiMapper fenpeiMapper = mock(DmsWenjianFushenJihuaFenpeiMapper.class);
        DmsWenjianFushenJihuaFenpeiZixiangMapper zixiangMapper = mock(
                DmsWenjianFushenJihuaFenpeiZixiangMapper.class);
        Date assignedAt = new Date();
        when(fenpeiMapper.selectOne(any())).thenReturn(fenpei("dept-1", "user-1", assignedAt));
        DmsWenjianFushenJihuaFenpeiSyncService service = service(fenpeiMapper, zixiangMapper);

        service.sync("plan-1");

        ArgumentCaptor<Wrapper<DmsWenjianFushenJihuaFenpeiZixiangEntity>> captor = ArgumentCaptor.forClass(
                Wrapper.class);
        verify(zixiangMapper).update(isNull(), captor.capture());
        LambdaUpdateWrapper<?> update = (LambdaUpdateWrapper<?>) captor.getValue();
        assertTrue(update.getSqlSet().contains("fenpei_bumen_id"));
        assertTrue(update.getSqlSet().contains("fenpei_bumen_fuzeren"));
        assertTrue(update.getSqlSet().contains("fenpei_riqi"));
        assertTrue(update.getSqlSet().contains("biz_status"));
        assertTrue(update.getExpression().getNormal().getSqlSegment().contains("f_foreign_id"));
        assertTrue(update.getExpression().getNormal().getSqlSegment().contains("f_delete_mark"));
        assertTrue(update.getParamNameValuePairs().containsValue("plan-1"));
        assertTrue(update.getParamNameValuePairs().containsValue("dept-1"));
        assertTrue(update.getParamNameValuePairs().containsValue("user-1"));
        assertTrue(update.getParamNameValuePairs().containsValue(assignedAt));
        assertTrue(update.getParamNameValuePairs().containsValue("daizhixing"));
    }

    @Test
    void reassignsMatchingChildrenFromOtherPlansWithoutDeletingThem() throws Exception {
        DmsWenjianFushenJihuaFenpeiMapper fenpeiMapper = mock(DmsWenjianFushenJihuaFenpeiMapper.class);
        DmsWenjianFushenJihuaFenpeiZixiangMapper zixiangMapper = mock(
                DmsWenjianFushenJihuaFenpeiZixiangMapper.class);
        Date assignedAt = new Date();
        when(fenpeiMapper.selectOne(any())).thenReturn(fenpei("dept-1", "owner-1", assignedAt));
        Date huiguShixian = new Date();
        when(zixiangMapper.selectList(any())).thenReturn(
                Arrays.asList(child("new-detail-1", "file-1", huiguShixian)),
                Arrays.asList(child("existing-detail-1", "file-1", huiguShixian)));
        DmsWenjianFushenJihuaFenpeiSyncService service = service(fenpeiMapper, zixiangMapper);

        service.sync("plan-1");

        ArgumentCaptor<Wrapper<DmsWenjianFushenJihuaFenpeiZixiangEntity>> captor = ArgumentCaptor.forClass(
                Wrapper.class);
        verify(zixiangMapper, org.mockito.Mockito.times(2)).update(isNull(), captor.capture());
        List<Wrapper<DmsWenjianFushenJihuaFenpeiZixiangEntity>> updates = captor.getAllValues();
        LambdaUpdateWrapper<?> reassignmentUpdate = (LambdaUpdateWrapper<?>) updates.get(0);
        assertTrue(reassignmentUpdate.getSqlSet().contains("huigu_ren"));
        assertTrue(reassignmentUpdate.getSqlSet().contains("fenpei_bumen_id"));
        assertTrue(reassignmentUpdate.getSqlSet().contains("fenpei_bumen_fuzeren"));
        assertTrue(reassignmentUpdate.getSqlSet().contains("fenpei_riqi"));
        assertTrue(reassignmentUpdate.getSqlSet().contains("biz_status"));
        assertTrue(reassignmentUpdate.getExpression().getNormal().getSqlSegment().contains("f_id"));
        assertTrue(reassignmentUpdate.getParamNameValuePairs().containsValue("existing-detail-1"));
        assertTrue(reassignmentUpdate.getParamNameValuePairs().containsValue("dept-1"));
        assertTrue(reassignmentUpdate.getParamNameValuePairs().containsValue("owner-1"));
        assertTrue(reassignmentUpdate.getParamNameValuePairs().containsValue(assignedAt));
        assertTrue(reassignmentUpdate.getParamNameValuePairs().containsValue("daizhixing"));
        verify(zixiangMapper).deleteById("new-detail-1");
    }

    @Test
    void doesNotUpdateChildrenWhenThePlanDoesNotExist() {
        DmsWenjianFushenJihuaFenpeiMapper fenpeiMapper = mock(DmsWenjianFushenJihuaFenpeiMapper.class);
        DmsWenjianFushenJihuaFenpeiZixiangMapper zixiangMapper = mock(
                DmsWenjianFushenJihuaFenpeiZixiangMapper.class);
        when(fenpeiMapper.selectOne(any())).thenReturn(null);
        DmsWenjianFushenJihuaFenpeiSyncService service = service(fenpeiMapper, zixiangMapper);

        DataException error = assertThrows(DataException.class, () -> service.sync("missing-plan"));

        assertEquals("未找到文件复审计划分配记录：f_id=missing-plan", error.getMessage());
        verify(zixiangMapper, never()).update(any(), any());
    }

    private DmsWenjianFushenJihuaFenpeiSyncService service(
            DmsWenjianFushenJihuaFenpeiMapper fenpeiMapper,
            DmsWenjianFushenJihuaFenpeiZixiangMapper zixiangMapper) {
        return new DmsWenjianFushenJihuaFenpeiSyncServiceImpl(fenpeiMapper, zixiangMapper);
    }

    private DmsWenjianFushenJihuaFenpeiEntity fenpei(String departmentId, String owner, Date assignedAt) {
        DmsWenjianFushenJihuaFenpeiEntity result = new DmsWenjianFushenJihuaFenpeiEntity();
        result.setFenpeiBumenId(departmentId);
        result.setFenpeiBumenFuzeren(owner);
        result.setFenpeiRiqi(assignedAt);
        return result;
    }

    private DmsWenjianFushenJihuaFenpeiZixiangEntity child(String id, String wenjianId, Date huiguShixian) {
        DmsWenjianFushenJihuaFenpeiZixiangEntity result = new DmsWenjianFushenJihuaFenpeiZixiangEntity();
        result.setId(id);
        result.setWenjianId(wenjianId);
        result.setHuiguShixian(huiguShixian);
        return result;
    }

    private void initTableInfo(Class<?> entityClass) {
        if (TableInfoHelper.getTableInfo(entityClass) == null) {
            TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new Configuration(), ""), entityClass);
        }
    }
}