package com.engine.salary.wrapper;

import com.cloudstore.eccom.pc.table.WeaTable;
import com.cloudstore.eccom.result.WeaResultMsg;
import com.engine.salary.entity.agency.po.PaymentAgencyPO;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import com.engine.salary.entity.taxagent.bo.TaxAgentBO;
import com.engine.salary.entity.taxagent.dto.TaxAgentEmployeeOptionDTO;
import com.engine.salary.entity.taxagent.dto.TaxAgentFormDTO;
import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeListDTO;
import com.engine.salary.entity.taxagent.param.TaxAgentAdminChangeCheckParam;
import com.engine.salary.entity.taxagent.param.TaxAgentQueryParam;
import com.engine.salary.entity.taxagent.param.TaxAgentRangeQueryParam;
import com.engine.salary.entity.taxagent.param.TaxAgentSaveParam;
import com.engine.salary.entity.taxagent.po.TaxAgentAdminPO;
import com.engine.salary.entity.taxagent.po.TaxAgentPO;
import com.engine.salary.enums.UserStatusEnum;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.service.*;
import com.engine.salary.util.SalaryAssert;
import com.engine.salary.util.SalaryI18nUtil;
import com.engine.salary.util.page.PageInfo;
import com.engine.salary.util.page.PageUtil;
import com.google.common.collect.Maps;
import com.weaver.common.component.browser.combination.TypesBrowserOption;
import com.weaver.common.component.form.WeaForm;
import com.weaver.common.component.form.item.WeaFormOption;
import com.weaver.common.hrm.domain.employee.HrmStatus;
import com.weaver.hrm.salary.entity.taxagent.dto.TaxAgentManageRangeFormDTO;
import com.weaver.hrm.salary.entity.taxagent.param.*;
import com.weaver.hrm.salary.service.*;
import com.weaver.hrm.salary.util.SalaryFormatUtil;
import com.weaver.teams.security.context.UserContext;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.springframework.beans.BeanUtils;

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

/**
 * 个税扣缴义务人
 * <p>Copyright: Copyright (c) 2022</p>
 * <p>Company: 泛微软件</p>
 *
 * @author qiantao
 * @version 1.0
 **/
public class TaxAgentWrapper {


    private TaxAgentBaseService taxAgentBaseService;

    private TaxAgentAdminService taxAgentAdminService;

    private TaxAgentV2Service taxAgentService;

    private SalaryEmployeeService employeeService;

    private TaxAgentManageRangeService taxAgentManageRangeService;

    private PaymentAgencyService paymentAgencyService;

    private SIEmployeeStatusMapper siEmployeeStatusMapper;

    private HrmCommonHrmStatusService hrmCommonHrmStatusService;

    private HrmConfigSetCache hrmConfigSetCache;

    /**
     * 是否是薪酬模块总管理员
     *
     * @param currentEmployeeId
     * @return
     */
    public Boolean isChief(Long currentEmployeeId) {
        return taxAgentService.isChief(currentEmployeeId);
    }

    /**
     * 权限信息
     *
     * @param currentEmployeeId
     * @return
     */
    public Map<String, Boolean> permission(Long currentEmployeeId) {
        Map<String, Boolean> resultMap = Maps.newHashMap();
        Boolean isChief = isChief(currentEmployeeId);
        Boolean isDefaultOpen = taxAgentService.isDefaultOpen(currentEmployeeId);
        Boolean isAdminEnable = taxAgentService.isAdminEnable(currentEmployeeId);
        resultMap.put("isChief", isChief);
        resultMap.put("isDefaultOpen", isDefaultOpen);
        resultMap.put("isAdminEnable", isAdminEnable);
        return resultMap;
    }

    /**
     * 个税口角义务人列表
     *
     * @param queryParam
     * @param currentEmployeeId
     * @return
     */
    public Map<String, Object> list(TaxAgentQueryParam queryParam, Long currentEmployeeId) {
        // 是否是总管理员
        Boolean isChief = taxAgentService.isChief(currentEmployeeId);
        // 是否开启分权
        boolean isOpenDevolution = taxAgentBaseService.isOpenDevolution();

//        List<PaymentAgencyPO> paymentAgencyPOS = paymentAgencyService.listAll(currentTenantKey);

        PageInfo<TaxAgentPO> page = null;
        if (isChief) {
            page = taxAgentService.listPage(queryParam);
        } else {
            // 分权情况下，根据自己作为管理员过滤列表
            if (isOpenDevolution) {
                List<TaxAgentPO> list = taxAgentService.list(queryParam);
                // 1.判断自己是否是管理员， 如果是管理员，就是能够操作所属个税扣缴义务人下的所有人的数据
                List<TaxAgentAdminPO> taxAgentAdminList = taxAgentAdminService.listByTaxAgentIdsAndEmployeeId(list.stream().map(TaxAgentPO::getId).collect(Collectors.toList()), currentEmployeeId);
                // 是管理员的列表
                List<Long> adminTaxAgentIds = taxAgentAdminList.stream().map(TaxAgentAdminPO::getTaxAgentId).collect(Collectors.toList());
                list = list.stream().filter(f -> adminTaxAgentIds.contains(f.getId())).collect(Collectors.toList());
                // 分页参数
                // 填充总数和当页数据
                PageInfo<TaxAgentPO> dtoPage = PageUtil.buildPage(queryParam.getCurrent(), queryParam.getPageSize());
                dtoPage.setTotal(list.size());
                dtoPage.setList(PageUtil.subList(dtoPage.getPageNum(), dtoPage.getSize(), list));
                page = dtoPage;
            }
        }

        PageInfo<Map<String, Object>> listPage = new PageInfo<>();

        String setLabel = SalaryI18nUtil.getI18nLabel(94614, "设置");
        if (isOpenDevolution) {
            List<TaxAgentPO> list = page.getList();
            List<Long> taxAgentIds = list.stream().map(TaxAgentPO::getId).collect(Collectors.toList());
            List<TaxAgentAdminPO> taxAgentAdmins = taxAgentAdminService.listByTaxAgentIds(taxAgentIds);
            List<DataCollectionEmployee> adminList = employeeService.listByIds(taxAgentAdmins.stream().map(TaxAgentAdminPO::getEmployeeId).distinct().collect(Collectors.toList()));
            listPage.setList(TaxAgentBO.convertToTableListDTO(page.getList(), null, taxAgentAdmins, adminList, setLabel));
        } else {
            listPage.setList(TaxAgentBO.convertToTableListDTO(page.getList(), null, setLabel));
        }

        //构造表格
        WeaTable weaTable = new WeaTable();
        TaxAgentBO.buildTaxAgentTable(weaTable, isOpenDevolution);
        if (isChief) {
            // 在外展示操作按钮
//            weaTable.getOperates().get(0).setOuter(Boolean.TRUE);
        } else {
            // 去掉增删改权限
            weaTable.getOperates().getOperate().clear();
//            weaTable.getCheckBoxPermission().clear();
        }

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

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

        return datas;

    }

    public List<Map<String, Object>> paymentAgencyList(TaxAgentQueryParam queryParam, Long currentEmployeeId) {
        List<TaxAgentPO> taxAgentPOS = taxAgentService.listByIds(queryParam.getIds());
        List<PaymentAgencyPO> paymentAgencyPOS = paymentAgencyService.listAll(currentTenantKey);
        SalaryAssert.notEmpty(taxAgentPOS, "taxagent data is not exist");
        TaxAgentPO taxAgentPO = taxAgentPOS.get(0);
        return TaxAgentBO.buildPaymentAgency(taxAgentPO.getPaymentAgency(), paymentAgencyPOS);
    }

    public String paymentAgencySave(TaxAgentSaveParam param, Long currentEmploueeId) {
//        List<TaxAgentPO> taxAgentPOS = taxAgentService.listByIds(Collections.singletonList(param.getId()));
//        SalaryAssert.notEmpty(taxAgentPOS, "data is not exist");
//        TaxAgentPO taxAgentPO = taxAgentPOS.get(0);
//        List<String> errorList = new ArrayList<>();
//        List<String> resultList = new ArrayList<>();
//        if (StringUtils.isNotBlank(taxAgentPO.getPaymentAgency())) {
//            List<String> originList = new ArrayList<>(Arrays.asList(taxAgentPO.getPaymentAgency().split(",")));
//            List<String> list = new ArrayList<>(Arrays.asList(param.getPaymentAgency().split(",")));
//            originList.removeAll(list);
//            if (CollectionUtils.isNotEmpty(originList)) {
//                originList.stream().forEach(e -> {
//                    List<InsuranceEmployeeStatusPO> employeeStatusPOS = new LambdaQueryChainWrapper<>(siEmployeeStatusMapper)
//                            .eq(InsuranceEmployeeStatusPO::getTenantKey)
//                            .eq(InsuranceEmployeeStatusPO::getPaymentAgency, Long.valueOf(e))
//                            .eq(InsuranceEmployeeStatusPO::getPaymentOrganization, param.getId())
//                            .list();
//                    if (CollectionUtils.isNotEmpty(employeeStatusPOS)) {
//                        errorList.add(e);
//                    }
//                });
//            }
//            if (CollectionUtils.isNotEmpty(errorList)) {
//                List<PaymentAgencyPO> paymentAgencyPOS = paymentAgencyService.listAll(currentTenantKey);
//                errorList.forEach(e -> {
//                    Optional<PaymentAgencyPO> optionalPaymentAgencyPO = paymentAgencyPOS.stream().filter(po -> Objects.equals(e, String.valueOf(po.getId()))).findFirst();
//                    optionalPaymentAgencyPO.ifPresent(paymentAgencyPO -> resultList.add(paymentAgencyPO.getAgencyName()));
//                });
//            }
//        }
//        if (CollectionUtils.isNotEmpty(resultList)) {
//            return SalaryI18nUtil.getI18nLabel(currentTenantKey, currentEmploueeId, 115128, "有员工在") + String.join(",", resultList) + SalaryI18nUtil.getI18nLabel(currentTenantKey,
//                    currentEmploueeId, 115129, "缴纳社保福利，不可取消关联");
//        } else {
//            taxAgentPO.setPaymentAgency(param.getPaymentAgency());
//            taxAgentService.paymentAgencyUpdate(taxAgentPO, currentEmploueeId);
//        }
        return "";
    }

    /**
     * 获取个税扣缴义务人表单
     *
     * @param id
     * @return
     */
    public TaxAgentFormDTO getFrom(Long id) {
        TaxAgentFormDTO taxAgentFromDTO = new TaxAgentFormDTO();
        if (id != null) {
            TaxAgentPO taxAgent = taxAgentService.getById(id);
            if (taxAgent == null) {
                throw new SalaryRunTimeException(String.format(SalaryI18nUtil.getI18nLabel(100543, "个税扣缴人不存在") + "[id:%s]", id));
            }
            BeanUtils.copyProperties(taxAgent, taxAgentFromDTO);
        }
        // 是否开启分权
        boolean isOpenDevolution = taxAgentBaseService.isOpenDevolution();
        if (isOpenDevolution) {
            List<TaxAgentAdminPO> admins = taxAgentAdminService.listByTaxAgentIds(Collections.singletonList(id));
            // 目前是一个
            TaxAgentEmployeeOptionDTO taxAgentEmployee = new TaxAgentEmployeeOptionDTO();
            taxAgentEmployee.setId(CollectionUtils.isEmpty(admins) ? null : admins.get(0).getEmployeeId());
            if (taxAgentEmployee.getId() != null) {
                DataCollectionEmployee employee = employeeService.getEmployeeById(taxAgentEmployee.getId());
                taxAgentEmployee.setContent(employee == null ? "" : employee.getUsername());
            }
            taxAgentFromDTO.setAdminUser(Collections.singletonList(taxAgentEmployee));
        } else {
            taxAgentFromDTO.setAdminUser(null);
        }

        return taxAgentFromDTO;
    }

    /**
     * 保存个税扣缴义务人
     *
     * @param saveParam
     * @param currentEmployeeId
     * @return
     */
    public String save(TaxAgentSaveParam saveParam, Long currentEmployeeId) {
        return taxAgentService.save(saveParam, currentEmployeeId);
    }

    /**
     * 编辑个税扣缴义务人
     *
     * @param saveParam
     * @param currentEmployeeId
     * @return
     */
    public String update(TaxAgentSaveParam saveParam, Long currentEmployeeId) {
        return taxAgentService.update(saveParam, currentEmployeeId);
    }

    /**
     * 更换管理员校验
     *
     * @param checkParam
     * @param currentEmployeeId
     * @return
     */
    public Boolean adminChangeCheck(TaxAgentAdminChangeCheckParam checkParam, Long currentEmployeeId) {
        return taxAgentService.adminChangeCheck(checkParam, currentEmployeeId);
    }

    /**
     * 删除个税扣缴义务人
     *
     * @param ids
     * @param currentEmployeeId
     * @return
     */
    public String delete(Collection<Long> ids, Long currentEmployeeId) {
        return taxAgentService.delete(ids, currentEmployeeId);
    }

    /**
     * 个税扣缴义务人下拉列表
     *
     * @param currentEmployeeId
     * @return
     */
    public List<Map<String, Object>> selectList(Long currentEmployeeId) {
        return taxAgentService.selectList(currentEmployeeId);
    }

    /**
     * 范围列表
     *
     * @param queryParam
     * @return
     */
    public PageInfo<TaxAgentManageRangeListDTO> listRangeInclude(TaxAgentRangeQueryParam queryParam) {
        PageInfo<TaxAgentManageRangeListDTO> listPage = taxAgentManageRangeService.listPageByParamAndIncludeType(queryParam, NumberUtils.INTEGER_ONE);
        return listPage;
    }

    /**
     * 范围排除列表
     *
     * @param queryParam
     * @return
     */
    public PageInfo<TaxAgentManageRangeListDTO> listRangeExclude(TaxAgentRangeQueryParam queryParam) {
        PageInfo<TaxAgentManageRangeListDTO> listPage = taxAgentManageRangeService.listPageByParamAndIncludeType(queryParam, NumberUtils.INTEGER_ZERO);
        return listPage;
    }

    /**
     * 获取管理范围表单
     *
     * @return
     */
    public WeaForm getRangeFrom() {
        // 查询人员状态
        List<UserStatusEnum> hrmStatusList = UserStatusEnum.getEffectiveList();
        List<WeaFormOption> weaFormOptions = hrmStatusList.stream().map(hrmStatus -> {
            WeaFormOption weaFormOption = new WeaFormOption();
            weaFormOption.setId("" + hrmStatus.getCodeId());
            weaFormOption.setContent(hrmStatus.getName());
            return weaFormOption;
        }).collect(Collectors.toList());
        Long employeeId = UserContext.getCurrentEmployeeId();
        List<TypesBrowserOption> browserOptions = new ArrayList<>();
        browserOptions.add(new TypesBrowserOption("user", SalaryI18nUtil.getI18nLabel(1869, "人员")));
        browserOptions.add(new TypesBrowserOption("dept", SalaryI18nUtil.getI18nLabel(1250, "部门")));
        if (hrmConfigSetCache.isSubcompanySupport(tenantKey)) {
            browserOptions.add(new TypesBrowserOption("subcompany", SalaryI18nUtil.getI18nLabel(107369, "分部")));
        }
        browserOptions.add(new TypesBrowserOption("position", SalaryI18nUtil.getI18nLabel(1245, "岗位")));

        WeaForm weaForm = SalaryFormatUtil.<TaxAgentManageRangeFormDTO>getInstance().buildForm(TaxAgentManageRangeFormDTO.class, TaxAgentManageRangeFormDTO.builder().targetOptions(browserOptions).build());
        weaForm.getItems().forEach((key, value) -> {
            if (StringUtils.equals("employeeStatus", key)) {
                value.setOptions(weaFormOptions);
            }
        });
        return weaForm;
    }

    /**
     * 保存管理范围
     *
     * @param saveParam
     * @param employeeId
     * @param tenantKey
     * @return
     */
    public String saveRange(TaxAgentRangeSaveParam saveParam, Long employeeId, String tenantKey) {
        taxAgentManageRangeService.save(saveParam, employeeId, tenantKey);
        return StringUtils.EMPTY;
    }

    /**
     * 删除管理范围
     *
     * @param ids
     * @param tenantKey
     * @return
     */
    public String deleteRange(Collection<Long> ids, Long employeeId, String tenantKey) {
        taxAgentManageRangeService.deleteByIds(ids, employeeId, tenantKey);
        return StringUtils.EMPTY;
    }
}