package jnpf.dmsService;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import jnpf.dmsEntity.DmsDanganCundangShenqingEntity;
import jnpf.dmsEntity.DmsDanganCundangShenqingDanganheEntity;
import jnpf.dmsEntity.form.DmsDanganCundangJieshouDanganheForm;
import jnpf.dmsEntity.form.DmsDanganCundangJieshouForm;
import jnpf.dmsMapper.DmsDanganCundangShenqingDanganheMapper;
import jnpf.dmsMapper.DmsDanganCundangShenqingMapper;
import jnpf.dmsService.impl.DmsDanganCundangJieshouServiceImpl;
import jnpf.exception.DataException;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import org.mockito.ArgumentCaptor;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.apache.ibatis.session.Configuration;

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

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
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 DmsDanganCundangJieshouServiceTest {

    @BeforeEach
    void setUp() {
        if (TableInfoHelper.getTableInfo(DmsDanganCundangShenqingDanganheEntity.class) == null) {
            TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new Configuration(), ""),
                    DmsDanganCundangShenqingDanganheEntity.class);
        }
        if (TableInfoHelper.getTableInfo(DmsDanganCundangShenqingEntity.class) == null) {
            TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new Configuration(), ""),
                    DmsDanganCundangShenqingEntity.class);
        }
    }

    @Test
    void receivesEveryRequestedDanganheInOneConditionalUpdate() throws Exception {
        DmsDanganCundangShenqingDanganheMapper mapper = mock(DmsDanganCundangShenqingDanganheMapper.class);
        when(mapper.selectList(any())).thenReturn(Arrays.asList(danganhe("box-1", null), danganhe("box-2", "")));
        when(mapper.update(isNull(), any())).thenReturn(2);
        DmsDanganCundangJieshouService service = service(mapper);

        service.jieshou(form(item("box-1", "box-1"), item("box-2", "box-2")));

        ArgumentCaptor<Wrapper<DmsDanganCundangShenqingDanganheEntity>> captor = ArgumentCaptor.forClass(Wrapper.class);
        verify(mapper).update(isNull(), captor.capture());
        com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper<?> update =
                (com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper<?>) captor.getValue();
        String sqlSet = update.getSqlSet();
        assertTrue(sqlSet.contains("jieshou_ren"));
        assertTrue(sqlSet.contains("yijiao_ren"));
        assertTrue(sqlSet.contains("biz_sign"));
        assertTrue(sqlSet.contains("biz_review_sign"));
        assertTrue(sqlSet.contains("jieshou_riqi"));
        assertTrue(update.getParamNameValuePairs().containsValue("receiver-1"));
        assertTrue(update.getParamNameValuePairs().containsValue("reviewer-1"));
        assertTrue(update.getParamNameValuePairs().containsValue("sign-1"));
        assertTrue(update.getParamNameValuePairs().containsValue("review-sign-1"));
        assertNotNull(update.getParamNameValuePairs().values().stream()
                .filter(Date.class::isInstance)
                .findFirst()
                .orElse(null));
    }

    @Test
    void rejectsWhenAnyDanganheHasAlreadyBeenReceived() {
        DmsDanganCundangShenqingDanganheMapper mapper = mock(DmsDanganCundangShenqingDanganheMapper.class);
        when(mapper.selectList(any())).thenReturn(Arrays.asList(danganhe("box-1", null), danganhe("box-2", "receiver-0")));
        DmsDanganCundangJieshouService service = service(mapper);

        DataException error = assertThrows(DataException.class,
                () -> service.jieshou(form(item("box-1", "box-1"), item("box-2", "box-2"))));

        assertEquals("档案盒已接收，不能重复接收", error.getMessage());
        verify(mapper, never()).update(any(), any());
    }

    @Test
    void rollsBackWhenAnotherRequestReceivesARecordBeforeTheUpdate() {
        DmsDanganCundangShenqingDanganheMapper mapper = mock(DmsDanganCundangShenqingDanganheMapper.class);
        when(mapper.selectList(any())).thenReturn(Arrays.asList(danganhe("box-1", null), danganhe("box-2", null)));
        when(mapper.update(isNull(), any())).thenReturn(1);
        DmsDanganCundangJieshouService service = service(mapper);

        DataException error = assertThrows(DataException.class,
                () -> service.jieshou(form(item("box-1", "box-1"), item("box-2", "box-2"))));

        assertEquals("档案盒已接收，不能重复接收", error.getMessage());
    }

    @Test
    void checkSucceedsForAnApprovedUnreceivedDanganhe() throws Exception {
        DmsDanganCundangShenqingDanganheMapper danganheMapper = mock(DmsDanganCundangShenqingDanganheMapper.class);
        DmsDanganCundangShenqingMapper shenqingMapper = mock(DmsDanganCundangShenqingMapper.class);
        when(danganheMapper.selectList(any())).thenReturn(Arrays.asList(danganhe("box-1", null, "shenqing-1")));
        when(shenqingMapper.selectOne(any())).thenReturn(shenqing("shenqing-1", 2));
        DmsDanganCundangJieshouService service = new DmsDanganCundangJieshouServiceImpl(
                danganheMapper, shenqingMapper);

        DmsDanganCundangShenqingDanganheEntity result = service.check("box-1");

        assertEquals("box-1", result.getId());
        verify(danganheMapper).selectList(any());
        verify(shenqingMapper).selectOne(any());
    }

    @Test
    void checkRejectsUnknownDanganheBeforeCheckingApplication() {
        DmsDanganCundangShenqingDanganheMapper danganheMapper = mock(DmsDanganCundangShenqingDanganheMapper.class);
        DmsDanganCundangShenqingMapper shenqingMapper = mock(DmsDanganCundangShenqingMapper.class);
        when(danganheMapper.selectList(any())).thenReturn(Arrays.asList());
        DmsDanganCundangJieshouService service = new DmsDanganCundangJieshouServiceImpl(
                danganheMapper, shenqingMapper);

        DataException error = assertThrows(DataException.class, () -> service.check("missing-box"));

        assertEquals("未找到对应的档案盒记录", error.getMessage());
        verify(shenqingMapper, never()).selectOne(any());
    }

    @Test
    void checkRejectsApplicationThatHasNotPassed() {
        DmsDanganCundangShenqingDanganheMapper danganheMapper = mock(DmsDanganCundangShenqingDanganheMapper.class);
        DmsDanganCundangShenqingMapper shenqingMapper = mock(DmsDanganCundangShenqingMapper.class);
        when(danganheMapper.selectList(any())).thenReturn(Arrays.asList(danganhe("box-1", null, "shenqing-1")));
        when(shenqingMapper.selectOne(any())).thenReturn(shenqing("shenqing-1", 1));
        DmsDanganCundangJieshouService service = new DmsDanganCundangJieshouServiceImpl(
                danganheMapper, shenqingMapper);

        DataException error = assertThrows(DataException.class, () -> service.check("box-1"));

        assertEquals("档案存档申请尚未审批通过，无法接收", error.getMessage());
    }

    @Test
    void checkRejectsDanganheThatHasAlreadyBeenReceived() {
        DmsDanganCundangShenqingDanganheMapper danganheMapper = mock(DmsDanganCundangShenqingDanganheMapper.class);
        DmsDanganCundangShenqingMapper shenqingMapper = mock(DmsDanganCundangShenqingMapper.class);
        when(danganheMapper.selectList(any())).thenReturn(Arrays.asList(danganhe("box-1", "receiver-0", "shenqing-1")));
        when(shenqingMapper.selectOne(any())).thenReturn(shenqing("shenqing-1", 2));
        DmsDanganCundangJieshouService service = new DmsDanganCundangJieshouServiceImpl(
                danganheMapper, shenqingMapper);

        DataException error = assertThrows(DataException.class, () -> service.check("box-1"));

        assertEquals("档案盒已接收，不能重复接收", error.getMessage());
    }

    private DmsDanganCundangJieshouService service(DmsDanganCundangShenqingDanganheMapper danganheMapper) {
        return new DmsDanganCundangJieshouServiceImpl(danganheMapper,
                mock(DmsDanganCundangShenqingMapper.class));
    }

    private DmsDanganCundangJieshouForm form(DmsDanganCundangJieshouDanganheForm... danganhe) {
        DmsDanganCundangJieshouForm form = new DmsDanganCundangJieshouForm();
        form.setDanganheXinxi(Arrays.asList(danganhe));
        form.setBizUserId("receiver-1");
        form.setBizReviewUser("reviewer-1");
        form.setBizSign("sign-1");
        form.setBizReviewSign("review-sign-1");
        return form;
    }

    private DmsDanganCundangJieshouDanganheForm item(String id, String fId) {
        DmsDanganCundangJieshouDanganheForm item = new DmsDanganCundangJieshouDanganheForm();
        item.setId(id);
        item.setFId(fId);
        return item;
    }

    private DmsDanganCundangShenqingDanganheEntity danganhe(String id, String jieshouRen) {
        return danganhe(id, jieshouRen, null);
    }

    private DmsDanganCundangShenqingDanganheEntity danganhe(String id, String jieshouRen, String foreignId) {
        DmsDanganCundangShenqingDanganheEntity result = new DmsDanganCundangShenqingDanganheEntity();
        result.setId(id);
        result.setJieshouRen(jieshouRen);
        result.setForeignId(foreignId);
        result.setJieshouRiqi(new Date());
        return result;
    }

    private DmsDanganCundangShenqingEntity shenqing(String id, Integer flowState) {
        DmsDanganCundangShenqingEntity result = new DmsDanganCundangShenqingEntity();
        result.setId(id);
        result.setFlowState(flowState);
        return result;
    }
}