package com.engine.salary.service.impl;

import com.alibaba.fastjson.JSON;
import com.api.formmode.mybatis.util.SqlProxyHandle;
import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service;
import com.engine.salary.biz.EmployBiz;
import com.engine.salary.constant.SalaryDefaultTenantConstant;
import com.engine.salary.entity.SalarySobExtRangePO;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import com.engine.salary.entity.hrm.DeptInfo;
import com.engine.salary.entity.hrm.JobCallInfo;
import com.engine.salary.entity.hrm.PositionInfo;
import com.engine.salary.entity.hrm.SubCompanyInfo;
import com.engine.salary.entity.hrm.dto.EmployeeInfoExpandDTO;
import com.engine.salary.entity.hrm.dto.FieldSetting;
import com.engine.salary.entity.hrm.po.ExpandFieldSettingsPO;
import com.engine.salary.entity.salarysob.bo.SalarySobRangeBO;
import com.engine.salary.entity.salarysob.param.SalarySobRangeEmpQueryParam;
import com.engine.salary.entity.salarysob.po.SalarySobRangePO;
import com.engine.salary.enums.UserStatusEnum;
import com.engine.salary.enums.datacollection.UseEmployeeTypeEnum;
import com.engine.salary.enums.salarysob.TargetTypeEnum;
import com.engine.salary.mapper.datacollection.EmployMapper;
import com.engine.salary.mapper.hrm.ExpandFieldSettingsMapper;
import com.engine.salary.mapper.sys.SalarySysConfMapper;
import com.engine.salary.service.ExtEmpService;
import com.engine.salary.service.SalaryEmployeeService;
import com.engine.salary.service.SalarySobExtRangeService;
import com.engine.salary.service.SalarySobRangeService;
import com.engine.salary.sys.entity.po.SalarySysConfPO;
import com.engine.salary.util.SalaryEntityUtil;
import com.engine.salary.util.SalaryI18nUtil;
import com.engine.salary.util.db.IdGenerator;
import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
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
 **/
@Slf4j
public class SalaryEmployeeServiceImpl extends Service implements SalaryEmployeeService {

    private EmployBiz employBiz = new EmployBiz();

    private EmployMapper getEmployMapper() {
        return SqlProxyHandle.getProxy(EmployMapper.class);
    }

    private SalarySobRangeService getSalarySobRangeService(User user) {
        return ServiceUtil.getService(SalarySobRangeServiceImpl.class, user);
    }

    private SalaryEmployeeService getSalaryEmployeeService(User user) {
        return ServiceUtil.getService(SalaryEmployeeServiceImpl.class, user);
    }

    private SalarySysConfMapper getSalarySysConfMapper() {
        return SqlProxyHandle.getProxy(SalarySysConfMapper.class);
    }


    private ExpandFieldSettingsMapper getExpandFieldSettingsMapper() {
        return SqlProxyHandle.getProxy(ExpandFieldSettingsMapper.class);
    }


    private ExtEmpService getExtEmpService(User user) {
        return ServiceUtil.getService(ExtEmpServiceImpl.class, user);
    }


    private SalarySobExtRangeService getSalarySobExtRangeService(User user) {
        return ServiceUtil.getService(SalarySobExtRangeServiceImpl.class, user);
    }

    boolean openExtEmp = true;

    @Override
    public List<DataCollectionEmployee> listAll(UseEmployeeTypeEnum empType) {
        List<DataCollectionEmployee> result = new ArrayList<>();
        if (empType == UseEmployeeTypeEnum.ORG) {
            result = employBiz.listAll();
        }
        if (empType == UseEmployeeTypeEnum.EXT) {
            result = getExtEmpService(user).listEmployee();
        }
        if (empType == UseEmployeeTypeEnum.ALL) {
            result.addAll(employBiz.listAll());
            result.addAll(getExtEmpService(user).listEmployee());
        }
        SalaryI18nUtil.i18nList(result);
        return result;
    }

    @Override
    public List<DataCollectionEmployee> listAllForReport() {
        List<DataCollectionEmployee> result = employBiz.listAllForReport();
        if (openExtEmp) {
            result.addAll(getExtEmpService(user).listAllForReport());
        }
        SalaryI18nUtil.i18nList(result);
        return result;
    }

    @Override
    public List<DataCollectionEmployee> listBySalarySobId(Long salarySobId) {

        List<DataCollectionEmployee> includeSalaryEmployees = new ArrayList<>();

        // 查询薪资账套的人员范围
        List<SalarySobRangePO> includeSalarySobRangePOS = getSalarySobRangeService(user).listBySalarySobIdAndIncludeType(salarySobId, NumberUtils.INTEGER_ONE);
        if (CollectionUtils.isNotEmpty(includeSalarySobRangePOS)) {
            // 将薪资账套的人员范围转换成人员查询参数
            List<SalarySobRangeEmpQueryParam> includeQueryParams = SalarySobRangeBO.convert2EmployeeQueryParam(includeSalarySobRangePOS);
            // 根据上一步的查询参数查询人员
            includeSalaryEmployees = listByParams(includeQueryParams);
            if (CollectionUtils.isEmpty(includeSalaryEmployees)) {
                return Collections.emptyList();
            }
            //去重
            includeSalaryEmployees = includeSalaryEmployees.stream().distinct().collect(Collectors.toList());
            // 查询薪资账套的人员范围（从范围中排除）
            List<SalarySobRangePO> excludeSalarySobRangePOS = getSalarySobRangeService(user).listBySalarySobIdAndIncludeType(salarySobId, NumberUtils.INTEGER_ZERO);
            if (CollectionUtils.isNotEmpty(excludeSalarySobRangePOS)) {
                // 将薪资账套的人员范围转换成人员查询参数
                List<SalarySobRangeEmpQueryParam> excludeQueryParams = SalarySobRangeBO.convert2EmployeeQueryParam(excludeSalarySobRangePOS);
                // 根据上一步的查询参数查询人员
                List<DataCollectionEmployee> excludeSalaryEmployees = listByParams(excludeQueryParams);
                // 需要排除的人员范围
                Set<Long> excludeEmployeeIds = SalaryEntityUtil.properties(excludeSalaryEmployees, DataCollectionEmployee::getEmployeeId);
                // 过滤人员
                includeSalaryEmployees = includeSalaryEmployees.stream()
                        .filter(salaryEmployee -> !excludeEmployeeIds.contains(salaryEmployee.getEmployeeId()))
                        .collect(Collectors.toList());
            }
        }

        //外部人员
        List<SalarySobExtRangePO> salarySobExtRangePOS = getSalarySobExtRangeService(user).listBySalarySobId(salarySobId);
        if (CollectionUtils.isNotEmpty(salarySobExtRangePOS)) {
            List<Long> ids = SalaryEntityUtil.properties(salarySobExtRangePOS, SalarySobExtRangePO::getTargetId, Collectors.toList());
            List<DataCollectionEmployee> extEmps = getExtEmpService(user).getEmployeeByIds(ids);
            extEmps = extEmps.stream().distinct().collect(Collectors.toList());

            includeSalaryEmployees.addAll(extEmps);
        }
        SalaryI18nUtil.i18nList(includeSalaryEmployees);
        return includeSalaryEmployees;
    }

    @Override
    public List<DataCollectionEmployee> getEmployeeByIdsAll(List<Long> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return new ArrayList<>();
        }
        List<DataCollectionEmployee> employeeList = employBiz.getEmployeeByIdsAll(ids);
        if (openExtEmp) {
            employeeList.addAll(getExtEmpService(user).getEmployeeByIds(ids));
        }
        SalaryI18nUtil.i18nList(employeeList);
        return employeeList;
    }

    @Override
    public List<DataCollectionEmployee> listByIds(List<Long> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return Collections.emptyList();
        }
        List<DataCollectionEmployee> result = new ArrayList<>();
        if (openExtEmp) {
            result.addAll(getExtEmpService(user).getEmployeeByIds(ids));
        }
        result.addAll(employBiz.getEmployeeByIdsAll(ids));
        SalaryI18nUtil.i18nList(result);
        return result;
    }

    @Override
    public DataCollectionEmployee getEmployeeById(Long employeeId) {
        if (openExtEmp) {
            DataCollectionEmployee employee = getExtEmpService(user).getEmployeeById(employeeId);
            if (Objects.nonNull(employee)) {
                return SalaryI18nUtil.i18n(employee);
            }
        }
        DataCollectionEmployee employee = employBiz.getEmployeeById(employeeId);
        return SalaryI18nUtil.i18n(employee);
    }

    @Override
    public List<DataCollectionEmployee> getEmployeeByIds(List<Long> simpleEmployeeIds) {
        if (CollectionUtils.isEmpty(simpleEmployeeIds)) {
            return new ArrayList<>();
        }
        List<DataCollectionEmployee> employeeList = new ArrayList<>();
        List<List<Long>> partition = Lists.partition(simpleEmployeeIds, 1000);
        for (List<Long> longs : partition) {
            employeeList.addAll(employBiz.getEmployeeByIds(longs));
            if (openExtEmp) {
                employeeList.addAll(getExtEmpService(user).getEmployeeByIds(longs));
            }
        }
        return SalaryI18nUtil.i18nList(employeeList);

    }

    @Override
    public List<DataCollectionEmployee> getEmployeeByIdsIncludeAccountType(List<Long> simpleEmployeeIds) {
        if (CollectionUtils.isEmpty(simpleEmployeeIds)) {
            return new ArrayList<>();
        }
        List<DataCollectionEmployee> employeeList = new ArrayList<>();
        List<List<Long>> partition = Lists.partition(simpleEmployeeIds, 1000);
        for (List<Long> longs : partition) {
            employeeList.addAll(employBiz.getEmployeeByIdsIncludeAccountType(longs));
            if (openExtEmp) {
                employeeList.addAll(getExtEmpService(user).getEmployeeByIds(longs));
            }
        }
        return SalaryI18nUtil.i18nList(employeeList);

    }


    public List<DataCollectionEmployee> filterEmployees(List<DataCollectionEmployee> employees, String userName, String deparmentName, String mobile) {
        List<DataCollectionEmployee> employeeSameIds = employees.stream().filter(e -> (StringUtils.isBlank(userName) || Objects.equals(e.getUsername(), userName))
                        && (StringUtils.isBlank(deparmentName) || Objects.equals(e.getDepartmentName(), deparmentName))
                        && (StringUtils.isBlank(mobile) || Objects.equals(e.getMobile(), mobile)))
                .collect(Collectors.toList());
        //存在离职和在职状态取在职状态
        employeeSameIds = employeeSameIds.stream()
                .filter(e -> UserStatusEnum.getNormalStatus().contains(e.getStatus()))
                .collect(Collectors.toList());

        return SalaryI18nUtil.i18nList(employeeSameIds);
    }

    @Override
    public List<DataCollectionEmployee> matchImportEmployee(String confValue, List<DataCollectionEmployee> employeeList, String userName, String deparmentName, String mobile, String workcode, String idNo, Long uid) {
        if (uid != null) {
            return employeeList.stream()
                    .filter(e -> Objects.equals(e.getEmployeeId(), uid))
                    .collect(Collectors.toList());
        }

        List<DataCollectionEmployee> employees = new ArrayList<>();
        //“0”代表姓名+部门+手机号的匹配原则，“1”代表工号为唯一匹配原则
        if ("0".equals(confValue)) {
            employees = employeeList.stream().filter(e -> (StringUtils.isBlank(userName) || Objects.equals(e.getUsername(), userName))
                            && (StringUtils.isBlank(deparmentName) || Objects.equals(e.getDepartmentName(), deparmentName))
                            && (StringUtils.isBlank(mobile) || Objects.equals(e.getMobile(), mobile)))
                    .collect(Collectors.toList());
        } else if ("1".equals(confValue)) {
            employees = employeeList.stream().filter(e -> (StringUtils.isBlank(workcode) || Objects.equals(e.getWorkcode(), workcode)))
                    .collect(Collectors.toList());
        } else if ("2".equals(confValue)) {
            employees = employeeList.stream().filter(e -> (StringUtils.isBlank(idNo) || Objects.equals(e.getIdNo(), idNo)))
                    .collect(Collectors.toList());
        }

        return SalaryI18nUtil.i18nList(employees);

    }

    /**
     * 人员定位方式
     * “0”代表姓名+部门+手机号的匹配原则，“1”代表工号为唯一匹配原则
     *
     * @return
     */
    @Override
    public String empValidType() {
        SalarySysConfPO salarySysConfPO = getSalarySysConfMapper().getOneByCode("matchEmployeeMode");
        return (salarySysConfPO != null && salarySysConfPO.getConfValue() != null && !"".equals(salarySysConfPO.getConfValue())) ? salarySysConfPO.getConfValue() : "0";
    }

    @Override
    public List<DeptInfo> getDeptInfoList(List<Long> departmentIds) {
        return SalaryI18nUtil.i18nList(employBiz.getDeptInfoList(departmentIds));
    }

    @Override
    public DeptInfo getDeptInfoById(Long departmentId) {
        if (departmentId == null) {
            return null;
        }
        return SalaryI18nUtil.i18n(employBiz.getDeptInfoById(departmentId));
    }

    @Override
    public List<DeptInfo> getVirtualDeptInfoList(List<Long> virtualDepartmentIds) {
        if (CollectionUtils.isEmpty(virtualDepartmentIds)) {
            return Collections.emptyList();
        }
        return SalaryI18nUtil.i18nList(getEmployMapper().getVirtualDeptInfoList(virtualDepartmentIds));
    }


    @Override
    public List<SubCompanyInfo> getSubCompanyInfoList(List<Long> subDepartmentIds) {
        return SalaryI18nUtil.i18nList(employBiz.getSubCompanyInfoList(subDepartmentIds));
    }

    @Override
    public SubCompanyInfo getSubCompanyInfoById(Long subDepartmentId) {
        return SalaryI18nUtil.i18n(employBiz.getSubCompanyInfoById(subDepartmentId));
    }

    @Override
    public List<SubCompanyInfo> getVirtualSubCompanyInfoList(List<Long> virtualSubDepartmentIds) {
        if (CollectionUtils.isEmpty(virtualSubDepartmentIds)) {
            return Collections.emptyList();
        }
        return SalaryI18nUtil.i18nList(getEmployMapper().getVirtualSubCompanyInfoList(virtualSubDepartmentIds));
    }


    @Override
    public List<PositionInfo> listPositionInfo(List<Long> positionIds) {
        return SalaryI18nUtil.i18nList(employBiz.listPositionInfo(positionIds));
    }

    @Override
    public PositionInfo getPositionInfoById(Long positionId) {
        return SalaryI18nUtil.i18n(employBiz.getPositionInfoById(positionId));
    }

    @Override
    public List<DataCollectionEmployee> listEmployee() {
        List<DataCollectionEmployee> result = employBiz.listEmployee();
        if (openExtEmp) {
            result.addAll(getExtEmpService(user).listEmployee());
        }
        return SalaryI18nUtil.i18nList(result);
    }

    @Override
    public List<DataCollectionEmployee> listByParams(List<SalarySobRangeEmpQueryParam> includeQueryParams) {
        if (CollectionUtils.isEmpty(includeQueryParams)) {
            return Collections.emptyList();
        }
        List<SalarySobRangeEmpQueryParam> queryParams = includeQueryParams.stream().filter(param -> !param.getTargetType().equals(TargetTypeEnum.SQL.name())).collect(Collectors.toList());
        List<DataCollectionEmployee> result = employBiz.listByParams(queryParams);
        if (openExtEmp) {
            result.addAll(getExtEmpService(user).listByParams(queryParams));
        }
        // 查询虚拟部门、分部人员信息
        List<SalarySobRangeEmpQueryParam> virtualParams = queryParams.stream().filter(param ->
                (param.getTargetType().equals(TargetTypeEnum.SUBCOMPANY.name()) || param.getTargetType().equals(TargetTypeEnum.DEPT.name())) && ((List<Long>) param.getTargetIds()).get(0).compareTo(0L) < 0
        ).collect(Collectors.toList());

        result.addAll(employBiz.listByVirtualParams(virtualParams));

        List<Long> empIds = new ArrayList<>();
        includeQueryParams.stream()
                .filter(param -> param.getTargetType().equals(TargetTypeEnum.SQL.name()))
                .forEach(param -> {
                    String sql = param.getTarget();
                    RecordSet rs = new RecordSet();
                    if (rs.execute(sql)) {
                        while (rs.next()) {
                            empIds.add((long) rs.getInt("id"));
                        }
                    }
                });
        List<DataCollectionEmployee> employees = getSalaryEmployeeService(user).getEmployeeByIds(empIds);
        result.addAll(employees);

        // 从hrmresource和hrmresourcevirtual可能获取到重复人员数据，需要根据人员id去重
        result = result.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparingLong(DataCollectionEmployee::getEmployeeId))), ArrayList::new));

        return result;
    }

    /**
     * 根据离职日期获取离职信息
     *
     * @param dismissDate
     * @return
     */
    @Override
    public Map<Long, String> getResignationMapByDate(String dismissDate) {
        if (StringUtils.isBlank(dismissDate)) {
            return Collections.emptyMap();
        }
        List<DataCollectionEmployee> employeeList = employBiz.listByDismissDate(dismissDate);
        return SalaryEntityUtil.convert2Map(employeeList, DataCollectionEmployee::getEmployeeId, DataCollectionEmployee::getDismissdate);
    }

    @Override
    public List<DataCollectionEmployee> expandEmployeeInfo(List<Long> ids, EmployeeInfoExpandDTO param) {

        List<DataCollectionEmployee> employees = getEmployeeByIdsAll(ids);

        if (param != null) {
            RecordSet rs = new RecordSet();
            String sql = param.getExpandSql().replace("=$人员id$", "in (" + StringUtils.join(ids, ",") + ")")
                    .replace("in($人员id$)", "in (" + StringUtils.join(ids, ",") + ")");
            String primaryKey = param.getPk();
            rs.executeQuery(sql);
            while (rs.next()) {
                Map<String, String> extendData = new HashMap<>();
                param.getFieldSettings().forEach(setting -> {
                    String field = setting.getField();
                    String value = rs.getString(field);
                    setting.setValue(value);
                    extendData.put(field, value);
                });

                String id = rs.getString(primaryKey);
                employees.stream()
                        .filter(e -> id.equals(e.getEmployeeId().toString()))
                        .forEach(e -> e.setExtendData(extendData));
            }
        }
        return SalaryI18nUtil.i18nList(employees);
    }

    @Override
    public Map<Long, Map<String, String>> expandEmployeeMap(List<Long> ids, EmployeeInfoExpandDTO param) {
        if (CollectionUtils.isNotEmpty(ids) && param != null) {
            Map<Long, Map<String, String>> map = new HashMap<>();

            List<List<Long>> partition = Lists.partition(ids, 5);
            for (int i = 0; i < partition.size(); i++) {
                List<Long> idList = partition.get(i);
                RecordSet rs = new RecordSet();
                String sql = param.getExpandSql().replace("=$人员id$", " in (" + StringUtils.join(idList, ",") + ")")
                        .replace("in($人员id$)", " in (" + StringUtils.join(idList, ",") + ")");
                String primaryKey = param.getPk();
                rs.executeQuery(sql);

                log.info("扩展属性sql" + sql);

                while (rs.next()) {
                    Map<String, String> extendData = new HashMap<>();
                    param.getFieldSettings().forEach(setting -> {
                        String field = setting.getField();
                        String value = rs.getString(field);
                        setting.setValue(value);
                        extendData.put(field, value);
                    });

                    String id = rs.getString(primaryKey);
                    map.put(Long.valueOf(id), extendData);
                }
            }

            return map;
        }
        return new HashMap<>();
    }

    @Override
    public void saveEmployeeExpandFieldSettings(EmployeeInfoExpandDTO param) {
        String settings = JSON.toJSONString(param.getFieldSettings());

        Date now = new Date();

        if (Objects.nonNull(param.getId())) {
            ExpandFieldSettingsPO po = getExpandFieldSettingsMapper().getById(param.getId());
            if (po == null) {
                throw new RuntimeException("配置不存在！");
            }

            po.setPk(param.getPk());
            po.setExpandSql(param.getExpandSql());
            po.setFieldSetting(settings);
            po.setCreator((long) user.getUID());
            po.setUpdateTime(now);
            getExpandFieldSettingsMapper().update(po);

        } else {
            ExpandFieldSettingsPO po = ExpandFieldSettingsPO.builder()
                    .id(IdGenerator.generate())
                    .module(param.getModule())
                    .moduleInfo(param.getModuleInfo())
                    .pk(param.getPk())
                    .fieldSetting(settings)
                    .expandSql(param.getExpandSql())
                    .deleteType(0)
                    .creator((long) user.getUID())
                    .createTime(now)
                    .updateTime(now)
                    .tenantKey(SalaryDefaultTenantConstant.DEFAULT_TENANT_KEY)
                    .build();
            getExpandFieldSettingsMapper().insertIgnoreNull(po);
        }

    }


    @Override
    public EmployeeInfoExpandDTO getExpandFieldSettings(String module) {

        ExpandFieldSettingsPO po = getExpandFieldSettingsMapper().getByModule(module);

        if (po != null) {
            List<FieldSetting> list = JSON.parseArray(po.getFieldSetting(), FieldSetting.class);
            return EmployeeInfoExpandDTO.builder()
                    .id(po.getId())
                    .module(po.getModule())
                    .moduleInfo(po.getModuleInfo())
                    .pk(po.getPk())
                    .expandSql(po.getExpandSql())
                    .fieldSettings(list)
                    .build();

        }

        return null;
    }

    @Override
    public List<DataCollectionEmployee> getVirtualEmpByVirtualDepIds(List<Long> virtualDepartmentIds) {
        if (CollectionUtils.isEmpty(virtualDepartmentIds)) {
            return Collections.emptyList();
        }
        return getEmployMapper().listVirtualEmpByVirtualDepIds(virtualDepartmentIds);
    }

    @Override
    public List<DataCollectionEmployee> getVirtualEmpByVirtualSubCompanyIds(List<Long> virtualSubCompanyIds) {
        if (CollectionUtils.isEmpty(virtualSubCompanyIds)) {
            return Collections.emptyList();
        }
        return getEmployMapper().listVirtualEmpByVirtualSubCompanyIds(virtualSubCompanyIds);
    }

    @Override
    public List<DataCollectionEmployee> listBySubCompanyOrDepartment(List<Long> subCompanyIds, List<Long> departmentIds) {
        List<DataCollectionEmployee> employeeList = new ArrayList<>();
        employeeList.addAll(getEmployMapper().listBySubCompanyOrDepartment(subCompanyIds, departmentIds));
        if (openExtEmp) {
            employeeList.addAll(getExtEmpService(user).listBySubCompanyOrDepartment(subCompanyIds, departmentIds));
        }
        return SalaryI18nUtil.i18nList(employeeList);
    }

    @Override
    public JobCallInfo getJobCallInfoById(Long jobCallId) {
        if (jobCallId == null) {
            return null;
        }
        return SalaryI18nUtil.i18n(getEmployMapper().getJobCallInfoById(jobCallId));
    }
}