package com.engine.salary.wrapper;

import com.cloudstore.eccom.pc.table.WeaTableColumn;
import com.cloudstore.eccom.result.WeaResultMsg;
import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service;
import com.engine.salary.biz.EmployBiz;
import com.engine.salary.component.SalaryWeaTable;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import com.engine.salary.entity.salaryarchive.bo.SalaryArchiveBO;
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.*;
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.taxagent.dto.TaxAgentListDTO;
import com.engine.salary.entity.taxagent.po.TaxAgentPO;
import com.engine.salary.enums.UserStatusEnum;
import com.engine.salary.enums.salaryarchive.*;
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.SalaryI18nUtil;
import com.engine.salary.util.page.PageInfo;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import weaver.conn.RecordSet;
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 ServiceUtil.getService(SalaryArchiveServiceImpl.class, user);
    }

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

    private EmployBiz employeeService = new EmployBiz();

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

    /**
     * 薪资档案列表（分页）
     *
     * @param queryParam
     * @return
     */
    public Map<String, Object> list(SalaryArchiveQueryParam queryParam) {
        //薪资档案列表
        PageInfo<SalaryArchiveListDTO> pageInfo = getSalaryArchiveService(user).listPage(queryParam);
        Collection<SalaryArchiveListDTO> salaryArchives = pageInfo.getList();

        //所有个税扣缴义务人
        Collection<TaxAgentPO> taxAgentLists = getTaxAgentService(user).listAll();

        // 获取所有可被引用的薪资项目
        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(pageInfo.getTotal());
        pageInfos.setPageNum(pageInfo.getPageNum());
        pageInfos.setPageSize(pageInfo.getPageSize());


        //动态列组装
        List<WeaTableColumn> columns = SalaryArchiveBO.buildSalaryArchiveTable(salaryItems);

        SalaryWeaTable<SalaryArchiveListDTO> table = new SalaryWeaTable<SalaryArchiveListDTO>(user, SalaryArchiveListDTO.class);
        table.setColumns(columns);


        WeaResultMsg result = new WeaResultMsg(false);
        result.putAll(table.makeDataResult());
        result.success();


        Map<String, Object> datas = new HashMap<>();
        datas.put("pageInfo", pageInfos);
        datas.put("dataKey", result.getResultMap());
        datas.put("salaryArchives", salaryArchives);
        return datas;
    }


    /**
     * 薪资档案列表（分页）
     *
     * @param queryParam
     * @return
     */
    public Map<String, Object> list(SalaryArchiveQueryParam queryParam, SalaryArchiveListTypeEnum listTypeEnum) {
        //薪资档案列表
        PageInfo<SalaryArchiveListDTO> pageInfo = getSalaryArchiveService(user).listPage(queryParam);
        Collection<SalaryArchiveListDTO> salaryArchives = pageInfo.getList();

        //所有个税扣缴义务人
        Collection<TaxAgentPO> taxAgentLists = getTaxAgentService(user).listAll();

        // 获取所有可被引用的薪资项目
        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(pageInfo.getTotal());
        pageInfos.setPageNum(pageInfo.getPageNum());
        pageInfos.setPageSize(pageInfo.getPageSize());


        //动态列组装
        List<WeaTableColumn> columns = SalaryArchiveBO.buildSalaryArchiveTable(salaryItems);

        SalaryWeaTable<SalaryArchiveListDTO> table = new SalaryWeaTable<SalaryArchiveListDTO>(user, SalaryArchiveListDTO.class);
        table.setColumns(columns);


        WeaResultMsg result = new WeaResultMsg(false);
        result.putAll(table.makeDataResult());
        result.success();


        Map<String, Object> datas = new HashMap<>();
        datas.put("pageInfo", pageInfos);
        datas.put("dataKey", result.getResultMap());
        datas.put("salaryArchives", salaryArchives);
        return datas;
    }


    /**
     * 获取各tab总人数
     *
     * @return
     */
    public Map<String, Long> queryTabTotal() {
        return getSalaryArchiveService(user).queryTabTotal();
    }

    /**
     * 待定薪列表
     *
     * @param queryParam
     * @return
     */
    public Map<String, Object> listPage(SalaryArchiveQueryParam queryParam) {
//        queryParam.setRunStatusList(Arrays.asList(SalaryArchiveStatusEnum.FIXED.getValue()));
//        WeaTable<LinkedHashMap> weaTable = list(queryParam, SalaryArchiveListTypeEnum.PENDING);
        Map<String, Object> list = list(queryParam);
        return list;
    }


    /**
     * 待定薪列表
     *
     * @param queryParam
     * @return
     */
    public Map<String, Object> pendingList(SalaryArchiveQueryParam queryParam) {
        queryParam.setRunStatusList(Arrays.asList(SalaryArchiveStatusEnum.PENDING.getValue()));
        return list(queryParam, SalaryArchiveListTypeEnum.PENDING);
    }

    /**
     * 定薪列表
     *
     * @param queryParam
     * @return
     */
    public Map<String, Object> fixedList(SalaryArchiveQueryParam queryParam) {
        queryParam.setRunStatusList(Arrays.asList(SalaryArchiveStatusEnum.FIXED.getValue(), SalaryArchiveStatusEnum.SUSPEND.getValue()));
        return list(queryParam, SalaryArchiveListTypeEnum.FIXED);
    }

    /**
     * 待停薪列表
     *
     * @param queryParam
     * @return
     */
    public Map<String, Object> suspendList(SalaryArchiveQueryParam queryParam) {
        queryParam.setRunStatusList(Arrays.asList(SalaryArchiveStatusEnum.SUSPEND.getValue()));
        return list(queryParam, SalaryArchiveListTypeEnum.SUSPEND);
    }

    /**
     * 停薪列表
     *
     * @param queryParam
     * @return
     */
    public Map<String, Object> stopList(SalaryArchiveQueryParam queryParam) {
        queryParam.setRunStatusList(Arrays.asList(SalaryArchiveStatusEnum.STOP_FROM_PENDING.getValue(), SalaryArchiveStatusEnum.STOP_FROM_SUSPEND.getValue()));
        return list(queryParam, SalaryArchiveListTypeEnum.STOP);
    }

    /**
     * 设为定薪员工
     *
     * @param ids
     * @return
     */
    public Map<String, Object> gotoFixed(Collection<Long> ids) {
        return getSalaryArchiveService(user).gotoFixed(ids);
    }

    /**
     * 一键全部定薪
     *
     * @param queryParam
     * @return
     */
    public Map<String, Object> allGotoFixed(SalaryArchiveQueryParam queryParam) {
        return getSalaryArchiveService(user).allGotoFixed(queryParam);
    }

//    /**
//     * 删除待定薪待办
//     *
//     * @param ids
//     * @param currentEmployeeId
//     * @param currentTenantKey
//     * @return
//     */
//    public String deletePendingTodo(Collection<Long> ids) {
//        return getSalaryArchiveService(user).deletePendingTodo(ids);
//    }

    /**
     * 停薪
     *
     * @param ids
     * @return
     */
    public Map<String, Object> gotoStop(Collection<Long> ids) {
        return getSalaryArchiveService(user).gotoStop(ids);
    }

    /**
     * 一键全部停薪
     *
     * @param queryParam
     * @return
     */
    public Map<String, Object> allGotoStop(SalaryArchiveQueryParam queryParam) {
        return getSalaryArchiveService(user).allGotoStop(queryParam);
    }

//    /**
//     * 删除待停薪待办
//     *
//     * @param ids
//     * @param currentEmployeeId
//     * @param currentTenantKey
//     * @return
//     */
//    public String deleteSuspendTodo(Collection<Long> ids) {
//        return getSalaryArchiveService(user).deleteSuspendTodo(ids);
//    }

    /**
     * 取消停薪
     *
     * @param ids
     * @return
     */
    public String cancelStop(Collection<Long> ids) {
        return getSalaryArchiveService(user).cancelStop(ids);
    }


    /**
     * 获取薪资档案详情表单
     *
     * @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<TaxAgentListDTO> taxAgentLists = getTaxAgentService(user).findAll();
        String taxAgent = "";
        if (CollectionUtils.isNotEmpty(taxAgentList)) {
            SalaryArchiveTaxAgentPO salaryArchiveTaxAgent = taxAgentList.get(0);
            Optional<TaxAgentListDTO> 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(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);
    }

    /**
     * 预览
     *
     * @param param
     * @return
     */
    public Map<String, Object> preview(SalaryArchiveImportHandleParam param) {
        return getSalaryArchiveService(user).preview(param);
    }

    /**
     * 导入档案
     *
     * @param param
     * @return
     */
    public Map<String, Object> importSalaryArchive(SalaryArchiveImportHandleParam param) {
        return getSalaryArchiveService(user).importSalaryArchive(param);
    }

    /**
     * 导出列表
     *
     * @param queryParam
     * @return
     */
    public XSSFWorkbook exportList(SalaryArchiveQueryParam queryParam) {
        return getSalaryArchiveService(user).exportList(queryParam);
    }

    public Map<String, Object> checkImportSalaryArchive(SalaryArchiveImportHandleParam param) {
        String queryImageId = "select imagefileid from docimagefile where docid = ?";
        if (param.getImageId() != null && !"".equals(param.getImageId())) {
            RecordSet rs = new RecordSet();
            rs.executeQuery(queryImageId, param.getImageId());
            if (rs.next()) {
                param.setImageId(rs.getString("imagefileid"));
            }
        }
        return getSalaryArchiveService(user).importSalaryArchive(param, false);
    }


    /**
     * 检查导入文件
     *
     * @param param
     * @return
     */
    public Map<String, Object> checkImportSalaryArchiveParam(SalaryArchiveImportHandleParam param) {
        return getSalaryArchiveService(user).importSalaryArchive(param, false);
    }

    /**
     * 人员状态列表
     *
     * @return
     */
    public Map<String, Object> searchCondition() {
        List<Map<String, String>> userStatus = UserStatusEnum.getList();
        List<Map<String, String>> itemAdjustReasons = SalaryArchiveItemAdjustReasonEnum.getList();
        List<Map<String, String>> TaxAgentAdjustReason = SalaryArchiveTaxAgentAdjustReasonEnum.getList();
        Collection<TaxAgentListDTO> taxAgentList = getTaxAgentService(user).findAll();
        HashMap map = Maps.newHashMap();
        map.put("userStatus", userStatus);
        map.put("itemAdjustReasons", itemAdjustReasons);
        map.put("TaxAgentAdjustReason", TaxAgentAdjustReason);
        map.put("taxAgentList", taxAgentList);
        return map;
    }

    public Map<String, Object> selectSalaryArchiveColumns(String importType) {
        return getSalaryArchiveService(user).selectSalaryArchiveColumns(SalaryArchiveImportTypeEnum.parseByValue(importType));
    }


    public Map<String, Object> importSalaryArchiveInit(SalaryArchiveImportActionParam importData) {
        return getSalaryArchiveService(user).importSalaryArchiveAction(importData, importData.isAddData());
    }


    public Map<String, Object> importSalaryArchiveSalaryItemAdjust(SalaryArchiveImportActionParam importData) {
        importData.setImportType("salaryItemAdjust");
        return getSalaryArchiveService(user).importSalaryArchiveAction(importData, false);
    }

    public Map<String, Object> importSalaryArchiveTaxAgentAdjust(SalaryArchiveImportActionParam importData) {
        importData.setImportType("taxAgentAdjust");
        return getSalaryArchiveService(user).importSalaryArchiveAction(importData, false);
    }

    /**
     * 停薪
     *
     * @param stopSalaryParam
     * @return
     */
    public void stopSalary(SalaryArchiveStopParam stopSalaryParam) {
        getSalaryArchiveService(user).stopSalary(stopSalaryParam);
    }


}