package com.ruoyi.project.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.core.domain.entity.SysDictData;
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.IServiceDonateorganService;
import com.ruoyi.system.mapper.SysDictDataMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 捐献器官管理Service业务层处理
 * 
 * @author ruoyi
 * @date 2021-11-10
 */
@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;



    /**
     * 查询捐献器官管理列表
     * 
     * @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());
        }
        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<BasePrcaddressDict> city = basePrcaddressDictMapper.getAllCityOfZJ();
//        for(BasePrcaddressDict c : city){
//            NumberOfOrgans numberOfOrgans = new NumberOfOrgans();
//            numberOfOrgans.setDistrict(c.getAreaname());
//            numberOfOrgans.setNumberOfHospitals(baseOrganizationMapper.getOrganizationByCity(c.getAreanumber()));
//            numberOfOrgans.setDonateNumber(map_donate.getOrDefault(c.getAreaname(),0));
//            numberOfOrgans.setAcceptNumber(map_accept.getOrDefault(c.getAreaname(),0));
//            list.add(numberOfOrgans);
//        }

        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.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
//    public List<DonateByRegionVO> OrgansOfHospitalByMonth() {
//        List<BaseOrganization> baseOrganizations = baseOrganizationMapper.getHospitalList();
//        List<DonateByRegionVO> l = new ArrayList<>();
//        List<ServiceDonatebaseinfo> serviceDonatebaseinfos = serviceDonatebaseinfoMapper.getAllDonateBaseInfo();
//
//        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<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;
    }



}