package com.docus.demo.service;


import cn.hutool.core.util.ObjectUtil;
import com.docus.demo.dto.SyncBasicDataDto;
import com.docus.demo.entity.CommonResult;
import com.docus.demo.entity.Tbasic;
import com.docus.demo.entity.TbasicSub;
import com.docus.demo.entity.sqlserver.CardInfo;
import com.docus.demo.entity.sqlserver1.Tdiagnose;
import com.docus.demo.entity.sqlserver1.Toperation;
import com.docus.demo.entity.sqlserver1.Tpatientvisit;
import com.docus.demo.facade.ISyncBasicDataService;
import com.docus.demo.mapper.mysql.BasicMapper;
import com.docus.demo.mapper.sqlserver.TcardMapper;
import com.docus.demo.mapper.sqlserver1.PaintVisitMapper;
import com.docus.demo.utils.SnowflakeIdWorker;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.Collectors;

@Slf4j
@Service
public class SyncBasicDataImpl implements ISyncBasicDataService {
    @Autowired
    private BasicMapper basicMapper;

    @Autowired
    private PaintVisitMapper paintVisitMapper;
    @Autowired
    private TcardMapper tcardMapper;

    private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
//    private final ExecutorService executor = Executors.newFixedThreadPool(7);

    @Override
    public CommonResult<?> syncBasicData(SyncBasicDataDto syncBasicDataDto) {

        LocalDate startDate = LocalDate.parse(syncBasicDataDto.getStartDate());
        LocalDate endDate = LocalDate.parse(syncBasicDataDto.getEndDate());


        //每页1000条数据

        List<Tpatientvisit> tpatientvisitList;
        for (int current = 1; ; current++) {
            syncBasicDataDto.setStartDate(startDate+" 00:00:00");
            syncBasicDataDto.setEndDate(startDate.plusDays(1)+" 23:59:59");

            log.info(syncBasicDataDto.getStartDate()+" --- " +syncBasicDataDto.getEndDate());
            //根据出院时间查询省厅数据
            tpatientvisitList = paintVisitMapper.getTpatientVisitList(0, 0, syncBasicDataDto);
            log.info("开始同步"+tpatientvisitList.size());
//            tpatientvisitList = paintVisitMapper.getTpatientVisitList((current - 1) * limit, current*limit, syncBasicDataDto);

            List<String> fprnList = tpatientvisitList.stream().map(Tpatientvisit::getFprn).collect(Collectors.toList());
            //诊断数据
            List<Tdiagnose> tdiagnoses = paintVisitMapper.getTdiagnose(fprnList);
            List<Toperation> toperations = paintVisitMapper.getToperation(fprnList);
            //数据map转换
            List<Tbasic> oldBasicList = basicMapper.getOldBasicList(fprnList, syncBasicDataDto);
            List<Tbasic> tbasicList = this.getTbasicList(oldBasicList, tpatientvisitList, tdiagnoses, toperations);

            List<TbasicSub> tbasicSubList = this.getTbasicSubList(tbasicList);

            //数据入库
            basicMapper.insertOrUpdateByid(tbasicList);
            basicMapper.insertOrUpdateTbasicSub(tbasicSubList);
            log.info("数据库入库"+tbasicList.size() +"子表"+tbasicSubList.size());

            if (startDate.compareTo(endDate)>0) {
                break;
            }
            startDate = startDate.plusDays(10);
        }
        return CommonResult.success("同步成功");
    }

    private List<TbasicSub> getTbasicSubList(List<Tbasic> tbasicList) {
        return tbasicList.stream().map(m->{
            TbasicSub tbasicSub = new TbasicSub();
            tbasicSub.setBirthday(m.getBirthday());
            tbasicSub.setPatientId(m.getPatientId());
        return tbasicSub;
        }).collect(Collectors.toList());
    }


    private List<Tbasic> getTbasicList(List<Tbasic> oldBasicList, List<Tpatientvisit> tpatientvisitList, List<Tdiagnose> tdiagnoses, List<Toperation> toperations) {

        // 根据病案号 住院次数 名称  做去重判断

        return tpatientvisitList.stream().map(m -> {
                    Tbasic oldBasic = oldBasicList.stream()
                            .filter(old -> ObjectUtil.equal(m.getFprn(), old.getInpatientNo())
                                    && ObjectUtil.equal(m.getFtimes(), old.getAdmissTimes())
                                    && ObjectUtil.equal(m.getFname(), old.getName())
                            )
                            .findFirst()
                            .orElse(null);


                    String fprn = m.getFprn();
                    Integer ftimes = m.getFtimes();

                    Tdiagnose tdiagnose = tdiagnoses.stream()
                            .filter(f -> ObjectUtil.equal(f.getFprn(), fprn)
                                    && ObjectUtil.equal(f.getFtimes(), ftimes)
                                    && ObjectUtil.equal(f.getFzdlx(), "1")
                            )
                            .findFirst()
                            .orElse(null);

                    Toperation toperation = toperations.stream()
                            .filter(f -> ObjectUtil.equal(f.getFprn(), fprn)
                                    && ObjectUtil.equal(f.getFtimes(), ftimes)
                                    && ObjectUtil.equal(f.getFpx(), 1L)
                            )
                            .findFirst()
                            .orElse(null);

                    Tbasic tbasic = new Tbasic();
                    if (oldBasic!=null){
                        tbasic.setPatientId(oldBasic.getPatientId());
                    }else {
                        tbasic.setPatientId(String.valueOf(SnowflakeIdWorker.idWorker.nextId()));
                    }
                    tbasic.setAdmissTimes(m.getFtimes());
                    tbasic.setInpatientNo(m.getFprn());
                    tbasic.setName(m.getFname());
                    tbasic.setSex(m.getFsexbh());
                    tbasic.setSexName(m.getFsex());
                    if (m.getFage().contains("Y")){
                        tbasic.setAge(Integer.valueOf(m.getFage().split("Y")[1]));
                    }else if (m.getFage().contains("M")){
                        tbasic.setAgeMonth(Integer.valueOf(m.getFage().split("M")[1]));
                    }else if (m.getFage().contains("D")){
                        tbasic.setAgeDay(Integer.valueOf(m.getFage().split("D")[1]));
                    }

                    tbasic.setIdCard(m.getFidcard());
                    tbasic.setTelphone("");
                    tbasic.setAdmissDate(m.getFrydate());
                    tbasic.setAdmissDept(m.getFrytykh());
                    tbasic.setAdmissDeptName(m.getFrydept());
                    tbasic.setDisDate(m.getFcydate());
                    tbasic.setDisDept(m.getFcytykh());
                    tbasic.setDisDeptName(m.getFcydept());
                    tbasic.setAdmissDays(m.getFdays());
                    tbasic.setAttending(m.getFzzdoctbh());
                    tbasic.setAttendingName(m.getFzzdoct());
                    tbasic.setBirthday(m.getFbirthday());
                    if (tdiagnose != null) {
                        tbasic.setMainDiagCode(tdiagnose.getFicdm());
                        tbasic.setMainDiagName(tdiagnose.getFjbname());
                    }
                    if (toperation != null) {
                        tbasic.setMainOperateCode(toperation.getFopcode());
                        tbasic.setMainOperateName(toperation.getFop());
                    }
//                    tbasic.setIsDead(m.getFbody());
                    tbasic.setCreateTime(new Date());
                    tbasic.setSexName(m.getFsex());
                    tbasic.setArchiveFileStorageType(2);
                    tbasic.setScanUploadState(0);
                    tbasic.setIsArchive(1);

                    return tbasic;
                }).collect(Collectors.toList());
    }


    @Override
    public CommonResult<?> syncLzBasicData(SyncBasicDataDto syncBasicDataDto) {

//        executor.execute(()->{
            //页码
            int current;
            //每页1000条数据
            int limit = syncBasicDataDto.getLimit();
            List<CardInfo> cardInfoList;
            for (current = 1; ; current++) {
                cardInfoList = tcardMapper.getCardInfo((current - 1) * limit, current * limit, syncBasicDataDto);
                if (null == cardInfoList || cardInfoList.size() == 0) {
                    break;
                }
                log.info(syncBasicDataDto.getStartDate() + "  " + syncBasicDataDto.getEndDate() + "开始同步" + cardInfoList.size());
                List<String> fprnList = cardInfoList.stream().map(CardInfo::getPatNo).collect(Collectors.toList());
                //数据map转换
                List<Tbasic> oldBasicList = basicMapper.getOldBasicList(fprnList, syncBasicDataDto);
                log.info("获取到旧数据"+oldBasicList.size());
                List<Tbasic> tbasicList = this.getInsertTbasic(oldBasicList, cardInfoList);
                if (ObjectUtil.isNotEmpty(tbasicList)) {
                    //判断数据量 如果文件数据大于五百条 需要做拆分分批次插入
                    int batchSize = 1000;
                    // 拆分列表
                    for (int i = 0; i < tbasicList.size(); i += batchSize) {
                        int endIndex = Math.min(i + batchSize, tbasicList.size());
                        List<Tbasic> sublist = tbasicList.subList(i, endIndex);
                        //数据入库
                        basicMapper.insertOrUpdateByid(sublist);
                        log.info("数据入库"+sublist.size());
                    }
                }
            }
            log.info(syncBasicDataDto.getStartDate() + "  " + syncBasicDataDto.getEndDate() + "结束同步" );
//        });


        return CommonResult.success("同步成功");
    }

    private List<Tbasic> getInsertTbasic(List<Tbasic> oldBasicList, List<CardInfo> cardInfoList) {

        List<CardInfo> cardInfos = cardInfoList.stream().filter(f -> {
            //根据病案号 名称 住院次数 出院时间 去重
            String pno = f.getPatNo();
            String name = f.getPatName();
            Integer pNum = f.getPatNum();

            Tbasic tbasic = oldBasicList.stream().filter(o ->
                            ObjectUtil.equal(pno, o.getInpatientNo())
                                    && ObjectUtil.equal(name, o.getName())
                                    && ObjectUtil.equal(pNum, o.getAdmissTimes())
                                    )
                    .findAny()
                    .orElse(null);

            return tbasic == null;
        }).collect(Collectors.toList());

        List<Tbasic> tbasicList = cardInfos.stream().map(m -> {

            Tbasic tbasic = new Tbasic();
            tbasic.setPatientId(String.valueOf(SnowflakeIdWorker.idWorker.nextId()));
            tbasic.setAdmissTimes(m.getPatNum());
            tbasic.setInpatientNo(m.getPatNo());
            tbasic.setAdmissId(m.getPatNo());
            tbasic.setName(m.getPatName());
            tbasic.setSex(m.getPatSex());
            tbasic.setAge(m.getPatAge());
            tbasic.setIdCard(m.getPatCiticard());
            tbasic.setAdmissDate(m.getInDate());
            tbasic.setAdmissDept(m.getInDeptCode());
            tbasic.setAdmissDeptName(m.getInDeptName());
            tbasic.setDisDate(m.getOutDate());
            tbasic.setDisDept(m.getOutDeptCode());
            tbasic.setDisDeptName(m.getOutDeptName());
            tbasic.setMainDiagName(m.getIcdeName11());
            tbasic.setMainDiagCode(m.getIcdeCode11());
            tbasic.setMainOperateName(m.getOperName1());
            tbasic.setMainOperateCode(m.getOperIcpm1());
            tbasic.setBColumn5(m.getCuid());
            tbasic.setBColumn8(1);
            tbasic.setIsArchive(1);
            tbasic.setArchiveFileStorageType(2);
            tbasic.setCreateTime(new Date());
            tbasic.setFileSource(2);
            return tbasic;
        }).collect(Collectors.toList());

        return tbasicList;
    }

}