package com.engine.salary.wrapper;

import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service;
import com.engine.salary.biz.EmployBiz;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import com.engine.salary.entity.salaryarchive.dto.SalaryArchiveBaseInfoFormDTO;
import com.engine.salary.entity.salaryarchive.dto.SalaryArchiveFormDTO;
import com.engine.salary.entity.salaryarchive.dto.SalaryArchiveListDTO;
import com.engine.salary.entity.salaryarchive.param.SalaryArchiveDimissionSaveParam;
import com.engine.salary.entity.salaryarchive.param.SalaryArchiveImportHandleParam;
import com.engine.salary.entity.salaryarchive.param.SalaryArchiveQueryParam;
import com.engine.salary.entity.salaryarchive.po.SalaryArchiveDimissionPO;
import com.engine.salary.entity.salaryarchive.po.SalaryArchiveItemPO;
import com.engine.salary.entity.salaryarchive.po.SalaryArchivePO;
import com.engine.salary.entity.salaryarchive.po.SalaryArchiveTaxAgentPO;
import com.engine.salary.entity.salaryitem.po.SalaryItemPO;
import com.engine.salary.entity.taxrate.TaxAgent;
import com.engine.salary.enums.salaryarchive.SalaryArchiveImportTypeEnum;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.service.SalaryArchiveItemService;
import com.engine.salary.service.SalaryArchiveService;
import com.engine.salary.service.TaxAgentService;
import com.engine.salary.service.impl.SalaryArchiveItemServiceImpl;
import com.engine.salary.service.impl.SalaryArchiveServiceImpl;
import com.engine.salary.service.impl.TaxAgentServiceImpl;
import com.engine.salary.util.SalaryDateUtil;
import com.engine.salary.util.SalaryI18nUtil;
import com.engine.salary.util.page.PageInfo;
import com.google.common.collect.Lists;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import weaver.hrm.User;

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

/**
 * 薪资档案
 * <p>Copyright: Copyright (c) 2022</p>
 * <p>Company: 泛微软件</p>
 *
 * @author qiantao
 * @version 1.0
 **/
public class SalaryArchiveWrapper extends Service {

    private SalaryArchiveService getSalaryArchiveService(User user) {
        return (SalaryArchiveService) ServiceUtil.getService(SalaryArchiveServiceImpl.class, user);
    }

    private SalaryArchiveItemService getSalaryArchiveItemService(User user) {
        return (SalaryArchiveItemService) ServiceUtil.getService(SalaryArchiveItemServiceImpl.class, user);
    }

    private EmployBiz employeeService = new EmployBiz();

    private TaxAgentService getTaxAgentService(User user) {
        return (TaxAgentService) ServiceUtil.getService(TaxAgentServiceImpl.class, user);
    }

//    private SalaryBatchService salaryBatchService;
//    private ExecutorService taskExecutor;


    /**
     * 薪资档案列表（分页）
     *
     * @param queryParam
     * @return
     */
    public PageInfo<Map<String, Object>> list(SalaryArchiveQueryParam queryParam) {
        Collection<TaxAgent> taxAgentLists = getTaxAgentService(user).findAll();

        PageInfo<SalaryArchiveListDTO> pageInfo = getSalaryArchiveService(user).listPage(queryParam);

        Collection<SalaryArchiveListDTO> salaryArchives = pageInfo.getList();
        // 获取所有可被引用的薪资项目
        List<SalaryItemPO> salaryItems = getSalaryArchiveItemService(user).getCanAdjustSalaryItems();
        List<Map<String, Object>> listMaps = getSalaryArchiveService(user).buildSalaryArchiveData(salaryArchives, taxAgentLists, salaryItems, Boolean.TRUE);

        PageInfo<Map<String, Object>> pageInfos = new PageInfo<Map<String, Object>>(listMaps);
        pageInfos.setTotal(listMaps.size());
        pageInfos.setPageNum(queryParam.getCurrent());
        pageInfos.setPageSize(queryParam.getPageSize());

        return pageInfos;
    }

    /**
     * 获取薪资档案详情表单
     *
     * @param salaryArchiveId
     * @return
     */
    public SalaryArchiveFormDTO getFrom(Long salaryArchiveId) {
        if (salaryArchiveId == null) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100425, "薪资档案id不能为空"));
        }
        SalaryArchivePO po = getSalaryArchiveService(user).getById(salaryArchiveId);
        if (po == null) {
            throw new SalaryRunTimeException(String.format(SalaryI18nUtil.getI18nLabel(100463, "薪资档案不存在") + "[id:%s]", salaryArchiveId));
        }

        List<DataCollectionEmployee> employeeList = employeeService.getEmployeeByIdsAll(Collections.singletonList(po.getEmployeeId()));
        if (CollectionUtils.isEmpty(employeeList)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100465, "薪资档案员工信息不存在"));
        }

        // 获取当前已生效个税扣缴义务人
        List<SalaryArchiveTaxAgentPO> taxAgentList = getSalaryArchiveService(user).getCurrentEffectiveTaxAgentList(Collections.singletonList(salaryArchiveId));
        // 获取所有个税扣缴义务人
        Collection<TaxAgent> taxAgentLists = getTaxAgentService(user).findAll();
        String taxAgent = "";
        if (CollectionUtils.isNotEmpty(taxAgentList)) {
            SalaryArchiveTaxAgentPO salaryArchiveTaxAgent = taxAgentList.get(0);
            Optional<TaxAgent> taxAgentOptional = taxAgentLists.stream().filter(f -> f.getId().equals(salaryArchiveTaxAgent.getTaxAgentId())).findFirst();
            taxAgent = taxAgentOptional.isPresent() ? taxAgentOptional.get().getName() : taxAgent;
        }

        // 1.基本信息表单
        Map<String, Object> baseInfo = new HashMap<>();
        DataCollectionEmployee employee = employeeList.get(0);
        SalaryArchiveBaseInfoFormDTO build = SalaryArchiveBaseInfoFormDTO.builder()
                .username(employee.getUsername())
                .department(employee.getDepartmentName())
                .position(employee.getJobtitleName() == null ? "" : employee.getJobtitleName())
                .hiredate(SalaryDateUtil.getFormatLocalDate(employee.getCompanystartdate()))
                .mobile(employee.getMobile())
                .taxAgent(taxAgent)
                .build();
        baseInfo.put("employee", build);

        List<Map<String, Object>> salaryItems = Lists.newArrayList();
        // 获取所有可被引用的薪资项目
        List<SalaryItemPO> salaryItemList = getSalaryArchiveItemService(user).getCanAdjustSalaryItems();
        Collection<Long> salaryItemIds = salaryItemList.stream().map(SalaryItemPO::getId).collect(Collectors.toList());
        List<SalaryArchiveItemPO> salaryArchiveItemList = getSalaryArchiveService(user).getCurrentEffectiveItemList(Collections.singletonList(salaryArchiveId), salaryItemIds);
        salaryArchiveItemList.forEach(m -> {
            Optional<SalaryItemPO> optionalItem = salaryItemList.stream().filter(f -> f.getId().equals(m.getSalaryItemId())).findFirst();
            if (optionalItem.isPresent()) {
                Map<String, Object> salaryItemMap = new LinkedHashMap<>();
                salaryItemMap.put("id", m.getId());
                salaryItemMap.put("name", optionalItem.get().getName());
                salaryItemMap.put("value", m.getItemValue());
                salaryItems.add(salaryItemMap);
            }
        });

        return SalaryArchiveFormDTO.builder()
                .id(salaryArchiveId)
                .employeeId(employee.getEmployeeId())
                .baseInfo(baseInfo)
                .adjustSalaryItems(salaryItems)
                .build();
    }


    /**
     * 获取离职时段设置表单
     *
     * @return
     */
    public Map<String, Object> getDimissionSetForm() {
        List<SalaryArchiveDimissionPO> dimissionSets = getSalaryArchiveService(user).dimissionSets();
        Map<String, Object> data = new LinkedHashMap<>();
        if (CollectionUtils.isNotEmpty(dimissionSets)) {
            data.put("dimissionTimeInterval", dimissionSets.get(0).getDimissionTimeInterval());
        }
        return data;
    }

    /**
     * 保存离职时段设置
     *
     * @param saveParam
     * @return
     */
    public String saveDimissionSet(SalaryArchiveDimissionSaveParam saveParam) {
        return getSalaryArchiveService(user).saveDimissionSet(saveParam);
    }

    public List<Map<String, Object>> getImportTypes() {
        List<Map<String, Object>> importTypes = Arrays.stream(SalaryArchiveImportTypeEnum.values()).map(m -> {
            Map<String, Object> map = new HashMap<>(2);
            map.put("id", String.valueOf(m.getValue()));
            map.put("content", SalaryI18nUtil.getI18nLabel(m.getLabelId(), m.getDefaultLabel()));
            return map;
        }).collect(Collectors.toList());
        return importTypes;
    }

//    /**
//     * 导出薪资档案
//     *
//     * @param queryParam
//     * @param employeeId
//     * @param tenantKey
//     * @return
//     */
//    public Map<String, Object> exportList(SalaryArchiveQueryParam queryParam, Long employeeId, String tenantKey) {
//        // 构建异步导出参数
//        Map<String, Object> map = salaryBatchService.buildeExportParam("exportSalaryArchive");
//        String username = UserContext.getCurrentUser().getUsername();
//        String eteamsId = TenantRpcContext.getEteamsId();
//        taskExecutor.execute(() -> {
//            try {
//                DSTenantKeyThreadVar.tenantKey.set(tenantKey);
//                getSalaryArchiveService(user).exportList(map, username, eteamsId, queryParam, employeeId, tenantKey);
//            } finally {
//                DSTenantKeyThreadVar.tenantKey.remove();
//            }
//        });
//
//        return map;
//    }
//

    /**
     * 下载导入模板
     *
     * @param queryParam
     * @return
     */
    public XSSFWorkbook downloadTemplate(SalaryArchiveQueryParam queryParam) {
        SalaryArchiveImportTypeEnum salaryArchiveImportTypeEnum = SalaryArchiveImportTypeEnum.parseByValue(queryParam.getImportType());
        if (salaryArchiveImportTypeEnum == null) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(100593, "导入类型不正确"));
        }

        return getSalaryArchiveService(user).downloadTemplate(SalaryArchiveImportTypeEnum.parseByValue(queryParam.getImportType()), queryParam);
    }

    public Map<String, Object> preview(SalaryArchiveImportHandleParam param) {
        return getSalaryArchiveService(user).preview(param);
    }

    public void importSalaryArchive(SalaryArchiveImportHandleParam param) {
        getSalaryArchiveService(user).importSalaryArchive(param);
    }


//
//    /**
//     * 获取导入参数
//     *
//     * @return
//     */
//    public ExcelImportParam getImportParams() {
//        return salaryBatchService.buildImportParam("importSalaryArchive",
//                "importSalaryArchive",
//                SalaryI18nUtil.getI18nLabel(TenantContext.getCurrentTenantKey(), UserContext.getCurrentEmployeeId(), 85368, "薪资档案"),
//                null,
//                null);
//    }
}