package com.engine.salary.wrapper;

import com.engine.core.impl.Service;
import com.engine.salary.cache.SalaryCacheKey;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import com.engine.salary.entity.taxagent.po.TaxAgentPO;
import com.engine.salary.entity.taxdeclaration.dto.*;
import com.engine.salary.entity.taxdeclaration.param.AbnormalEmployeeListQueryParam;
import com.engine.salary.entity.taxdeclaration.param.TaxDeclarationListQueryParam;
import com.engine.salary.entity.taxdeclaration.param.TaxDeclarationSaveParam;
import com.engine.salary.entity.taxdeclaration.param.TaxDeclarationValueListQueryParam;
import com.engine.salary.entity.taxdeclaration.po.*;
import com.engine.salary.enums.salarysob.IncomeCategoryEnum;
import com.engine.salary.enums.taxdeclaration.TaxDeclareStatusEnum;
import com.engine.salary.enums.taxdeclaration.TaxDeclareTypeEnum;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.service.*;
import com.engine.salary.util.SalaryDateUtil;
import com.engine.salary.util.SalaryEntityUtil;
import com.engine.salary.util.SalaryEnumUtil;
import com.engine.salary.util.SalaryI18nUtil;
import com.engine.salary.util.page.PageInfo;
import com.engine.salary.util.page.SalaryPageUtil;
import com.weaver.util.threadPool.ThreadPoolUtil;
import com.weaver.util.threadPool.constant.ModulePoolEnum;
import com.weaver.util.threadPool.entity.LocalRunnable;
import dm.jdbc.util.IdGenerator;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.compress.utils.Lists;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.springframework.stereotype.Component;
import weaver.general.Util;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @description: 个税申报
 * @author: xiajun
 * @modified By: xiajun
 * @date: Created in 2022/11/10 9:24 AM
 * @version:v1.0
 */
@Slf4j
@Component
public class TaxDeclareRecordWrapper extends Service {


    private TaxDeclareRecordService taxDeclareRecordService;

    private TaxAgentService taxAgentService;

    private SalaryEmployeeService hrmCommonEmployeeService;

    private SalaryCacheService salaryCacheService;

    private TaxDeclarationService taxDeclarationService;

    private TaxDeclarationValueService taxDeclarationValueService;

    private TaxDeclarationExcelService taxDeclarationExcelService;

    private TaxDeclareEmployeeService taxDeclareEmployeeService;

    private TaxDeclareFailService taxDeclareFailService;

    /**
     * 个税申报记录列表
     *
     * @param queryParam
     * @return
     */
    public PageInfo<TaxDeclareRecordListDTO> listPage(TaxDeclarationListQueryParam queryParam) {
        PageInfo<TaxDeclareRecordPO> page = taxDeclareRecordService.listPageByParam(queryParam);
        List<TaxDeclareRecordPO> list = page.getList();

        PageInfo<TaxDeclareRecordListDTO> dtoPage = SalaryPageUtil.buildPage(queryParam.getCurrent(), queryParam.getPageSize(), TaxDeclareRecordListDTO.class);
        if (CollectionUtils.isNotEmpty(list)) {
            // 查询个税扣缴义务人
            Set<Long> taxAgentIds = SalaryEntityUtil.properties(list, TaxDeclareRecordPO::getTaxAgentId);
            List<TaxAgentPO> taxAgents = taxAgentService.listByIds(taxAgentIds);
            // 查询人员姓名
            List<Long> employeeIds = SalaryEntityUtil.properties(list, TaxDeclareRecordPO::getCreator, Collectors.toList());
            List<DataCollectionEmployee> simpleEmployees = hrmCommonEmployeeService.getEmployeeByIds(employeeIds);

            List<TaxDeclareRecordListDTO> dtoList = Lists.newArrayList();
            Map<Long, String> taxAgentNameMap = SalaryEntityUtil.convert2Map(taxAgents, TaxAgentPO::getId, TaxAgentPO::getName);
            Map<Long, String> simpleEmployeeNameMap = SalaryEntityUtil.convert2Map(simpleEmployees, DataCollectionEmployee::getEmployeeId, DataCollectionEmployee::getUsername);
            for (TaxDeclareRecordPO taxDeclareRecord : list) {
                TaxDeclareTypeEnum taxDeclareTypeEnum = SalaryEnumUtil.enumMatchByValue(taxDeclareRecord.getTaxDeclareType(), TaxDeclareTypeEnum.class);
                TaxDeclareStatusEnum taxDeclareStatusEnum = SalaryEnumUtil.enumMatchByValue(taxDeclareRecord.getTaxDeclareStatus(), TaxDeclareStatusEnum.class);
                TaxDeclareRecordListDTO taxDeclareRecordListDTO = new TaxDeclareRecordListDTO()
                        .setId(taxDeclareRecord.getId())
                        .setTaxAgentId(taxDeclareRecord.getTaxAgentId())
                        .setTaxAgentName(taxAgentNameMap.get(taxDeclareRecord.getTaxAgentId()))
                        .setSalaryMonth(taxDeclareRecord.getSalaryMonth())
                        .setTaxCycle(taxDeclareRecord.getTaxCycle())
                        .setTaxDeclareType(taxDeclareTypeEnum)
                        .setTaxDeclareTypeDesc(taxDeclareTypeEnum == null ? "" : SalaryI18nUtil.getI18nLabel(taxDeclareTypeEnum.getLabelId(), taxDeclareTypeEnum.getDefaultLabel()))
                        .setTaxDeclareStatus(taxDeclareStatusEnum)
                        .setTaxDeclareStatusDesc(taxDeclareStatusEnum == null ? "" : SalaryI18nUtil.getI18nLabel(taxDeclareStatusEnum.getLabelId(), taxDeclareStatusEnum.getDefaultLabel()))
                        .setTaxPaidAmount(SalaryEntityUtil.thousandthConvert(taxDeclareRecord.getTaxPaidAmount()))
                        .setOperateEmployeeId(taxDeclareRecord.getCreator())
                        .setOperateEmployeeName(simpleEmployeeNameMap.get(taxDeclareRecord.getCreator()))
                        .setOperateTime(SalaryDateUtil.getFormatLocalDateTime(taxDeclareRecord.getCreateTime()))
                        .setDescription(taxDeclareRecord.getRemark())
                        .setDisplayIcon(Objects.equals(taxDeclareRecord.getDisplayUpdateIcon(), 1));
                dtoList.add(taxDeclareRecordListDTO);
            }
            dtoPage.setList(dtoList);
        }
        return dtoPage;
    }

    /**
     * 个税申报表明细列表
     *
     * @param queryParam 列表查询条件
     * @return
     */
    public PageInfo listValuePage(TaxDeclarationValueListQueryParam queryParam) {
        // 查询个税申报表
        TaxDeclarationPO taxDeclaration = taxDeclarationService.getById(queryParam.getTaxDeclarationId());
        // 判断是否有权限查看
        boolean canSee = taxDeclareRecordService.checkByAuthority(taxDeclaration);
        if (!canSee) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(156515, "对不起，您暂时没有权限查看"));
        }
        // 查询个税申报表详情
        PageInfo<TaxDeclarationValuePO> page = taxDeclarationValueService.listPageByTaxDeclarationIds(queryParam,Collections.singleton(queryParam.getTaxDeclarationId()));
        TaxDeclarationValueListDTO taxDeclarationValueListDTO = taxDeclarationValueService.convert2List(taxDeclaration, page.getList());
        PageInfo<Map<String, Object>> dtoPage = new PageInfo();
        dtoPage.setList(taxDeclarationValueListDTO.getData());
        return dtoPage;
    }

    /**
     * 未报送的人员列表
     *
     * @param queryParam
     * @return
     */
    public PageInfo<AbnormalEmployeeListDTO> listEmployeePage4NotDeclare(AbnormalEmployeeListQueryParam queryParam) {
        return listEmployeePage("NotDeclare", queryParam);
    }

    /**
     * 没有申报数据的人员列表
     *
     * @param queryParam
     * @return
     */
    public PageInfo<AbnormalEmployeeListDTO> listEmployeePage4NoValue(AbnormalEmployeeListQueryParam queryParam) {
        return listEmployeePage("NoValue", queryParam);
    }

    /**
     * 申报失败的人员列表
     *
     * @param queryParam
     * @return
     */
    public PageInfo<FailEmployeeListDTO> listEmployeePage4Fail(AbnormalEmployeeListQueryParam queryParam) {
        // 查询个税申报记录
        TaxDeclareRecordPO taxDeclareRecord = taxDeclareRecordService.getById(queryParam.getTaxDeclareRecordId());
        // 查询申报失败的数据
        List<TaxDeclareFailPO> taxDeclareFailPOPageInfo = taxDeclareFailService.listPageByTaxDeclareRecordIds(Collections.singleton(taxDeclareRecord.getId()));
        // 转换成dto
        PageInfo<FailEmployeeListDTO> dtoPage = SalaryPageUtil.buildPage(queryParam.getCurrent(), queryParam.getPageSize(), FailEmployeeListDTO.class);
        dtoPage.setList(taxDeclareFailService.convert2FailEmployeeList(taxDeclareRecord, taxDeclareFailPOPageInfo));
        // 转成前端所需的格式
        return dtoPage;
    }

    private PageInfo<AbnormalEmployeeListDTO> listEmployeePage(String key, AbnormalEmployeeListQueryParam queryParam) {
        // 查询个税申报记录
        TaxDeclareRecordPO taxDeclareRecord = taxDeclareRecordService.getById(queryParam.getTaxDeclareRecordId());
        queryParam.setTaxAgentId(taxDeclareRecord.getTaxAgentId());
        queryParam.setTaxCycle(taxDeclareRecord.getTaxCycle());
        if (StringUtils.isEmpty(queryParam.getKeyword())) {
            // 查询个税申报记录的人员
            PageInfo<TaxDeclareEmployeePO> page = SalaryPageUtil.buildPage(queryParam.getCurrent(), queryParam.getPageSize(), TaxDeclareEmployeePO.class);
            if (StringUtils.equals("NotDeclare", key)) {
                page = taxDeclareEmployeeService.listPage4NotDeclareByParam(queryParam);
            } else if (StringUtils.equals("NoValue", key)) {
                page = taxDeclareEmployeeService.listPage4NoValueByParam(queryParam);
            }
            PageInfo<AbnormalEmployeeListDTO> dtoPage = SalaryPageUtil.buildPage(queryParam.getCurrent(), queryParam.getPageSize(), AbnormalEmployeeListDTO.class);
            dtoPage.setList(taxDeclareEmployeeService.convert2AbnormalEmployeeList(taxDeclareRecord, page.getList()));
            return dtoPage;
        } else {
            // 查询条件中包含"keyword"时，不好通过SQL分页，所以在内存中分页
            List<TaxDeclareEmployeePO> taxDeclareEmployees = Collections.emptyList();
            if (StringUtils.equals("NotDeclare", key)) {
                taxDeclareEmployees = taxDeclareEmployeeService.list4NotDeclareByParam(queryParam);
            } else if (StringUtils.equals("NoValue", key)) {
                taxDeclareEmployees = taxDeclareEmployeeService.list4NoValueByParam(queryParam);
            }
            List<AbnormalEmployeeListDTO> dtos = taxDeclareEmployeeService.convert2AbnormalEmployeeList(taxDeclareRecord, taxDeclareEmployees)
                    .stream()
                    .filter(e -> StringUtils.contains(e.getEmployeeName(), queryParam.getKeyword())
                            || StringUtils.contains(e.getJobNum(), queryParam.getKeyword())
                            || StringUtils.contains(e.getCardNum(), queryParam.getKeyword()))
                    .collect(Collectors.toList());
            PageInfo<AbnormalEmployeeListDTO> dtoPage = SalaryPageUtil.buildPage(queryParam.getCurrent(), queryParam.getPageSize(), dtos, AbnormalEmployeeListDTO.class);
            return dtoPage;
        }
    }

    /**
     * 获取个税申报记录的表单
     *
     * @param id
     * @return
     */
    public Map getForm(Long id) {
//        TaxDeclareRecordFormDTO formDTO = new TaxDeclareRecordFormDTO();
//        formDTO.setTaxAgentRange(TaxAgentRangeEnum.SELECT_TAX_AGENT);
//        // 判断当前是否开启了分权
//        Boolean openDevolution = taxAgentService.isOpenDevolution();
//        Boolean isChief = taxAgentService.isChief((long)user.getUID());
//        // 转换成前端所需的数据格式
//        WeaForm weaForm = SalaryFormatUtil.<TaxDeclareRecordFormDTO>getInstance().buildForm(TaxDeclareRecordFormDTO.class, formDTO);
//        weaForm.getItems().forEach((k, v) -> {
//            if (StringUtils.equals("salaryMonth", k)) {
//                Map<String, Object> otherParams = new HashMap<>();
//                otherParams.put("type", "month");
//                v.setOtherParams(otherParams);
//            }
//            // 未开启分权，没有"作为管理员的个税扣缴义务人"
//            if (!openDevolution && StringUtils.equals("taxAgentRange", k)) {
//                v.getOptions().remove(1);
//            }
//            // 开启分权，但不是总管理员，没有"所有个税扣缴义务人"
//            if (openDevolution && !isChief && StringUtils.equals("taxAgentRange", k)) {
//                v.getOptions().remove(0);
//            }
//        });
        return new HashMap();
    }

    /**
     * 获取个税申报记录下的个税申报表TAB
     *
     * @param id
     * @return
     */
    public List<TaxDeclarationTabDTO> getTaxDeclarationTab(Long id) {
        // 查询个税申报记录
        TaxDeclareRecordPO taxDeclareRecord = taxDeclareRecordService.getById(id);
        // 查询个税申报记录下的个税申报表
        List<TaxDeclarationPO> taxDeclarations = taxDeclarationService.listByTaxCycleAndTaxAgentIds(SalaryDateUtil.localDate2YearMonth(taxDeclareRecord.getTaxCycle()),
                Collections.singleton(taxDeclareRecord.getTaxAgentId()));
        taxDeclarations = taxDeclarations.stream()
                .filter(e -> Objects.equals(e.getControlView(), 0) || Objects.equals(e.getCreator(), (long)user.getUID()))
                .collect(Collectors.toList());
        Map<Integer, TaxDeclarationPO> taxDeclarationMap = SalaryEntityUtil.convert2Map(taxDeclarations, TaxDeclarationPO::getIncomeCategory);
        List<TaxDeclarationTabDTO> tabs = Lists.newArrayList();
        for (IncomeCategoryEnum incomeCategoryEnum : IncomeCategoryEnum.values()) {
            TaxDeclarationPO taxDeclaration = taxDeclarationMap.get(incomeCategoryEnum.getValue());
            if (taxDeclaration != null) {
                TaxDeclarationTabDTO taxDeclarationTabDTO = new TaxDeclarationTabDTO()
                        .setTabName(SalaryI18nUtil.getI18nLabel(incomeCategoryEnum.getLabelId(), incomeCategoryEnum.getDefaultLabel()))
                        .setIncomeCategory(incomeCategoryEnum)
                        .setTaxDeclarationId(taxDeclaration.getId());
                tabs.add(taxDeclarationTabDTO);
            }
        }
        return tabs;
    }

    /**
     * 查询个税申报表的基本信息
     *
     * @param id        个税申报表id
     * @return
     */
    public TaxDeclarationInfoDTO getTaxDeclarationInfoById(Long id) {
        // 查询个税申报表
        TaxDeclareRecordPO taxDeclareRecord = taxDeclareRecordService.getById(id);
        if (Objects.isNull(taxDeclareRecord)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(98877, "个税申报表不存在或已删除"));
        }
        AbnormalEmployeeListQueryParam queryParam = new AbnormalEmployeeListQueryParam()
                .setTaxDeclareRecordId(taxDeclareRecord.getId())
                .setTaxAgentId(taxDeclareRecord.getTaxAgentId())
                .setTaxCycle(taxDeclareRecord.getTaxCycle());
        // 查询是否存在有未报送的人
        List<TaxDeclareEmployeePO> notDeclareTaxDeclareEmployees = taxDeclareEmployeeService.list4NotDeclareByParam(queryParam);
        // 查询是否存在没有申报数据的人
        List<TaxDeclareEmployeePO> noValueTaxDeclareEmployees = taxDeclareEmployeeService.list4NoValueByParam(queryParam);
        // 查询是否存在申报失败的人
        List<TaxDeclareFailPO> taxDeclareFails = taxDeclareFailService.listByTaxDeclareRecordIds(Collections.singleton(taxDeclareRecord.getId()));
        // 查询个税扣缴义务人
        TaxAgentPO taxAgentPO = taxAgentService.getById(taxDeclareRecord.getTaxAgentId());
        TaxDeclareTypeEnum taxDeclareTypeEnum = SalaryEnumUtil.enumMatchByValue(taxDeclareRecord.getTaxDeclareType(), TaxDeclareTypeEnum.class);
        TaxDeclareStatusEnum taxDeclareStatusEnum = SalaryEnumUtil.enumMatchByValue(taxDeclareRecord.getTaxDeclareStatus(), TaxDeclareStatusEnum.class);
        return TaxDeclarationInfoDTO.builder()
                .salaryMonth(taxDeclareRecord.getSalaryMonth())
                .taxCycle(taxDeclareRecord.getTaxCycle())
                .taxAgentId(taxDeclareRecord.getTaxAgentId())
                .taxAgentName(Optional.ofNullable(taxAgentPO).map(TaxAgentPO::getName).orElse(""))
                .declareType(taxDeclareTypeEnum)
                .declareTypeDesc(taxDeclareTypeEnum == null ? "" : SalaryI18nUtil.getI18nLabel(taxDeclareTypeEnum.getLabelId(), taxDeclareTypeEnum.getDefaultLabel()))
                .declareStatus(taxDeclareStatusEnum)
                .declareStatusDesc(taxDeclareStatusEnum == null ? "" : SalaryI18nUtil.getI18nLabel(taxDeclareStatusEnum.getLabelId(), taxDeclareStatusEnum.getDefaultLabel()))
                .declareErrorMsg(taxDeclareRecord.getTaxDeclareErrorMsg())
                .displayIcon(Objects.equals(taxDeclareRecord.getDisplayUpdateIcon(), 1))
                .declareFailSize(taxDeclareFails.size())
                .abnormalSize(notDeclareTaxDeclareEmployees.size() + noValueTaxDeclareEmployees.size())
                .taxPaidAmount(SalaryEntityUtil.thousandthConvert(taxDeclareRecord.getTaxPaidAmount()))
                .build();
    }

    /**
     * 保存
     *
     * @param saveParam 保存参数
     */
    public String save(TaxDeclarationSaveParam saveParam) {
        TaxDeclarationRateDTO taxDeclarationRate = new TaxDeclarationRateDTO().setStatus(true)
                .setIndex(Util.null2String(IdGenerator.generate()))
                .setMsg(SalaryI18nUtil.getI18nLabel(95836, "生成申报表"));
        salaryCacheService.set(SalaryCacheKey.TAX_DECLARATION + taxDeclarationRate.getIndex(), taxDeclarationRate);
        LocalRunnable localRunnable = new LocalRunnable() {
            @Override
            public void execute() {
                try {
                    taxDeclareRecordService.save(saveParam);
                    taxDeclarationRate.setStatus(true).setFinish(true);
                } catch (SalaryRunTimeException e) {
                    taxDeclarationRate.setStatus(false).setFinish(true).setMsg(e.getMessage());
                } catch (Exception e) {
                    log.error("个税申报表生成报错：{}", e.getMessage(), e);
                    taxDeclarationRate.setStatus(false).setFinish(true).setMsg(SalaryI18nUtil.getI18nLabel(187276, "个税申报表生成报错：") + e.getMessage());
                } finally {
                    salaryCacheService.set(SalaryCacheKey.TAX_DECLARATION + taxDeclarationRate.getIndex(), taxDeclarationRate);
                }
            }
        };
        ThreadPoolUtil.fixedPoolExecute(ModulePoolEnum.OTHER, "saveTaxDeclaration", localRunnable);
        return taxDeclarationRate.getIndex();
    }

    /**
     * 更新个税申报表的待刷新数据的标识
     *
     * @param id
     */
    public void updateIcon(Long id) {
        taxDeclareRecordService.updateIcon(id, NumberUtils.INTEGER_ZERO);
    }

    /**
     * 删除个税申报表
     *
     * @param ids
     */
    public void delete(Collection<Long> ids) {
        taxDeclareRecordService.deleteByIds(ids);
    }

    /**
     * 获取个税申报表是否已经生成
     *
     * @param index
     * @return
     */
    public TaxDeclarationRateDTO getRate(String index) {
        return salaryCacheService.get(SalaryCacheKey.TAX_DECLARATION + index);
    }

    /**
     * 申报
     *
     * @param id
     */
    public String declare(Long id) {
        checkBefore(id);
        TaxDeclarationRateDTO taxDeclarationRate = new TaxDeclarationRateDTO().setStatus(true).setIndex(Util.null2String(id))
                .setMsg(SalaryI18nUtil.getI18nLabel(156454, "在线申报"));
        salaryCacheService.set(SalaryCacheKey.TAX_DECLARATION + taxDeclarationRate.getIndex(), taxDeclarationRate);
        LocalRunnable localRunnable = new LocalRunnable() {
            @Override
            public void execute() {
                try {
                    taxDeclareRecordService.declare(id);
                    taxDeclarationRate.setFinish(true);
                } catch (SalaryRunTimeException e) {
                    taxDeclarationRate.setStatus(false).setFinish(true).setMsg(e.getMessage());
                } catch (Exception e) {
                    log.error("在线申报失败：{}", e.getMessage(), e);
                    taxDeclarationRate.setStatus(false).setFinish(true).setMsg(SalaryI18nUtil.getI18nLabel(187274, "在线申报失败：") + e.getMessage());
                } finally {
                    salaryCacheService.set(SalaryCacheKey.TAX_DECLARATION + taxDeclarationRate.getIndex(), taxDeclarationRate);
                }
            }
        };
        ThreadPoolUtil.fixedPoolExecute(ModulePoolEnum.OTHER, "declare", localRunnable);
        return taxDeclarationRate.getIndex();
    }

    /**
     * 获取申报反馈
     *
     * @param id
     */
    public String getDeclareFeedback(Long id) {
        checkBefore(id);
        TaxDeclarationRateDTO taxDeclarationRate = new TaxDeclarationRateDTO().setStatus(true).setIndex(Util.null2String(id))
                .setMsg(SalaryI18nUtil.getI18nLabel(182680, "获取申报反馈"));
        salaryCacheService.set(SalaryCacheKey.TAX_DECLARATION + taxDeclarationRate.getIndex(), taxDeclarationRate);
        LocalRunnable localRunnable = new LocalRunnable() {
            @Override
            public void execute() {
                try {
                    taxDeclareRecordService.getDeclareFeedback(id, taxDeclarationRate);
                    taxDeclarationRate.setFinish(true);
                } catch (SalaryRunTimeException e) {
                    taxDeclarationRate.setStatus(false).setFinish(true).setMsg(e.getMessage());
                } catch (Exception e) {
                    log.error("获取申报反馈失败：{}", e.getMessage(), e);
                    taxDeclarationRate.setStatus(false).setFinish(true).setMsg(SalaryI18nUtil.getI18nLabel(187255, "获取申报反馈失败：") + e.getMessage());
                } finally {
                    salaryCacheService.set(SalaryCacheKey.TAX_DECLARATION + taxDeclarationRate.getIndex(), taxDeclarationRate);
                }
            }
        };
        ThreadPoolUtil.fixedPoolExecute(ModulePoolEnum.OTHER, "getDeclareFeedback", localRunnable);
        return taxDeclarationRate.getIndex();
    }

    /**
     * 作废
     *
     * @param id
     */
    public String cancelDeclare(Long id) {
        checkBefore(id);
        TaxDeclarationRateDTO taxDeclarationRate = new TaxDeclarationRateDTO().setStatus(true).setIndex(Util.null2String(id))
                .setMsg(SalaryI18nUtil.getI18nLabel(158842, "作废申报"));
        salaryCacheService.set(SalaryCacheKey.TAX_DECLARATION + taxDeclarationRate.getIndex(), taxDeclarationRate);
        LocalRunnable localRunnable = new LocalRunnable() {
            @Override
            public void execute() {
                try {
                    taxDeclareRecordService.cancelDeclare(id);
                    taxDeclarationRate.setFinish(true);
                } catch (SalaryRunTimeException e) {
                    taxDeclarationRate.setStatus(false).setFinish(true).setMsg(e.getMessage());
                } catch (Exception e) {
                    log.error("作废申报失败：{}", e.getMessage(), e);
                    taxDeclarationRate.setStatus(false).setFinish(true).setMsg(SalaryI18nUtil.getI18nLabel(187272, "作废申报失败：") + e.getMessage());
                } finally {
                    salaryCacheService.set(SalaryCacheKey.TAX_DECLARATION + taxDeclarationRate.getIndex(), taxDeclarationRate);
                }
            }
        };
        ThreadPoolUtil.fixedPoolExecute(ModulePoolEnum.OTHER, "cancel", localRunnable);
        return taxDeclarationRate.getIndex();
    }

    /**
     * 获取作废反馈
     *
     * @param id
     */
    public String getCancelFeedback(Long id) {
        checkBefore(id);
        TaxDeclarationRateDTO taxDeclarationRate = new TaxDeclarationRateDTO().setStatus(true).setIndex(Util.null2String(id))
                .setMsg(SalaryI18nUtil.getI18nLabel(182681, "获取作废申报反馈"));
        salaryCacheService.set(SalaryCacheKey.TAX_DECLARATION + taxDeclarationRate.getIndex(), taxDeclarationRate);
        LocalRunnable localRunnable = new LocalRunnable() {
            @Override
            public void execute() {
                try {
                    taxDeclareRecordService.getCancelFeedback(id, taxDeclarationRate);
                    taxDeclarationRate.setFinish(true);
                } catch (SalaryRunTimeException e) {
                    taxDeclarationRate.setStatus(false).setFinish(true).setMsg(e.getMessage());
                } catch (Exception e) {
                    log.error("获取作废反馈结果失败：{}", e.getMessage(), e);
                    taxDeclarationRate.setStatus(false).setFinish(true).setMsg(SalaryI18nUtil.getI18nLabel(187270, "获取作废反馈结果失败：") + e.getMessage());
                } finally {
                    salaryCacheService.set(SalaryCacheKey.TAX_DECLARATION + taxDeclarationRate.getIndex(), taxDeclarationRate);
                }
            }
        };
        ThreadPoolUtil.fixedPoolExecute(ModulePoolEnum.OTHER, "getCancelFeedback", localRunnable);
        return taxDeclarationRate.getIndex();
    }

    /**
     * 更正申报
     *
     * @param id
     * @return
     */
    public String updateDeclare(Long id) {
        checkBefore(id);
        TaxDeclarationRateDTO taxDeclarationRate = new TaxDeclarationRateDTO().setStatus(true).setIndex(Util.null2String(id))
                .setMsg(SalaryI18nUtil.getI18nLabel(177637, "更正申报"));
        salaryCacheService.set(SalaryCacheKey.TAX_DECLARATION + taxDeclarationRate.getIndex(), taxDeclarationRate);
        LocalRunnable localRunnable = new LocalRunnable() {
            @Override
            public void execute() {
                try {
                    taxDeclareRecordService.updateDeclare(id);
                    taxDeclarationRate.setFinish(true);
                } catch (SalaryRunTimeException e) {
                    taxDeclarationRate.setStatus(false).setFinish(true).setMsg(e.getMessage());
                } catch (Exception e) {
                    log.error("更正申报失败：{}", e.getMessage(), e);
                    taxDeclarationRate.setStatus(false).setFinish(true).setMsg(SalaryI18nUtil.getI18nLabel(187269, "更正申报失败：") + e.getMessage());
                } finally {
                    salaryCacheService.set(SalaryCacheKey.TAX_DECLARATION + taxDeclarationRate.getIndex(), taxDeclarationRate);
                }
            }
        };
        ThreadPoolUtil.fixedPoolExecute(ModulePoolEnum.OTHER, "updateDeclare", localRunnable);
        return taxDeclarationRate.getIndex();
    }

    /**
     * 税局端申报状态查询
     *
     * @param id
     * @return
     */
    public String queryDeclareStatus(Long id) {
        return taxDeclareRecordService.queryDeclareStatus(id);
    }

    /**
     * 税局端申报明细查询
     *
     * @param id
     * @return
     */
    public String queryCompanyIncomes(Long id) {
        return taxDeclareRecordService.queryCompanyIncomes(id);
    }

    /**
     * 刷新数据
     *
     * @param id
     * @return
     */
    public String refreshData(Long id) {
        checkBefore(id);
        TaxDeclarationRateDTO taxDeclarationRate = new TaxDeclarationRateDTO().setStatus(true).setIndex(Util.null2String(id))
                .setMsg(SalaryI18nUtil.getI18nLabel(156447, "刷新数据"));
        salaryCacheService.set(SalaryCacheKey.TAX_DECLARATION + taxDeclarationRate.getIndex(), taxDeclarationRate);
        LocalRunnable localRunnable = new LocalRunnable() {
            @Override
            public void execute() {
                try {
                    taxDeclareRecordService.refreshData(id);
                    taxDeclarationRate.setFinish(true);
                } catch (SalaryRunTimeException e) {
                    taxDeclarationRate.setStatus(false).setFinish(true).setMsg(e.getMessage());
                } catch (Exception e) {
                    log.error("刷新数据失败：{}", e.getMessage(), e);
                    taxDeclarationRate.setStatus(false).setFinish(true).setMsg(SalaryI18nUtil.getI18nLabel(187268, "刷新数据失败：") + e.getMessage());
                } finally {
                    salaryCacheService.set(SalaryCacheKey.TAX_DECLARATION + taxDeclarationRate.getIndex(), taxDeclarationRate);
                }
            }
        };
        ThreadPoolUtil.fixedPoolExecute(ModulePoolEnum.OTHER, "refreshData", localRunnable);
        return taxDeclarationRate.getIndex();
    }

    private void checkBefore(Long id) {
        TaxDeclarationRateDTO taxDeclarationRate = salaryCacheService.get(SalaryCacheKey.TAX_DECLARATION + Util.null2String(id));
        if (taxDeclarationRate != null && !taxDeclarationRate.isFinish()) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(182691, "当前正处于「{0}」中，请稍后再试").replace("{0}", taxDeclarationRate.getMsg()));
        }
    }

//    /**
//     * 导出个税申报明细列表
//     *
//     * @param queryParam
//     * @return
//     */
//    public Map<String, Object> exportTaxDeclarationValue(TaxDeclarationValueListQueryParam queryParam) {
//        ExcelExportParam excelExportParam = new ExcelExportParam()
//                .setBiz(String.valueOf(IdGenerator.generate()))
//                .setModule(EntityType.hrmsalary.name())
//                .setFunction("exportTaxDeclarationValue");
//        LocalRunnable localRunnable = new LocalRunnable() {
//            @Override
//            public void execute() {
//                taxDeclarationExcelService.exportTaxDeclarationValue(excelExportParam, queryParam, simpleEmployee);
//            }
//        };
//        ThreadPoolUtil.fixedPoolExecute(ModulePoolEnum.OTHER, "exportTaxDeclarationValue", localRunnable);
//        return JsonUtil.parseMap(excelExportParam, Object.class);
//    }
//
//    /**
//     * 导出未报送的人员列表
//     *
//     * @param queryParam
//     * @param simpleEmployee
//     * @return
//     */
//    public Map<String, Object> exportEmployee4NotDeclare(AbnormalEmployeeListQueryParam queryParam) {
//        ExcelExportParam excelExportParam = new ExcelExportParam()
//                .setBiz(String.valueOf(IdGenerator.generate()))
//                .setModule(EntityType.hrmsalary.name())
//                .setFunction("exportEmployee4NotDeclare");
//        LocalRunnable localRunnable = new LocalRunnable() {
//            @Override
//            public void execute() {
//                taxDeclarationExcelService.exportEmployee4NotDeclare(excelExportParam, queryParam, simpleEmployee);
//            }
//        };
//        ThreadPoolUtil.fixedPoolExecute(ModulePoolEnum.OTHER, "exportEmployee4NotDeclare", localRunnable);
//        return JsonUtil.parseMap(excelExportParam, Object.class);
//    }
//
//    /**
//     * 导出没有申报数据的人员列表
//     *
//     * @param queryParam
//     * @param simpleEmployee
//     * @return
//     */
//    public Map<String, Object> exportEmployee4NoValue(AbnormalEmployeeListQueryParam queryParam, SimpleEmployee simpleEmployee) {
//        ExcelExportParam excelExportParam = new ExcelExportParam()
//                .setBiz(String.valueOf(IdGenerator.generate()))
//                .setModule(EntityType.hrmsalary.name())
//                .setFunction("exportEmployee4NoValue");
//        LocalRunnable localRunnable = new LocalRunnable() {
//            @Override
//            public void execute() {
//                taxDeclarationExcelService.exportEmployee4NoValue(excelExportParam, queryParam, simpleEmployee);
//            }
//        };
//        ThreadPoolUtil.fixedPoolExecute(ModulePoolEnum.OTHER, "exportEmployee4NoValue", localRunnable);
//        return JsonUtil.parseMap(excelExportParam, Object.class);
//    }
//
//    /**
//     * 导出申报失败的人员列表
//     *
//     * @param queryParam
//     * @param simpleEmployee
//     * @return
//     */
//    public Map<String, Object> exportEmployee4Fail(AbnormalEmployeeListQueryParam queryParam, SimpleEmployee simpleEmployee) {
//        ExcelExportParam excelExportParam = new ExcelExportParam()
//                .setBiz(String.valueOf(IdGenerator.generate()))
//                .setModule(EntityType.hrmsalary.name())
//                .setFunction("exportEmployee4Fail");
//        LocalRunnable localRunnable = new LocalRunnable() {
//            @Override
//            public void execute() {
//                taxDeclarationExcelService.exportEmployee4Fail(excelExportParam, queryParam, simpleEmployee);
//            }
//        };
//        ThreadPoolUtil.fixedPoolExecute(ModulePoolEnum.OTHER, "exportEmployee4Fail", localRunnable);
//        return JsonUtil.parseMap(excelExportParam, Object.class);
//    }
}