package com.engine.salary.service.impl;

import com.engine.core.impl.Service;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import com.engine.salary.entity.extemp.param.ExtEmpQueryParam;
import com.engine.salary.entity.extemp.param.ExtEmpSaveParam;
import com.engine.salary.entity.extemp.po.ExtEmpPO;
import com.engine.salary.entity.salarysob.param.SalarySobRangeEmpQueryParam;
import com.engine.salary.mapper.extemp.ExternalEmployeeMapper;
import com.engine.salary.service.ExtEmpService;
import com.engine.salary.util.db.MapperProxyFactory;
import com.engine.salary.util.page.PageInfo;
import com.engine.salary.util.page.SalaryPageUtil;
import com.google.common.collect.Lists;
import dm.jdbc.util.IdGenerator;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.BeanUtils;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 累计专项
 * <p>Copyright: Copyright (c) 2022</p>
 * <p>Company: 泛微软件</p>
 *
 * @author qiantao
 * @version 1.0
 **/
public class ExtEmpServiceImpl extends Service implements ExtEmpService {


    private ExternalEmployeeMapper getExternalEmployeeMapper() {
        return MapperProxyFactory.getProxy(ExternalEmployeeMapper.class);
    }


    @Override
    public List<ExtEmpPO> list(ExtEmpQueryParam param) {
        return getExternalEmployeeMapper().listSome(ExtEmpPO.builder().username(param.getUsername()).build());
    }

    @Override
    public PageInfo<ExtEmpPO> listPage(ExtEmpQueryParam param) {
        List<ExtEmpPO> extEmpPOS = list(param);
        return SalaryPageUtil.buildPage(param.getCurrent(), param.getPageSize(), extEmpPOS, ExtEmpPO.class);

    }

    @Override
    public void save(ExtEmpSaveParam param) {
        ExtEmpPO po = new ExtEmpPO();
        BeanUtils.copyProperties(param, po);

        po.setId(IdGenerator.generate());
        po.setStatus("3");
        po.setCreator((long) user.getUID());
        po.setModifier((long) user.getUID());
        Date now = new Date();
        po.setCreateTime(now);
        po.setUpdateTime(now);
        po.setDeleteType(0);

        getExternalEmployeeMapper().insertIgnoreNull(po);
    }

    @Override
    public void update(ExtEmpSaveParam param) {
        ExtEmpPO po = new ExtEmpPO();
        BeanUtils.copyProperties(param, po);

        po.setModifier((long) user.getUID());
        Date now = new Date();
        po.setUpdateTime(now);

        getExternalEmployeeMapper().updateIgnoreNull(po);
    }

    @Override
    public void delete(Collection<Long> ids) {
        if (CollectionUtils.isNotEmpty(ids)) {
            ids.forEach(getExternalEmployeeMapper()::delete);
        }
    }

    @Override
    public DataCollectionEmployee getEmployeeById(Long id) {
        ExtEmpPO po = getExternalEmployeeMapper().getById(id);
        return cover(po);
    }

    @Override
    public List<DataCollectionEmployee> getEmployeeByIds(List<Long> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return new ArrayList<>();
        }
        List<ExtEmpPO> extEmpPOS = getExternalEmployeeMapper().listSome(ExtEmpPO.builder().ids(ids).build());

        return coverList(extEmpPOS);

    }

    @Override
    public List<DataCollectionEmployee> listByParams(List<SalarySobRangeEmpQueryParam> includeQueryParams) {
        List<DataCollectionEmployee> emps = new ArrayList<>();
        List<List<SalarySobRangeEmpQueryParam>> partition = Lists.partition(includeQueryParams, 100);
        partition.forEach(list->{
            emps.addAll(getExternalEmployeeMapper().listByParams(list));
        });
        return emps;
    }

    @Override
    public List<DataCollectionEmployee> listEmployee() {
        return getExternalEmployeeMapper().listEmployee();
    }

    @Override
    public Collection<DataCollectionEmployee> getEmployeeByIdsAll(List<Long> ids) {
        List<DataCollectionEmployee> employeeList = new ArrayList<>();
        List<List<Long>> partition = Lists.partition(ids, 1000);
        partition.forEach(e->{
            List<DataCollectionEmployee> employeeByIdsAll = getExternalEmployeeMapper().getEmployeeByIdsAll(e);
            employeeList.addAll(employeeByIdsAll);
        });
        return employeeList;
    }

    @Override
    public Collection<DataCollectionEmployee> listAllForReport() {
        return getExternalEmployeeMapper().listAllForReport();
    }

    @Override
    public ExtEmpPO getById(Long id) {
        return getExternalEmployeeMapper().getById(id);
    }


    public DataCollectionEmployee cover(ExtEmpPO extPo) {
        if (extPo == null) {
            return null;
        }
        DataCollectionEmployee employee = new DataCollectionEmployee();
        BeanUtils.copyProperties(extPo, employee);
        employee.setEmployeeId(extPo.getId());
        employee.setExtEmp(true);
        return employee;
    }

    public List<DataCollectionEmployee> coverList(List<ExtEmpPO> extEmps) {
        if (CollectionUtils.isEmpty(extEmps)) {
            return new ArrayList<>();
        }

        return extEmps.stream().map(emp -> {
            DataCollectionEmployee employee = new DataCollectionEmployee();
            BeanUtils.copyProperties(emp, employee);
            employee.setEmployeeId(emp.getId());
            employee.setExtEmp(true);
            return employee;
        }).collect(Collectors.toList());
    }
}