package com.glxp.api.controller.basic;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.file.FileWriter;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.glxp.api.constant.BasicProcessStatus;
import com.glxp.api.dao.basic.UdiProductDao;
import com.glxp.api.dao.basic.UdiRelevanceDao;
import com.glxp.api.dao.thrsys.ThrCorpDao;
import com.glxp.api.dao.thrsys.ThrProductsDao;
import com.glxp.api.entity.basic.*;
import com.glxp.api.entity.thrsys.ThrProductsEntity;
import com.glxp.api.req.basic.BasicCorpsExportRequest;
import com.glxp.api.req.basic.BasicUnitMaintainFilterRequest;
import com.glxp.api.req.basic.FilterUdiRelRequest;
import com.glxp.api.req.basic.UdiInfoExportRequest;
import com.glxp.api.req.thrsys.FilterThrCorpRequest;
import com.glxp.api.req.thrsys.FilterThrProductsRequest;
import com.glxp.api.res.basic.BasicCorpExportLogResponse;
import com.glxp.api.res.basic.UdiRelevanceExportJsonResponse;
import com.glxp.api.res.basic.UdiRelevanceResponse;
import com.glxp.api.res.thrsys.ThrCorpsResponse;
import com.glxp.api.service.basic.BasicCorpExportLogService;
import com.glxp.api.service.basic.BasicCorpService;
import com.glxp.api.service.basic.BasicProductsExportLogService;
import com.glxp.api.service.basic.UdiRelevanceService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.File;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

@Slf4j
@Service
public class BasicGenJsonService {

    @Resource
    BasicCorpExportLogService corpExportLogService;
    @Resource
    BasicCorpService basicUnitMaintainService;
    @Resource
    BasicProductsExportLogService basicProductsExportLogService;
    @Resource
    UdiRelevanceService udiRelevanceService;
    @Resource
    UdiRelevanceDao udiRelevanceDao;
    @Resource
    UdiProductDao udiProductDao;
    @Resource
    ThrProductsDao thrProductsDao;
    @Resource
    ThrCorpDao thrCorpDao;


    public void exportCorp(String genKey, BasicCorpsExportRequest basicCorpsExportRequest) {
        BasicCorpsExportLogEntity corpExportLogEntity = corpExportLogService.selectByGenKey(genKey);
        BasicCorpExportLogResponse exportData = new BasicCorpExportLogResponse();

        List<BasicCorpEntity> unitMaintainEntities = new ArrayList<>();
        if (basicCorpsExportRequest.getIds() != null && basicCorpsExportRequest.getIds().size() > 0) {
            List<Integer> ids = basicCorpsExportRequest.getIds();
            ids.forEach(id -> {
                BasicUnitMaintainFilterRequest request = new BasicUnitMaintainFilterRequest();
                request.setId(id);
                List<BasicCorpEntity> basicUnitMaintainEntities = basicUnitMaintainService.filterList(request);
                unitMaintainEntities.addAll(basicUnitMaintainEntities);
                getThrCorpList(exportData, basicUnitMaintainEntities);
            });
        } else { //一键导出
            BasicUnitMaintainFilterRequest filterRequest = new BasicUnitMaintainFilterRequest();
            BeanUtils.copyProperties(basicCorpsExportRequest, filterRequest);
            filterRequest.setPage(null);
            List<BasicCorpEntity> basicUnitMaintainEntities = basicUnitMaintainService.filterList(filterRequest);
            unitMaintainEntities.addAll(basicUnitMaintainEntities);
            getThrCorpList(exportData, basicUnitMaintainEntities);
        }

        exportData.setCorpList(unitMaintainEntities);
        FileWriter writer = new FileWriter(corpExportLogEntity.getFilePath());
        writer.write(JSONUtil.toJsonStr(exportData));
        corpExportLogEntity.setStatus(BasicProcessStatus.UDIINFO_IMPORT_SUCCESS);
        corpExportLogService.updateCorpExportLog(corpExportLogEntity);
    }


    public BasicCorpExportLogResponse exportCorpJson(BasicCorpsExportRequest corpsExportRequest) {
        BasicCorpExportLogResponse exportData = new BasicCorpExportLogResponse();
        List<BasicCorpEntity> unitMaintainEntities = new ArrayList<>();
        if (corpsExportRequest.getIds() != null && corpsExportRequest.getIds().size() > 0) {
            List<Integer> ids = corpsExportRequest.getIds();
            ids.forEach(id -> {
                BasicUnitMaintainFilterRequest request = new BasicUnitMaintainFilterRequest();
                request.setId(id);
                List<BasicCorpEntity> basicUnitMaintainEntities = basicUnitMaintainService.filterList(request);
                unitMaintainEntities.addAll(basicUnitMaintainEntities);
                getThrCorpList(exportData, basicUnitMaintainEntities);
            });
        } else { //一键导出
            BasicUnitMaintainFilterRequest filterRequest = new BasicUnitMaintainFilterRequest();
            BeanUtils.copyProperties(corpsExportRequest, filterRequest);
            filterRequest.setPage(null);
            List<BasicCorpEntity> basicUnitMaintainEntities = basicUnitMaintainService.filterList(filterRequest);
            unitMaintainEntities.addAll(basicUnitMaintainEntities);
            getThrCorpList(exportData, basicUnitMaintainEntities);
        }

        exportData.setCorpList(unitMaintainEntities);
        return exportData;
    }
//
    /**
     * 查询第三方往来单位信息
     *
     * @param exportData
     * @param basicUnitMaintainEntities
     */
    private void getThrCorpList(BasicCorpExportLogResponse exportData, List<BasicCorpEntity> basicUnitMaintainEntities) {
        if (CollUtil.isNotEmpty(basicUnitMaintainEntities)) {
            List<ThrCorpsResponse> thrCorpEntities = new ArrayList<>();
            Field[] fields = ReflectUtil.getFields(BasicCorpEntity.class);
            basicUnitMaintainEntities.forEach(basicUnitMaintainEntity -> {
                for (Field field : fields) {
                    if (field.getName().contains("thirdId")) {
                        String value = String.valueOf(ReflectUtil.getFieldValue(basicUnitMaintainEntity, field));
                        if (StrUtil.isNotBlank(value)) {
                            FilterThrCorpRequest thrCorpRequest = new FilterThrCorpRequest();
                            thrCorpRequest.setThirdSysFk("thirdId");
                            thrCorpRequest.setUnitId(value);
                            List<ThrCorpsResponse> result = thrCorpDao.filterThrCorps(thrCorpRequest);
                            if (CollUtil.isNotEmpty(result)) {
                                thrCorpEntities.addAll(result);
                            }
                        }
                    }
                }
            });
            if (CollUtil.isNotEmpty(thrCorpEntities)) {
                exportData.setThrCorpEntities(thrCorpEntities);
            }
        }
    }

    /**
     * 导出json格式医疗器械信息
     *
     * @param genKey
     * @param udiInfoExportRequest
     */
    @Async
    public void exportUdiInfoJson(String genKey, UdiInfoExportRequest udiInfoExportRequest) {
        BasicProductsExportLogEntity basicProductsExportLogEntity = basicProductsExportLogService.selectByGenKey(genKey);
        UdiRelevanceExportJsonResponse exportData = paresDataJson(udiInfoExportRequest);
        File file = new File(basicProductsExportLogEntity.getFilePath());
        if (!file.exists()) {
            try {
                if (!FileUtil.exist(file.getParentFile())) {
                    FileUtil.mkdir(file.getParentFile());
                }
                file.createNewFile();
            } catch (Exception e) {
                log.error("导出医疗器械信息异常", e);
            }
        }
        FileWriter writer = new FileWriter(file);
        writer.write(JSONUtil.toJsonStr(exportData));
        basicProductsExportLogEntity.setStatus(BasicProcessStatus.UDIINFO_IMPORT_SUCCESS);
        basicProductsExportLogService.updateUdiInfoExportLog(basicProductsExportLogEntity);
    }


    public UdiRelevanceExportJsonResponse paresDataJson(UdiInfoExportRequest udiInfoExportRequest) {
        UdiRelevanceExportJsonResponse exportData = new UdiRelevanceExportJsonResponse();
        //选中导出
        if (CollUtil.isNotEmpty(udiInfoExportRequest.getUuids())) {
            List<String> uuids = udiInfoExportRequest.getUuids();
            uuids.forEach(uuid -> {
                FilterUdiRelRequest filterUdiRelRequest = new FilterUdiRelRequest();
                filterUdiRelRequest.setUuid(uuid);
                List<UdiRelevanceResponse> udiRelevanceResponses = udiRelevanceService.filterUdiRelevance(filterUdiRelRequest);
                if (CollUtil.isNotEmpty(udiRelevanceResponses)) {
                    parseUdiRelevanceResponses(exportData, udiRelevanceResponses);
                }
            });
        } else {
            //一键导出
            FilterUdiRelRequest filterUdiRelRequest = new FilterUdiRelRequest();
            BeanUtil.copyProperties(udiInfoExportRequest, filterUdiRelRequest);
            filterUdiRelRequest.setPage(null);
            List<UdiRelevanceResponse> data = udiRelevanceService.filterUdiRelevance(filterUdiRelRequest);
            if (CollUtil.isNotEmpty(data)) {
                parseUdiRelevanceResponses(exportData, data);
            }
        }
        return exportData;
    }

    /**
     * 解析医疗器械信息查询结果，封装完整数据
     *
     * @param exportData
     * @param udiRelevanceResponses
     */
    private void parseUdiRelevanceResponses(UdiRelevanceExportJsonResponse exportData, List<UdiRelevanceResponse> udiRelevanceResponses) {
        List<String> uuids = new ArrayList<>(udiRelevanceResponses.size());
        udiRelevanceResponses.forEach(udi -> {
            uuids.add(udi.getUuid());
        });
        List<UdiProductEntity> udiInfoEntities = udiProductDao.batchSelectByUuid(uuids);
        List<UdiRelevanceEntity> udiRelevanceEntities = udiRelevanceDao.batchSelectByUuid(uuids);
        if (CollUtil.isNotEmpty(udiRelevanceEntities)) {
            List<ThrProductsEntity> thrProductsEntities = new ArrayList<>(udiRelevanceEntities.size());
            Field[] fields = ReflectUtil.getFields(UdiRelevanceEntity.class);
            udiRelevanceEntities.forEach(udiRelevanceEntity -> {
                for (Field field : fields) {
                    if (field.getName().contains("thirdId")) {
                        Object fieldValue = ReflectUtil.getFieldValue(udiRelevanceEntity, field);
                        if (null != fieldValue) {
                            FilterThrProductsRequest filter = new FilterThrProductsRequest();
                            filter.setCode(String.valueOf(fieldValue));
                            filter.setThirdSysFk("thirdId");
                            List<ThrProductsEntity> result = thrProductsDao.filterThrProducts(filter);
                            if (CollUtil.isNotEmpty(result)) {
                                thrProductsEntities.addAll(result);
                            }
                        }
                    }
                }
            });
            if (CollUtil.isNotEmpty(thrProductsEntities)) {
                exportData.setThrProductsEntities(thrProductsEntities);
            }
        }
        List<UdiProductEntity> udiInfo = exportData.getUdiProductEntities();
        List<UdiRelevanceEntity> udiRelevance = exportData.getUdiRelevanceEntities();
        udiInfo.addAll(udiInfoEntities);
        udiRelevance.addAll(udiRelevanceEntities);
        exportData.setUdiProductEntities(udiInfo);
        exportData.setUdiRelevanceEntities(udiRelevance);
    }
}