package com.ruoyi.project.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.core.domain.entity.SysRole;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.exception.base.BaseException;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.project.domain.*;
import com.ruoyi.project.domain.vo.*;
import com.ruoyi.project.mapper.*;
import com.ruoyi.project.service.*;
import com.ruoyi.system.mapper.SysDictDataMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Logger;

/**
 * 捐献器官管理Service业务层处理
 *
 * @author ruoyi
 * @date 2021-11-10
 */
@Slf4j
@Service
public class ServiceDonateorganServiceImpl extends ServiceImpl<ServiceDonateorganMapper, ServiceDonateorgan> implements IServiceDonateorganService {

    @Autowired
    ServiceDonateorganMapper serviceDonateorganMapper;

    @Autowired
    BaseOrganizationMapper baseOrganizationMapper;

    @Autowired
    BasePrcaddressDictMapper basePrcaddressDictMapper;

    @Autowired
    ServiceDonationwitnessMapper serviceDonationwitnessMapper;

    @Autowired
    ServiceDonatebaseinfoMapper serviceDonatebaseinfoMapper;

    @Autowired
    ServiceMedicalevaluationMapper serviceMedicalevaluationMapper;

    @Autowired
    ServiceRelativesconfirmationMapper serviceRelativesconfirmationMapper;

    @Autowired
    ServiceOrganallocationMapper serviceOrganallocationMapper;

    @Autowired
    ServiceEthicalreviewopinionsMapper serviceEthicalreviewopinionsMapper;

    @Autowired
    ServiceDonatecompletioninfoMapper serviceDonatecompletioninfoMapper;

    @Autowired
    private SysDictDataMapper dictDataMapper;

    @Autowired
    IServiceOrganallocationService serviceOrganallocationService;


    /**
     * 查询捐献器官管理列表
     *
     * @param serviceDonateorgan 捐献器官管理
     * @return 捐献器官管理
     */
    @Override
    public List<ServiceDonateorgan> queryList(ServiceDonateorgan serviceDonateorgan) {
        LambdaQueryWrapper<ServiceDonateorgan> wrappers = Wrappers.lambdaQuery();
        if (StringUtils.isNotNull(serviceDonateorgan.getInfoid())) {
            wrappers.eq(ServiceDonateorgan::getInfoid, serviceDonateorgan.getInfoid());
        }
        if (StringUtils.isNotBlank(serviceDonateorgan.getDonorno())) {
            wrappers.eq(ServiceDonateorgan::getDonorno, serviceDonateorgan.getDonorno());
        }
        if (StringUtils.isNotBlank(serviceDonateorgan.getOrganno())) {
            wrappers.eq(ServiceDonateorgan::getOrganno, serviceDonateorgan.getOrganno());
        }
        if (StringUtils.isNotBlank(serviceDonateorgan.getOrganname())) {
            wrappers.like(ServiceDonateorgan::getOrganname, serviceDonateorgan.getOrganname());
        }
        if (serviceDonateorgan.getOrganstate() != null) {
            wrappers.eq(ServiceDonateorgan::getOrganstate, serviceDonateorgan.getOrganstate());
        }
        if (StringUtils.isNotBlank(serviceDonateorgan.getOrgannumber())) {
            wrappers.eq(ServiceDonateorgan::getOrgannumber, serviceDonateorgan.getOrgannumber());
        }
        if (serviceDonateorgan.getOrgangettime() != null) {
            wrappers.eq(ServiceDonateorgan::getOrgangettime, serviceDonateorgan.getOrgangettime());
        }
        if (StringUtils.isNotBlank(serviceDonateorgan.getOrgangetdoct())) {
            wrappers.eq(ServiceDonateorgan::getOrgangetdoct, serviceDonateorgan.getOrgangetdoct());
        }
        if (StringUtils.isNotBlank(serviceDonateorgan.getGainhospitalno())) {
            wrappers.eq(ServiceDonateorgan::getGainhospitalno, serviceDonateorgan.getGainhospitalno());
        }
        if (StringUtils.isNotBlank(serviceDonateorgan.getGainhospitalname())) {
            wrappers.like(ServiceDonateorgan::getGainhospitalname, serviceDonateorgan.getGainhospitalname());
        }
        if (StringUtils.isNotBlank(serviceDonateorgan.getTransplanthospitalno())) {
            wrappers.eq(ServiceDonateorgan::getTransplanthospitalno, serviceDonateorgan.getTransplanthospitalno());
        }
        if (StringUtils.isNotBlank(serviceDonateorgan.getTransplanthospitalname())) {
            wrappers.like(ServiceDonateorgan::getTransplanthospitalname, serviceDonateorgan.getTransplanthospitalname());
        }
        if (StringUtils.isNotBlank(serviceDonateorgan.getTransplantdoct())) {
            wrappers.eq(ServiceDonateorgan::getTransplantdoct, serviceDonateorgan.getTransplantdoct());
        }
        if (serviceDonateorgan.getTransplanttime() != null) {
            wrappers.eq(ServiceDonateorgan::getTransplanttime, serviceDonateorgan.getTransplanttime());
        }
        if (serviceDonateorgan.getEstimatedtime() != null) {
            wrappers.eq(ServiceDonateorgan::getEstimatedtime, serviceDonateorgan.getEstimatedtime());
        }
        return this.list(wrappers);
    }

    @Override
    public List<NumberOfOrgans> getNumberOfOrgans() {
        ArrayList<NumberOfOrgans> list = new ArrayList<NumberOfOrgans>();
        List<ServiceDonateorgan> serviceDonateorgans = serviceDonateorganMapper.getAllDonateOrgans();
        Map<String, Integer> map_donate = new HashMap<String, Integer>();
        Map<String, Integer> map_accept = new HashMap<String, Integer>();

        for (ServiceDonateorgan s : serviceDonateorgans) {
            BaseOrganization org_donate = baseOrganizationMapper.getOrganizationByNumber(s.getGainhospitalno());
            if (org_donate != null) {
                map_donate.put(org_donate.getCity(), map_donate.getOrDefault(org_donate.getCity(), 0) + 1);
            }
            BaseOrganization org_accept = baseOrganizationMapper.getOrganizationByNumber(s.getTransplanthospitalno());
            if (org_accept != null) {
                map_accept.put(org_accept.getCity(), map_accept.getOrDefault(org_accept.getCity(), 0) + 1);
            }
        }

        List<String> regions = new ArrayList<String>();
        regions.add("0");
        regions.add("1");
        regions.add("2");
        regions.add("3");
        regions.add("4");
        regions.add("5");
        regions.add("6");
        regions.add("7");
        regions.add("8");
        regions.add("9");
        regions.add("A");
        regions.add("B");
        for (String r : regions) {
            NumberOfOrgans numberOfOrgans = new NumberOfOrgans();
            numberOfOrgans.setDistrict(r);
            numberOfOrgans.setNumberOfHospitals(baseOrganizationMapper.getOrganizationByCity(r));
            numberOfOrgans.setDonateNumber(map_donate.getOrDefault(r, 0));
            numberOfOrgans.setAcceptNumber(map_accept.getOrDefault(r, 0));
            list.add(numberOfOrgans);
        }

        return list;
    }

    @Override
    public List<OrgansOfHospital> getOrgansOfHospital(String cityName) {
        ArrayList<OrgansOfHospital> list = new ArrayList<OrgansOfHospital>();
        List<ServiceDonateorgan> serviceDonateorgans = serviceDonateorganMapper.getAllDonateOrgans();
        Map<String, Integer> map_donate = new HashMap<String, Integer>();
        Map<String, Integer> map_accept = new HashMap<String, Integer>();

        for (ServiceDonateorgan s : serviceDonateorgans) {
            map_donate.put(s.getGainhospitalno(), map_donate.getOrDefault(s.getGainhospitalno(), 0) + 1);

            map_accept.put(s.getTransplanthospitalno(), map_accept.getOrDefault(s.getTransplanthospitalno(), 0) + 1);

        }
        List<BaseOrganization> baseOrganization = baseOrganizationMapper.getBaseOrganizationList();
        for (BaseOrganization o : baseOrganization) {
            OrgansOfHospital organsOfHospital = new OrgansOfHospital();
            if (cityName.equals(o.getCityname())) {
                organsOfHospital.setHospitalName(o.getOrganizationname());
                organsOfHospital.setHospitalNo(o.getMedicalcode());
                organsOfHospital.setDonateNumber(map_donate.getOrDefault(o.getMedicalcode(), 0));
                organsOfHospital.setAcceptNumber(map_accept.getOrDefault(o.getMedicalcode(), 0));
                list.add(organsOfHospital);
            }
        }

        return list;
    }

    @Override
    public AllOrgansInfo getAllOrgansInfo(TimeVO timeVO) {

        AllOrgansInfo allOrgansInfo = new AllOrgansInfo();

        allOrgansInfo.setProcessOrgans(serviceDonateorganMapper.getAllProcessOrgans(timeVO));
        allOrgansInfo.setFinishedOrgans(serviceDonateorganMapper.getAllFinishedOrgans(timeVO));
        allOrgansInfo.setHeart(serviceDonateorganMapper.getOrganNo("C38", timeVO.getStarttime(), timeVO.getEndtime(), timeVO.getCity(), timeVO.getReporterno()));
        allOrgansInfo.setLeftLiver(serviceDonateorganMapper.getOrganNo("C22L", timeVO.getStarttime(), timeVO.getEndtime(), timeVO.getCity(), timeVO.getReporterno()));
        allOrgansInfo.setRightLiver(serviceDonateorganMapper.getOrganNo("C22R", timeVO.getStarttime(), timeVO.getEndtime(), timeVO.getCity(), timeVO.getReporterno()));
        allOrgansInfo.setFullLiver(serviceDonateorganMapper.getOrganNo("C22", timeVO.getStarttime(), timeVO.getEndtime(), timeVO.getCity(), timeVO.getReporterno()));
        allOrgansInfo.setLeftEye(serviceDonateorganMapper.getOrganNo("C69L", timeVO.getStarttime(), timeVO.getEndtime(), timeVO.getCity(), timeVO.getReporterno()));
        allOrgansInfo.setRightEye(serviceDonateorganMapper.getOrganNo("C69R", timeVO.getStarttime(), timeVO.getEndtime(), timeVO.getCity(), timeVO.getReporterno()));
        allOrgansInfo.setLeftLung(serviceDonateorganMapper.getOrganNo("C34L", timeVO.getStarttime(), timeVO.getEndtime(), timeVO.getCity(), timeVO.getReporterno()));
        allOrgansInfo.setRightLung(serviceDonateorganMapper.getOrganNo("C34R", timeVO.getStarttime(), timeVO.getEndtime(), timeVO.getCity(), timeVO.getReporterno()));
        allOrgansInfo.setFullLung(serviceDonateorganMapper.getOrganNo("C34", timeVO.getStarttime(), timeVO.getEndtime(), timeVO.getCity(), timeVO.getReporterno()));
        allOrgansInfo.setLeftRenal(serviceDonateorganMapper.getOrganNo("C64L", timeVO.getStarttime(), timeVO.getEndtime(), timeVO.getCity(), timeVO.getReporterno()));
        allOrgansInfo.setRightRenal(serviceDonateorganMapper.getOrganNo("C64R", timeVO.getStarttime(), timeVO.getEndtime(), timeVO.getCity(), timeVO.getReporterno()));
        allOrgansInfo.setPancreas(serviceDonateorganMapper.getOrganNo("C25", timeVO.getStarttime(), timeVO.getEndtime(), timeVO.getCity(), timeVO.getReporterno()));
        allOrgansInfo.setSmallIntestine(serviceDonateorganMapper.getOrganNo("C17", timeVO.getStarttime(), timeVO.getEndtime(), timeVO.getCity(), timeVO.getReporterno()));
        allOrgansInfo.setBody(serviceDonateorganMapper.getOrganNo("C00", timeVO.getStarttime(), timeVO.getEndtime(), timeVO.getCity(), timeVO.getReporterno()));
        allOrgansInfo.setOthers(serviceDonateorganMapper.getOrganNo("C01", timeVO.getStarttime(), timeVO.getEndtime(), timeVO.getCity(), timeVO.getReporterno()));

        return allOrgansInfo;
    }

    @Override
    public String getOrganNumber(ServiceDonateorgan serviceDonateorgan) {
        String organNo = serviceDonateorgan.getOrganno();
        return organNo;

    }

    @Override
    public organQuality getOrganQuality(TimeVO timeVO) {
        organQuality og = new organQuality();

        //本年度获取捐献者数量
        int transferNumber = serviceDonationwitnessMapper.countThisYearByTime(timeVO);
        //本年度潜在捐献者数量
        int donateNumber = serviceDonatebaseinfoMapper.getDonateBaseCountThisYear(timeVO);
        if (donateNumber == 0) {
            og.setDonateTransferRate(0.0);
        } else {
            double transferRate = (double) transferNumber / (double) donateNumber;
            og.setDonateTransferRate(transferRate);
        }

        //本年度移植器官数量
        int organTransplantNumber = serviceDonateorganMapper.getAllFinishedOrgansThisYear(timeVO);
        //本年度DBD来源器官捐献者
        int DBDDonaterNumber = serviceDonationwitnessMapper.getDBDDonaterNumberThisYear(timeVO);
        //本年度DCD来源器官捐献者
        int DCDDonaterNumber = serviceDonationwitnessMapper.getDCDDonaterNumberThisYear(timeVO);
        //本年度DBCD来源器官捐献者
        int DBCDDonaterNumber = serviceDonationwitnessMapper.getDBCDDonaterNumberThisYear(timeVO);
        if (transferNumber == 0) {
            og.setOrganProductionRate(0.0);
            og.setDBDDonateRate(0.0);
            og.setDCDDonateRate(0.0);
            og.setDBCDDonateRate(0.0);
        } else {
            double productionRate = (double) organTransplantNumber / (double) transferNumber;
            og.setOrganProductionRate(productionRate);

            double DBDDonaterRate = (double) DBDDonaterNumber / (double) transferNumber;
            og.setDBDDonateRate(DBDDonaterRate);

            double DCDDonaterRate = (double) DCDDonaterNumber / (double) transferNumber;
            og.setDCDDonateRate(DCDDonaterRate);

            double DBCDDonaterRate = (double) DBCDDonaterNumber / (double) transferNumber;
            og.setDBCDDonateRate(DBCDDonaterRate);
        }


        //本年度获取器官数量
        int getOrganNumber = serviceDonateorganMapper.getOrganNumberThisYear(timeVO);
        //本年度获取前器官活检数量
        int biopsyBeforeNumber = serviceDonateorganMapper.getbiopsyBeforeNumberThisYear(timeVO);
        //本年度获取后移植前器官活检数量
        int biopsyAfterNumber = serviceDonateorganMapper.getbiopsyAfterNumberThisYear(timeVO);
        //本年度边缘供器官数量
        int marginalOrgansNumber = serviceDonateorganMapper.getmarginalOrgansNumberThisYear(timeVO);
        //本年度病原菌阳性数量
        int pathogenPositiveNumber = serviceDonateorganMapper.getPathogenPositiveNumberThisYear(timeVO);

        if (getOrganNumber == 0) {
            og.setOrganUsedRate(0.0);
            og.setOrganBeforeGetCheckRate(0.0);
            og.setOrganAfterGetCheckRate(0.0);
            og.setMarginOrganRate(0.0);
            og.setGermPositiveRate(0.0);
        } else {
            double organUsedRate = (double) organTransplantNumber / (double) getOrganNumber;
            og.setOrganUsedRate(organUsedRate);

            double biopsyBeforeRate = (double) biopsyBeforeNumber / (double) getOrganNumber;
            og.setOrganBeforeGetCheckRate(biopsyBeforeRate);

            double biopsyAfterRate = (double) biopsyAfterNumber / (double) getOrganNumber;
            og.setOrganAfterGetCheckRate(biopsyAfterRate);

            double marginalOrgansRate = (double) marginalOrgansNumber / (double) getOrganNumber;
            og.setMarginOrganRate(marginalOrgansRate);

            double pathogenPositiveRate = (double) pathogenPositiveNumber / (double) getOrganNumber;
            og.setGermPositiveRate(pathogenPositiveRate);
        }

        //本年度总PNF数量
        int PNFNumber = serviceDonateorganMapper.getPNFNumberThisYear(timeVO);
        if (organTransplantNumber == 0) {
            og.setTotalPNFRate(0.0);
        } else {
            double PNFRate = (double) PNFNumber / (double) organTransplantNumber;
            og.setTotalPNFRate(PNFRate);
        }

        List<ServiceDonateorgan> list = serviceDonateorganMapper.getAllDonateOrgansByTime(timeVO);
        List<ServiceDonateorgan> list_PNF = serviceDonateorganMapper.selectPNFOrganThisYear(timeVO);
        List<ServiceDonateorgan> list_DGF = serviceDonateorganMapper.selectDGFOrganThisYear(timeVO);

        //本年度DBD来源器官数量
        int countDBD = 0;
        //本年度DCD来源器官数量
        int countDCD = 0;
        //本年度DBCD来源器官数量
        int countDBCD = 0;
        for (ServiceDonateorgan l : list) {
            Long InfoId = l.getInfoid();

            String category = serviceDonationwitnessMapper.getDonationCategoryByInfoId(InfoId);
            if (category != null && category.equals("DBD")) {
                countDBD += 1;
            }
            if (category != null && category.equals("DCD")) {
                countDCD += 1;
            }
            if (category != null && category.equals("DBCD")) {
                countDBCD += 1;
            }
        }

        //本年度DBD来源器官PNF数量
        int countDBDPNF = 0;
        //本年度DCD来源器官PNF数量
        int countDCDPNF = 0;
        //本年度DBCD来源器官PNF数量
        int countDBCDPNF = 0;
        for (ServiceDonateorgan s : list_PNF) {
            Long InfoId = s.getInfoid();
            String category = serviceDonationwitnessMapper.getDonationCategoryByInfoId(InfoId);
            if (category != null && category.equals("DBD")) {
                countDBDPNF += 1;
            }
            if (category != null && category.equals("DCD")) {
                countDCDPNF += 1;
            }
            if (category != null && category.equals("DBCD")) {
                countDBCDPNF += 1;
            }
        }

        //本年度总DGF数量
        int DGFNumber = serviceDonateorganMapper.getDGFNumberThisYear(timeVO);

        if (organTransplantNumber == 0) {
            og.setTotalDGFRate(0.0);
        } else {
            double DGFRate = (double) DGFNumber / (double) organTransplantNumber;
            og.setTotalDGFRate(DGFRate);
        }


        //本年度DBD来源器官DGF数量
        int countDBDDGF = 0;
        //本年度DCD来源器官DGF数量
        int countDCDDGF = 0;
        //本年度DBCD来源器官DGF数量
        int countDBCDDGF = 0;
        for (ServiceDonateorgan d : list_DGF) {
            Long InfoId = d.getInfoid();
            String category = serviceDonationwitnessMapper.getDonationCategoryByInfoId(InfoId);
            if (category != null && category.equals("DBD")) {
                countDBDDGF += 1;
            }
            if (category != null && category.equals("DCD")) {
                countDCDDGF += 1;
            }
            if (category != null && category.equals("DBCD")) {
                countDBCDDGF += 1;
            }
        }

        if (countDBD == 0) {
            og.setDBDPNFRate(0.0);
            og.setDBDDGFRate(0.0);
        } else {
            double DBDPNFRate = (double) countDBDPNF / (double) countDBD;
            og.setDBDPNFRate(DBDPNFRate);

            double DBDDGFRate = (double) countDBDDGF / (double) countDBD;
            og.setDBDDGFRate(DBDDGFRate);
        }

        if (countDCD == 0) {
            og.setDCDPNFRate(0.0);
            og.setDCDDGFRate(0.0);
        } else {
            double DCDPNFRate = (double) countDCDPNF / (double) countDCD;
            og.setDCDPNFRate(DCDPNFRate);

            double DCDDGFRate = (double) countDCDDGF / (double) countDCD;
            og.setDCDDGFRate(DCDDGFRate);
        }

        if (countDBCD == 0) {
            og.setDBCDPNFRate(0.0);
            og.setDBCDDGFRate(0.0);
        } else {
            double DBCDPNFRate = (double) countDBCDPNF / (double) countDBCD;
            og.setDBCDPNFRate(DBCDPNFRate);

            double DBCDDGFRate = (double) countDBCDDGF / (double) countDBCD;
            og.setDBCDDGFRate(DBCDDGFRate);
        }

        return og;
    }

    @Override
    public List<DonateOrganVO> selectVOList(DonateOrganVO donateOrganVO) {

        return serviceDonateorganMapper.selectVOList(donateOrganVO);
    }

    @Override
    public DonateNumber getDonateNumber(TimeVO timeVO) {
        DonateNumber donateNumber = new DonateNumber();
        donateNumber.setNumberOfDonate(serviceDonatebaseinfoMapper.countNumber(timeVO));
        donateNumber.setNumberOfMedicalEvaluation(serviceMedicalevaluationMapper.countNumber(timeVO));
        donateNumber.setNumberOfRelativeConfirmation(serviceRelativesconfirmationMapper.countNumber(timeVO));
//        donateNumber.setNumberOfDonatePeople(serviceOrganallocationMapper.countNumber(timeVO));
        donateNumber.setNumberOfDonatePeople(serviceDonateorganMapper.countNumber(timeVO));
        donateNumber.setNumberOfOrgans(serviceDonateorganMapper.countNumber(timeVO));
        donateNumber.setNumberOfWitness(serviceDonationwitnessMapper.countNumber(timeVO));
        donateNumber.setNumberOfEthicalReview(serviceEthicalreviewopinionsMapper.countNumber(timeVO));
        donateNumber.setNumberOfCompletion(serviceDonatecompletioninfoMapper.countNumber(timeVO));
        donateNumber.setNumberOfTerminated(serviceDonatebaseinfoMapper.countTerminatedNumber(timeVO));

        return donateNumber;
    }


    @Override
    public List<DonateNumberByMonth> getDonateBaseInfoByMonth() {
        List<DonateNumberByMonth> l = new ArrayList<DonateNumberByMonth>();
        List<ServiceDonatebaseinfo> serviceDonatebaseinfos = serviceDonatebaseinfoMapper.getAllDonateBaseInfo();
        HashMap<String, Integer> map_baseinfo_count = new HashMap<String, Integer>();

        for (ServiceDonatebaseinfo s : serviceDonatebaseinfos) {
            Date dt = s.getReporttime();
            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String date = formatter.format(dt);
            String month = date.substring(0, 7);
            map_baseinfo_count.put(month, map_baseinfo_count.getOrDefault(month, 0) + 1);
        }

        for (Map.Entry<String, Integer> entry : map_baseinfo_count.entrySet()) {
            DonateNumberByMonth d = new DonateNumberByMonth();
            d.setDonatemonth(entry.getKey());
            d.setDonatecount(entry.getValue());
            l.add(d);
        }

        return l;
    }

    @Override
    public List<DonateByRegionVO> OrgansOfHospitalByMonth(TimeVO timeVO) {
        List<BaseOrganization> baseOrganizations = baseOrganizationMapper.getHospitalList();
        List<DonateByRegionVO> l = new ArrayList<>();
        List<ServiceDonatebaseinfo> serviceDonatebaseinfos = serviceDonatebaseinfoMapper.getAllDonateBaseInfoByTime(timeVO);

        for (BaseOrganization b : baseOrganizations) {
            HashMap<String, Integer> map_baseinfo_count = new HashMap<String, Integer>();
            HashMap<String, Integer> map_completion_count = new HashMap<String, Integer>();
            //List<ServiceDonatebaseinfo> serviceDonatebaseinfos = serviceDonatebaseinfoMapper.getBaseInfoByHospital(b.getOrganizationid());
            List<ServiceDonatebaseinfo> serviceDonatebaseinfoOfThisHospital = new ArrayList<>();
            for (ServiceDonatebaseinfo sd : serviceDonatebaseinfos) {
                if (b.getOrganizationid().equals(sd.getTreatmenthospitalno())) {
                    serviceDonatebaseinfoOfThisHospital.add(sd);
                }
            }
            for (ServiceDonatebaseinfo s : serviceDonatebaseinfoOfThisHospital) {
                Date dt = s.getReporttime();
                SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String date = formatter.format(dt);
                String month = date.substring(0, 7);
                map_baseinfo_count.put(month, map_baseinfo_count.getOrDefault(month, 0) + 1);
                ServiceDonatecompletioninfo sc = serviceDonatecompletioninfoMapper.getByInfoId(s.getId());
                if (sc != null) {
                    map_completion_count.put(month, map_completion_count.getOrDefault(month, 0) + 1);
                } else {
                    map_completion_count.put(month, map_completion_count.getOrDefault(month, 0));
                }

            }

            for (Map.Entry<String, Integer> entry : map_baseinfo_count.entrySet()) {
                DonateByRegionVO d = new DonateByRegionVO();
                d.setHospitalNumber(b.getOrganizationid());
                d.setHospitalName(b.getOrganizationname());
                d.setRegionLevel(b.getRegionallevel());
                d.setMonth(entry.getKey());
                d.setBaseInfoCount(entry.getValue());
                d.setCompletionCount(map_completion_count.get(entry.getKey()));
                l.add(d);
            }
        }
        return l;
    }


    @Override
    public List<DonateByRegionVO> OrgansOfHospitalByTime(TimeVO timeVO) {
        List<BaseOrganization> baseOrganizations = baseOrganizationMapper.getHospitalList();
        List<DonateByRegionVO> l = new ArrayList<>();
        List<ServiceDonatebaseinfo> serviceDonatebaseinfos = serviceDonatebaseinfoMapper.getAllDonateBaseInfoByTime(timeVO);
        List<String> completeTreatmenthospitalnos = serviceDonatebaseinfoMapper.gettreatmenthospitalnoCompleteByTime(timeVO);

        for (BaseOrganization b : baseOrganizations) {
            HashMap<String, Integer> map_baseinfo_count = new HashMap<String, Integer>();
            HashMap<String, Integer> map_completion_count = new HashMap<String, Integer>();

            String Organizationid = b.getOrganizationid();
            for (ServiceDonatebaseinfo s : serviceDonatebaseinfos) {

                if (Organizationid.equals(s.getTreatmenthospitalno())) {
                    map_baseinfo_count.put(Organizationid, map_baseinfo_count.getOrDefault(Organizationid, 0) + 1);
                }
            }

            for (String sc : completeTreatmenthospitalnos) {
                if (Organizationid.equals(sc)) {
                    map_completion_count.put(Organizationid, map_completion_count.getOrDefault(Organizationid, 0) + 1);
                }
            }

            if (map_baseinfo_count.size() == 0) {
                map_baseinfo_count.put(Organizationid, map_baseinfo_count.getOrDefault(Organizationid, 0));
            }

            if (map_completion_count.size() == 0) {
                map_completion_count.put(Organizationid, map_completion_count.getOrDefault(Organizationid, 0));
            }

            // for(Map.Entry<String, Integer> entry: map_baseinfo_count.entrySet()) {
            if (map_baseinfo_count.get(b.getOrganizationid()) > 0 || map_completion_count.get(b.getOrganizationid()) > 0) {
                DonateByRegionVO d = new DonateByRegionVO();
                d.setHospitalNumber(b.getOrganizationid());
                d.setHospitalName(b.getOrganizationname());
                d.setRegionLevel(b.getCity());
                d.setMonth(b.getCityname());
                d.setBaseInfoCount(map_baseinfo_count.get(b.getOrganizationid()));
                d.setCompletionCount(map_completion_count.get(b.getOrganizationid()));
                l.add(d);
            }

            // }
        }
        return l;
    }

    @Override
    public List<ServiceDonateorgan> selectServiceDonateorganList(ServiceDonateorgan serviceDonateorgan) {
        return serviceDonateorganMapper.selectServiceDonateorganList(serviceDonateorgan);
    }

    @Override
    public List<ServiceDonateorgan> selectServiceDonateorganListNotAbandon(ServiceDonateorgan serviceDonateorgan) {
        return serviceDonateorganMapper.selectServiceDonateorganListNotAbandon(serviceDonateorgan);
    }

    @Override
    public PMPRateVO getPMPRate(TimeVO timeVO) {
        PMPRateVO p = new PMPRateVO();
        int count = serviceDonatecompletioninfoMapper.count(timeVO);
        p.setPMPRate((double) count / 64.0);

        return p;
    }

    @Override
    public List<DistrictDonateCalculateVO> getDistrictDonateCalculate() {
        List<DistrictDonateCalculateVO> l = new ArrayList<>();
        Map<String, Integer> map_donate = new HashMap<String, Integer>();
        Map<String, Integer> map_complete = new HashMap<String, Integer>();
        Map<String, Integer> map_organs = new HashMap<String, Integer>();

        List<String> l1 = serviceDonatebaseinfoMapper.getDistrictDonate();
        List<String> l2 = serviceDonatebaseinfoMapper.getDistrictComplete();
        List<String> l3 = serviceDonatebaseinfoMapper.getDistrictOrgans();

        for (String s1 : l1) {
            map_donate.put(s1, map_donate.getOrDefault(s1, 0) + 1);
        }
        for (String s2 : l2) {
            map_complete.put(s2, map_complete.getOrDefault(s2, 0) + 1);
        }
        for (String s3 : l3) {
            map_organs.put(s3, map_organs.getOrDefault(s3, 0) + 1);
        }

        List<String> regions = new ArrayList<String>();
        regions.add("0");
        regions.add("1");
        regions.add("2");
        regions.add("3");
        regions.add("4");
        regions.add("5");
        regions.add("6");
        regions.add("7");
        regions.add("8");
        regions.add("9");
        regions.add("A");
        regions.add("B");

        for (String r : regions) {
            DistrictDonateCalculateVO d = new DistrictDonateCalculateVO();
            d.setDistrict(r);
            d.setDonateCount(map_donate.getOrDefault(r, 0));
            d.setCompleteCount(map_complete.getOrDefault(r, 0));
            d.setTotalOrganCount(map_organs.getOrDefault(r, 0));
            l.add(d);
        }

        return l;
    }

    @Override
    public List<DistrictDonateCalculateVO> getDistrictDonateCalculateByTime(TimeVO timeVO) {
        List<DistrictDonateCalculateVO> l = new ArrayList<>();
        Map<String, Integer> map_donate = new HashMap<String, Integer>();
        Map<String, Integer> map_complete = new HashMap<String, Integer>();
        Map<String, Integer> map_organs = new HashMap<String, Integer>();

        List<String> l1 = serviceDonatebaseinfoMapper.getDistrictDonateByTime(timeVO);
        List<String> l2 = serviceDonatebaseinfoMapper.getDistrictCompleteByTime(timeVO);
        List<String> l3 = serviceDonatebaseinfoMapper.getDistrictOrgansByTime(timeVO);

        for (String s1 : l1) {
            map_donate.put(s1, map_donate.getOrDefault(s1, 0) + 1);
        }
        for (String s2 : l2) {
            map_complete.put(s2, map_complete.getOrDefault(s2, 0) + 1);
        }
        for (String s3 : l3) {
            map_organs.put(s3, map_organs.getOrDefault(s3, 0) + 1);
        }

        List<String> regions = new ArrayList<String>();
        regions.add("0");
        regions.add("1");
        regions.add("2");
        regions.add("3");
        regions.add("4");
        regions.add("5");
        regions.add("6");
        regions.add("7");
        regions.add("8");
        regions.add("9");
        regions.add("A");
        regions.add("B");

        for (String r : regions) {
            DistrictDonateCalculateVO d = new DistrictDonateCalculateVO();
            d.setDistrict(r);
            d.setDonateCount(map_donate.getOrDefault(r, 0));
            d.setCompleteCount(map_complete.getOrDefault(r, 0));
            d.setTotalOrganCount(map_organs.getOrDefault(r, 0));
            l.add(d);
        }

        return l;
    }


    @Override
    public List<organNumberByOrgVO> getOrganNumberByOrg(TimeVO timeVO) {
        List<organNumberByOrgVO> l = new ArrayList<>();
        List<BaseOrganization> baseOrganizations = baseOrganizationMapper.getTransOrg();
        Map<String, Integer> map_organs = new HashMap<String, Integer>();
        for (BaseOrganization b : baseOrganizations) {
            int count = serviceDonateorganMapper.getOrgansCount(timeVO.getStarttime(), timeVO.getEndtime(), b.getOrganizationid());
            map_organs.put(b.getOrganizationid(), count);
        }

        for (Map.Entry<String, Integer> entry : map_organs.entrySet()) {
            organNumberByOrgVO o = new organNumberByOrgVO();
            o.setOrgId(entry.getKey());
            o.setOrgName(baseOrganizationMapper.getNameByNo(entry.getKey()));
            o.setOrganCount(entry.getValue());
            l.add(o);
        }
        return l;
    }

    @Override
    public List<organInfoVO> getOrganCount(TimeVO timeVO) {
        List<organInfoVO> l = new ArrayList<>();

        //List<ServiceDonateorgan> serviceDonateorgans = serviceDonateorganMapper.selectAll(timeVO);
        Map<String, Integer> map_organs = new HashMap<String, Integer>();
        //List<String> organNo = new ArrayList<>();

        List<SysDictData> data = dictDataMapper.selectDictDataByType("sys_Organ");
        if (StringUtils.isNull(data)) {
            data = new ArrayList<SysDictData>();
        }


        for (SysDictData sysDictData : data) {
            if (!sysDictData.getDictValue().equals("C00")) {
                int count = serviceDonateorganMapper.getDistinctOrgansCount(sysDictData.getDictValue(), timeVO.getStarttime(), timeVO.getEndtime(), timeVO.getCity(), timeVO.getReporterno());
                map_organs.put(sysDictData.getDictValue(), count);
            }
        }
        for (Map.Entry<String, Integer> entry : map_organs.entrySet()) {
            organInfoVO organ = new organInfoVO();
            organ.setOrganNo(entry.getKey());
            //organ.setOrganName(serviceDonateorganMapper.getOrganNameByNo(entry.getKey()));
            organ.setCount(entry.getValue());
            l.add(organ);
        }

        return l;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public List<ServiceDonateorgan> saveData(List<ServiceDonateorgan> serviceDonateorgans) {
        for (ServiceDonateorgan serviceDonateorgan : serviceDonateorgans) {
            if (serviceDonateorgan.getInfoid() == null) {
                throw new BaseException("未关联捐献基础信息，infoid为空了" + serviceDonateorgan);
            }

            String organNumber = serviceDonateorgan.getDonorno() + "." + serviceDonateorgan.getOrganno();
            if (StringUtils.isEmpty(serviceDonateorgan.getDonorno()) || StringUtils.isEmpty(serviceDonateorgan.getOrganno())) {
                throw new BaseException("新增时生成的编号为空,创建失败(请检查捐献者编号和器官类别)! ：" + serviceDonateorgan.toString());
            } else {
                ServiceDonateorgan serviceDonateorgan1 = new ServiceDonateorgan();
                serviceDonateorgan1.setOrgannumber(organNumber);
                List<ServiceDonateorgan> listrecord = this.queryList(serviceDonateorgan);
                if (listrecord.size() > 0) {
                    continue;
                }
            }
            serviceDonateorgan.setOrgannumber(organNumber);
            log.info("serviceDonateorgan的数据为: {}", serviceDonateorgan);
            boolean save = this.save(serviceDonateorgan);

        }
        return serviceDonateorgans;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean editArrayData(List<ServiceDonateorgan> serviceDonateorgans) {
        for (ServiceDonateorgan serviceDonateorgan : serviceDonateorgans) {
            if (serviceDonateorgan.getId() == null) {
                throw new BaseException("id为空了 ：" + serviceDonateorgan);
            }
            this.updateById(serviceDonateorgan);
        }
        //将带ID的数据返回
        return true;
    }


    @Override
    public List<DonateNumberByMonth> getDonatePeopleByMonth(TimeVO timeVO) {
        List<DonateNumberByMonth> l = new ArrayList<DonateNumberByMonth>();
        List<ServiceDonationwitness> serviceDonationwitnesses = serviceDonationwitnessMapper.getAllDonatePeopleByTime(timeVO);
        HashMap<String, Integer> map_organ_count = new HashMap<String, Integer>();

        for (ServiceDonationwitness s : serviceDonationwitnesses) {
            Date dt = s.getOperationbegtime();
            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String date = formatter.format(dt);
            String month = date.substring(0, 7);
            map_organ_count.put(month, map_organ_count.getOrDefault(month, 0) + 1);
        }

        for (Map.Entry<String, Integer> entry : map_organ_count.entrySet()) {
            DonateNumberByMonth d = new DonateNumberByMonth();
            d.setDonatemonth(entry.getKey());
            d.setDonatecount(entry.getValue());
            l.add(d);
        }

        return l;
    }


    @Override
    public List<DonateNumberByMonth> getDonatePeopleByMonthFromCompletioninfo(TimeVO timeVO) {
        List<DonateNumberByMonth> l = new ArrayList<DonateNumberByMonth>();
        List<ServiceDonatecompletioninfo> serviceDonatecompletioninfos = serviceDonatecompletioninfoMapper.getCompletionDonatePeopleByTime(timeVO);
        HashMap<String, Integer> map_organ_count = new HashMap<String, Integer>();

        for (ServiceDonatecompletioninfo s : serviceDonatecompletioninfos) {
            Date dt = s.getCompletetime();
            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String date = formatter.format(dt);
            String month = date.substring(0, 7);
            map_organ_count.put(month, map_organ_count.getOrDefault(month, 0) + 1);
        }

        for (Map.Entry<String, Integer> entry : map_organ_count.entrySet()) {
            DonateNumberByMonth d = new DonateNumberByMonth();
            d.setDonatemonth(entry.getKey());
            d.setDonatecount(entry.getValue());
            l.add(d);
        }

        return l;
    }


    @Override
    public List<DonateNumberByMonth> getDonateNumberByMonth(TimeVO timeVO) {

        List<DonateNumberByMonth> l = new ArrayList<DonateNumberByMonth>();
        List<ServiceDonateorgan> serviceDonateorgans = serviceDonateorganMapper.getAllDonateOrgansByTime(timeVO);
        HashMap<String, Integer> map_organ_count = new HashMap<String, Integer>();

        for (ServiceDonateorgan s : serviceDonateorgans) {
            Date dt = s.getOrgangettime();
            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String date = formatter.format(dt);
            String month = date.substring(0, 7);
            map_organ_count.put(month, map_organ_count.getOrDefault(month, 0) + 1);
        }

        for (Map.Entry<String, Integer> entry : map_organ_count.entrySet()) {
            DonateNumberByMonth d = new DonateNumberByMonth();
            d.setDonatemonth(entry.getKey());
            d.setDonatecount(entry.getValue());
            l.add(d);
        }

        return l;
    }

    @Override
    public List<DonateNumberByMonth> getDonateHospitalByMonth(TimeVO timeVO) {
        List<DonateNumberByMonth> l = new ArrayList<DonateNumberByMonth>();
        List<ServiceDonateorgan> serviceDonateorgans = serviceDonateorganMapper.getAllDonateOrgansByTime(timeVO);
        HashMap<String, Integer> map_organ_count = new HashMap<String, Integer>();
        List<String> hospitals = new ArrayList<>();

        for (ServiceDonateorgan s : serviceDonateorgans) {
            Date dt = s.getOrgangettime();
            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String date = formatter.format(dt);
            String month = date.substring(0, 7);
            String gainHospital = s.getGainhospitalno();
            if (!hospitals.contains(gainHospital)) {
                map_organ_count.put(month, map_organ_count.getOrDefault(month, 0) + 1);
                hospitals.add(gainHospital);
            }
        }

        for (Map.Entry<String, Integer> entry : map_organ_count.entrySet()) {
            DonateNumberByMonth d = new DonateNumberByMonth();
            d.setDonatemonth(entry.getKey());
            d.setDonatecount(entry.getValue());
            l.add(d);
        }

        return l;
    }

    @Override
    public List<DonateNumberByMonth> getAcceptHospitalByMonth() {
        List<DonateNumberByMonth> l = new ArrayList<DonateNumberByMonth>();
        List<ServiceDonateorgan> serviceDonateorgans = serviceDonateorganMapper.getAllDonateOrgans();
        HashMap<String, Integer> map_organ_count = new HashMap<String, Integer>();
        List<String> hospitals = new ArrayList<>();

        for (ServiceDonateorgan s : serviceDonateorgans) {
            Date dt = s.getOrgangettime();
            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String date = formatter.format(dt);
            String month = date.substring(0, 7);
            String acceptHospital = s.getTransplanthospitalno();
            if (!hospitals.contains(acceptHospital)) {
                map_organ_count.put(month, map_organ_count.getOrDefault(month, 0) + 1);
                hospitals.add(acceptHospital);
            }
        }

        for (Map.Entry<String, Integer> entry : map_organ_count.entrySet()) {
            DonateNumberByMonth d = new DonateNumberByMonth();
            d.setDonatemonth(entry.getKey());
            d.setDonatecount(entry.getValue());
            l.add(d);
        }

        return l;
    }

    @Override
    public List<ServiceDonateorgan> countList(ServiceDonateorgan serviceDonateorgan) {
        SysUser user = SecurityUtils.getLoginUser().getUser();
        List<SysRole> l = user.getRoles();
        Boolean b = false;
        for (SysRole r : l) {
            if (r.getRoleId().longValue() == 3) {
                b = true;
            }
        }
        if (b) {
            serviceDonateorgan.setCreateBy(user.getUserName());
        }
        return serviceDonateorganMapper.countList(serviceDonateorgan);
    }

}