package com.engine.salary.service.impl;

import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service;
import com.engine.salary.biz.*;
import com.engine.salary.constant.SalaryDefaultTenantConstant;
import com.engine.salary.entity.salaryacct.po.SalaryAcctRecordPO;
import com.engine.salary.entity.salaryitem.bo.SysSalaryItemBO;
import com.engine.salary.entity.salaryitem.po.SalaryItemPO;
import com.engine.salary.entity.salaryitem.po.SysSalaryItemPO;
import com.engine.salary.entity.salarysob.bo.SalarySobBO;
import com.engine.salary.entity.salarysob.bo.SalarySobCycleBO;
import com.engine.salary.entity.salarysob.bo.SalarySobDuplicateBO;
import com.engine.salary.entity.salarysob.bo.SalarySobItemBO;
import com.engine.salary.entity.salarysob.dto.SalarySobCycleDTO;
import com.engine.salary.entity.salarysob.param.SalarySobBasicSaveParam;
import com.engine.salary.entity.salarysob.param.SalarySobDisableParam;
import com.engine.salary.entity.salarysob.param.SalarySobDuplicateParam;
import com.engine.salary.entity.salarysob.po.*;
import com.engine.salary.enums.SalarySystemTypeEnum;
import com.engine.salary.enums.salarysob.IncomeCategoryEnum;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.service.*;
import com.engine.salary.util.SalaryEntityUtil;
import com.engine.salary.util.SalaryI18nUtil;
import com.engine.salary.util.valid.RuntimeTypeEnum;
import com.engine.salary.util.valid.ValidUtil;
import com.google.common.collect.Lists;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.transaction.annotation.Transactional;
import weaver.hrm.User;

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

/**
 * 薪资账套
 * <p>Copyright: Copyright (c) 2022</p>
 * <p>Company: 泛微软件</p>
 *
 * @author qiantao
 * @version 1.0
 **/
public class SalarySobServiceImpl extends Service implements SalarySobService {


    private SalarySobBiz salarySobMapper = new SalarySobBiz();
    private SalarySobRangeBiz salarySobRangeService = new SalarySobRangeBiz();
    private SalarySobEmpFieldBiz empFieldBiz = new SalarySobEmpFieldBiz();
    private SalarySobDefaultItemGroupBiz defaultItemGroupBiz = new SalarySobDefaultItemGroupBiz();
    private SalarySobEmpFieldBiz salarySobEmpFieldService = new SalarySobEmpFieldBiz();
    private SalarySobDefaultItemBiz salarySobDefaultItemService = new SalarySobDefaultItemBiz();
    private SalarySobItemBiz salarySobItemService = new SalarySobItemBiz();
    private SalarySobItemGroupBiz salarySobItemGroupService = new SalarySobItemGroupBiz();


    private SalaryItemService getSalaryItemService(User user) {
        return (SalaryItemService) ServiceUtil.getService(SalaryItemServiceImpl.class, user);
    }

    private SysSalaryItemService getSysSalaryItemService(User user) {
        return (SysSalaryItemService) ServiceUtil.getService(SysSalaryItemServiceImpl.class, user);
    }
    private SalarySobAdjustRuleBiz salarySobAdjustRuleService = new SalarySobAdjustRuleBiz();

    private SalarySobCheckRuleService getSalarySobCheckRuleService(User user) {
        return (SalarySobCheckRuleService) ServiceUtil.getService(SalarySobCheckRuleServiceImpl.class, user);
    }
//
//    private LoggerTemplate salarySobLoggerTemplate;
//
    private SalaryAcctRecordService getSalaryAcctRecordService(User user) {
        return (SalaryAcctRecordService) ServiceUtil.getService(SalaryAcctRecordServiceImpl.class, user);
    }

    @Override
    public SalarySobPO getById(Long id) {
        return salarySobMapper.getById(id);
    }

    @Override
    public List<SalarySobPO> listByIds(Collection<Long> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return Collections.emptyList();
        }
        return salarySobMapper.listSome(SalarySobPO.builder().ids(ids).build());
    }

    @Override
    public List<SalarySobPO> listByName(String name) {
        if (StringUtils.isEmpty(name)) {
            return Collections.emptyList();
        }
        return salarySobMapper.listSome(SalarySobPO.builder().name(name).build());
    }

    @Override
    public List<SalarySobPO> listByNameLike(String nameLike) {
        if (StringUtils.isEmpty(nameLike)) {
            return Collections.emptyList();
        }
        return salarySobMapper.listByParam(SalarySobPO.builder().name(nameLike).build());
    }

    @Override
    public List<SalarySobPO> listByDisable(Integer disable) {
        return salarySobMapper.listSome(SalarySobPO.builder().disable(disable).build());
    }

    @Override
    public List<SalarySobPO> listByIncomeCategory(IncomeCategoryEnum incomeCategory) {
        return salarySobMapper.listSome(SalarySobPO.builder().incomeCategory(incomeCategory.getValue()).build());
    }

//    @Override
//    public Page<SalarySobPO> listPageByParam(SalarySobListQueryParam queryParam, String tenantKey) {
//        // 分页参数
//        Page<SalarySobPO> page = SalaryPageUtil.buildPage(queryParam.getCurrent(), queryParam.getPageSize());
//        // 查询薪资账套
//        return new LambdaQueryChainWrapper<>(salarySobMapper)
//                .eq(SalarySobPO::getTenantKey, tenantKey)
//                .eq(SalarySobPO::getDeleteType, 0)
//                .like(StringUtils.isNotEmpty(queryParam.getName()), SalarySobPO::getName, queryParam.getName())
//                .orderByDesc(SalarySobPO::getId)
//                .page(page);
//    }

    @Override
    public Long save(SalarySobBasicSaveParam saveParam) {

        ValidUtil.doValidator(saveParam);

        // 薪资账套的名称不能重复
        List<SalarySobPO> salarySobPOS = listByName(saveParam.getName());
        if (CollectionUtils.isNotEmpty(salarySobPOS)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(98403, "薪资账套名称已存在"));
        }
        // 保存参数转换成薪资账套po
        SalarySobPO salarySobPO = SalarySobBO.convert2PO(saveParam, (long) user.getUID());
        // 保存薪资账套
        salarySobMapper.insert(salarySobPO);
        //todo 记录日志
//        LoggerContext<SalarySobPO> loggerContext = new LoggerContext<>();
//        loggerContext.setTargetId(String.valueOf(salarySobPO.getId()));
//        loggerContext.setTargetName(salarySobPO.getName());
//        loggerContext.setOperateType(OperateTypeEnum.ADD.getValue());
//        loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(98404, "新建薪资账套"));
//        loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(98404, "新建薪资账套") + ": " + salarySobPO.getName());
//        loggerContext.setOldValues(salarySobPO);
//        salarySobLoggerTemplate.write(loggerContext);
        // 新建薪资账套时，保存默认的员工信息字段
        saveDefaultEmpField(salarySobPO);
        // 新建薪资账套时，保存默认的薪资项目
        saveDefaultItem(salarySobPO);
        // 返回薪资账套的主键id
        return salarySobPO.getId();
    }

    /**
     * todo
     * 新建薪资账套时，保存默认的员工信息字段
     *
     * @param salarySobPO 薪资账套
     */
    private void saveDefaultEmpField(SalarySobPO salarySobPO) {
        // 查询薪资账套默认的员工信息字段
        List<SalarySobDefaultEmpFieldPO> salarySobDefaultEmpFieldPOS = empFieldBiz.listDefaultEmpField();
        // 转换成薪资账套员工信息字段po
        List<SalarySobEmpFieldPO> salarySobEmpFieldPOS = SalarySobItemBO.convert2EmpFieldPO(salarySobPO.getId(), salarySobDefaultEmpFieldPOS, (long) user.getUID());
        // 保存
        empFieldBiz.batchInsert(salarySobEmpFieldPOS);
    }

    /**
     * 新建薪资账套时，保存默认的薪资项目
     * 1、薪资账套默认引用的系统薪资项目
     * 2、自定义薪资项目中开启了"默认使用"的薪资项目
     *
     * @param salarySobPO 薪资账套
     */
    private void saveDefaultItem(SalarySobPO salarySobPO) {
        // 1、根据薪资类型查询薪资账套默认使用的薪资项目分类以及薪资项目
        IncomeCategoryEnum incomeCategoryEnum = IncomeCategoryEnum.parseByValue(salarySobPO.getIncomeCategory());
        List<SalarySobDefaultItemGroupPO> salarySobDefaultItemGroupPOS = defaultItemGroupBiz.listByIncomeCategory(incomeCategoryEnum);
        List<SalarySobDefaultItemPO> salarySobDefaultItemPOS = salarySobDefaultItemService.listByIncomeCategory(SalarySobDefaultItemPO.builder().incomeCategory(incomeCategoryEnum.getValue()).build());
        // 2、薪资账套默认引用的系统薪资项目如果没有添加到薪资项目中，这里要给添加保存
        // 2.1、查询已经添加到薪资项目中的系统薪资项目
        Set<Long> defaultSysSalaryItemIds = SalaryEntityUtil.properties(salarySobDefaultItemPOS, SalarySobDefaultItemPO::getSysSalaryItemId);
        List<SalaryItemPO> salaryItemPOS = getSalaryItemService(user).listBySysSalaryItemIds(defaultSysSalaryItemIds);
        Set<Long> sysSalaryItemIds = SalaryEntityUtil.properties(salaryItemPOS, SalaryItemPO::getSysSalaryItemId);
        // 2.2、需要添加进薪资项目中的系统薪资项目id
        Set<Long> needAddSysSalaryItemIds = salarySobDefaultItemPOS.stream()
                .map(SalarySobDefaultItemPO::getSysSalaryItemId)
                .filter(sysSalaryItemId -> !sysSalaryItemIds.contains(sysSalaryItemId))
                .collect(Collectors.toSet());
        List<SysSalaryItemPO> needAddSysSalaryItemPOS = getSysSalaryItemService(user).listByIds(needAddSysSalaryItemIds);
        // 2.3、需要保存的薪资项目
        List<SalaryItemPO> needInsertSalaryItemPOS = SysSalaryItemBO.convert2SalaryItemPO(needAddSysSalaryItemPOS, (long) user.getUID());
        if (CollectionUtils.isNotEmpty(needInsertSalaryItemPOS)) {
            getSalaryItemService(user).batchSave(needInsertSalaryItemPOS);
        }

        // 3、查询开启了"默认使用"的自定义薪资项目
        List<SalaryItemPO> useDefaultSalaryItemPOS = getSalaryItemService(user).listBySystemTypeAndUseDefault(SalarySystemTypeEnum.CUSTOM, NumberUtils.INTEGER_ONE);

        // 4、默认引用的薪资项目（=薪资账套默认引用的系统薪资项目(已添加进薪资项目中的) + 薪资账套默认引用的系统薪资项目(待添加进薪资项目中的) + 自定义薪资项目中开启了"默认使用"的薪资项目）
        List<SalaryItemPO> defaultSalaryItemPOS = Lists.newArrayListWithExpectedSize(salaryItemPOS.size() + needInsertSalaryItemPOS.size() + useDefaultSalaryItemPOS.size());
        defaultSalaryItemPOS.addAll(salaryItemPOS);
        defaultSalaryItemPOS.addAll(needInsertSalaryItemPOS);
        defaultSalaryItemPOS.addAll(useDefaultSalaryItemPOS);

        // 5、保存
        SalarySobItemBO.Result result = SalarySobItemBO.initSalarySobItem(salarySobPO.getId(), salarySobDefaultItemGroupPOS, salarySobDefaultItemPOS, defaultSalaryItemPOS, (long) user.getUID(), SalaryDefaultTenantConstant.DEFAULT_TENANT_KEY);
        if (CollectionUtils.isNotEmpty(result.getNeedInsertSalarySobItems())) {
            salarySobItemService.batchInsert(result.getNeedInsertSalarySobItems());
        }
        if (CollectionUtils.isNotEmpty(result.getNeedInsertSalarySobItemGroups())) {
            salarySobItemGroupService.batchInsert(result.getNeedInsertSalarySobItemGroups());
        }
    }

    @Override
    public Long update(SalarySobBasicSaveParam saveParam) {

        ValidUtil.doValidator(saveParam, RuntimeTypeEnum.UPDATE);

        // 查询薪资账套
        SalarySobPO salarySobPO = getById(saveParam.getId());
        if (Objects.isNull(salarySobPO)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(98379, "参数错误，薪资账套不存在或者已被删除"));
        }
        // 薪资账套的名称不能重复
        List<SalarySobPO> salarySobPOS = listByName(saveParam.getName());
        boolean duplicateName = salarySobPOS.stream().anyMatch(e -> !Objects.equals(e.getId(), saveParam.getId()));
        if (duplicateName) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(98403, "薪资账套名称已存在"));
        }
        // 更新薪资账套
        SalarySobPO newSalarySobPO = new SalarySobPO();
        BeanUtils.copyProperties(salarySobPO, newSalarySobPO);
        newSalarySobPO.setId(saveParam.getId())
                .setName(saveParam.getName())
                .setIncomeCategory(saveParam.getTaxableItems())
                .setSalaryCycleType(saveParam.getSalaryCycleType())
                .setSalaryCycleFromDay(saveParam.getSalaryCycleFromDay())
                .setTaxCycleType(saveParam.getTaxCycleType())
                .setAttendCycleType(saveParam.getAttendCycleType())
                .setAttendCycleFromDay(saveParam.getAttendCycleFromDay())
                .setSocialSecurityCycleType(saveParam.getSocialSecurityCycleType())
                .setDescription(saveParam.getDescription())
                .setUpdateTime(new Date());
        salarySobMapper.updateById(newSalarySobPO);
        // 记录日志
//        LoggerContext<SalarySobPO> loggerContext = new LoggerContext<>();
//        loggerContext.setTargetId(String.valueOf(newSalarySobPO.getId()));
//        loggerContext.setTargetName(newSalarySobPO.getName());
//        loggerContext.setOperateType(OperateTypeEnum.UPDATE.getValue());
//        loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(98526, "编辑薪资账套基础设置"));
//        loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(98526, "编辑薪资账套基础设置"));
//        loggerContext.setOldValues(salarySobPO);
//        loggerContext.setNewValues(newSalarySobPO);
//        salarySobLoggerTemplate.write(loggerContext);
        // 返回薪资账套的主键id
        return salarySobPO.getId();
    }

    @Override
    public void updateDisable(SalarySobDisableParam disableParam) {
        // 查询薪资账套
        SalarySobPO salarySobPO = getById(disableParam.getId());
        if (Objects.isNull(salarySobPO)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(98379, "参数错误，薪资账套不存在或者已被删除"));
        }
        // 启用/禁用 薪资账套
        salarySobPO.setDisable(disableParam.getDisable());
        salarySobPO.setUpdateTime(new Date());
        salarySobMapper.updateById(salarySobPO);
        // todo 记录日志
//        String operateTypeName = Objects.equals(disableParam.getDisable(), NumberUtils.INTEGER_ONE) ?
//                SalaryI18nUtil.getI18nLabel(98591, "禁用薪资账套") : SalaryI18nUtil.getI18nLabel(98592, "启用薪资账套");
//        LoggerContext<SalarySobPO> loggerContext = new LoggerContext<>();
//        loggerContext.setTargetId("" + salarySobPO.getId());
//        loggerContext.setTargetName(salarySobPO.getName());
//        loggerContext.setOperateType(OperateTypeEnum.UPDATE.getValue());
//        loggerContext.setOperateTypeName(operateTypeName);
//        loggerContext.setOperatedesc(operateTypeName + ": " + salarySobPO.getName());
//        salarySobLoggerTemplate.write(loggerContext);
    }

    @Override
    public void deleteByIds(Collection<Long> ids) {
        // 查询薪资账套
        List<SalarySobPO> salarySobPOS = listByIds(ids);
        if (CollectionUtils.isEmpty(salarySobPOS)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(98379, "参数错误，薪资账套不存在或者已被删除"));
        }
        ids = SalaryEntityUtil.properties(salarySobPOS, SalarySobPO::getId);
        // 根据薪资账套id查询薪资核算记录，存在薪资核算记录就不能删除账套了
        List<SalaryAcctRecordPO> salaryAcctRecordPOS = getSalaryAcctRecordService(user).listBySalarySobIds(ids);
        if (CollectionUtils.isNotEmpty(salaryAcctRecordPOS)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(99713, "账套已用于薪资核算，不能删除"));
        }
        //关联其他的删除
        // 删除薪资账套
        salarySobMapper.deleteByIds(ids);
        // 删除薪资账套的人员范围
        salarySobRangeService.deleteBySalarySobIds(ids);
        // 删除薪资账套的人员信息字段
        salarySobEmpFieldService.deleteBySalarySobIds(ids);
        // 删除薪资账套的薪资项目
        salarySobItemService.deleteBySalarySobIds(ids);
        // 删除薪资账套的薪资项目分类
        salarySobItemGroupService.deleteBySalarySobIds(ids);
        // 删除薪资账套的调薪计薪规则
        salarySobAdjustRuleService.deleteBySalarySobIds(ids);
//        // 删除薪资账套的校验规则
        getSalarySobCheckRuleService(user).deleteBySalarySobIds(ids);
//        // 记录日志
//        salarySobPOS.forEach(salarySobPO -> {
//            LoggerContext<SalarySobPO> loggerContext = new LoggerContext<>();
//            loggerContext.setTargetId("" + salarySobPO.getId());
//            loggerContext.setTargetName(salarySobPO.getName());
//            loggerContext.setOperateType(OperateTypeEnum.DELETE.getValue());
//            loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(98535, "删除薪资账套"));
//            loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(98535, "删除薪资账套"));
//            salarySobLoggerTemplate.write(loggerContext);
//        });
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void duplicate(SalarySobDuplicateParam duplicateParam) {
        // 查询薪资账套
        SalarySobPO salarySobPO = getById(duplicateParam.getId());
        if (Objects.isNull(salarySobPO)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(98379, "参数错误，薪资账套不存在或者已被删除"));
        }
        // 薪资账套名称不能重复
        List<SalarySobPO> salarySobPOS = listByName(duplicateParam.getName());
        if (CollectionUtils.isNotEmpty(salarySobPOS)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(98403, "薪资账套名称已存在"));
        }
        // 查询薪资账套的员工信息字段
        List<SalarySobEmpFieldPO> salarySobEmpFieldPOS = salarySobEmpFieldService.listSome(SalarySobEmpFieldPO.builder().salarySobId(duplicateParam.getId()).build());
        // 查询薪资账套的薪资项目副本
        List<SalarySobItemPO> salarySobItemPOS = salarySobItemService.listSome(SalarySobItemPO.builder().salarySobId(duplicateParam.getId()).build());
        // 查询薪资账套的薪资项目分类
        List<SalarySobItemGroupPO> salarySobItemGroupPOS = salarySobItemGroupService.listSome(SalarySobItemGroupPO.builder().salarySobId(duplicateParam.getId()).build());
        // 查询薪资账套的调薪计薪规则
        List<SalarySobAdjustRulePO> salarySobAdjustRulePOS = salarySobAdjustRuleService.listBySalarySobId(duplicateParam.getId());
        // 查询薪资账套的校验规则
        List<SalarySobCheckRulePO> salarySobCheckRulePOS = getSalarySobCheckRuleService(user).listBySalarySobId(duplicateParam.getId());


        // 复制薪资账套的基础设置
        SalarySobPO newSalarySob = SalarySobPO.builder()
                .name(duplicateParam.getName())
                .incomeCategory(salarySobPO.getIncomeCategory())
                .salaryCycleType(salarySobPO.getSalaryCycleType())
                .salaryCycleFromDay(salarySobPO.getSalaryCycleFromDay())
                .taxCycleType(salarySobPO.getTaxCycleType())
                .attendCycleType(salarySobPO.getAttendCycleType())
                .attendCycleFromDay(salarySobPO.getAttendCycleFromDay())
                .socialSecurityCycleType(salarySobPO.getSocialSecurityCycleType())
                .disable(salarySobPO.getDisable())
                .creator((long)user.getUID())
                .createTime(new Date())
                .updateTime(new Date())
                .tenantKey(SalaryDefaultTenantConstant.DEFAULT_TENANT_KEY)
                .deleteType(NumberUtils.INTEGER_ZERO)
                .build();
        salarySobMapper.insert(newSalarySob);
        // 复制
        SalarySobDuplicateBO salarySobDuplicateBO = new SalarySobDuplicateBO(newSalarySob, salarySobEmpFieldPOS, salarySobItemPOS,
                salarySobItemGroupPOS, salarySobAdjustRulePOS, salarySobCheckRulePOS);
        SalarySobDuplicateBO.Result result = salarySobDuplicateBO.duplicate((long)user.getUID());
        // 复制薪资账套的员工信息字段
        if (CollectionUtils.isNotEmpty(result.getSalarySobEmpFields())) {
            salarySobEmpFieldService.batchInsert(result.getSalarySobEmpFields());
        }
        // 复制薪资账套的薪资项目副本
        if (CollectionUtils.isNotEmpty(result.getSalarySobItems())) {
            salarySobItemService.batchInsert(result.getSalarySobItems());
        }
        // 复制薪资账套的薪资项目分类
        if (CollectionUtils.isNotEmpty(result.getSalarySobItemGroups())) {
            salarySobItemGroupService.batchInsert(result.getSalarySobItemGroups());
        }
        // 复制薪资账套的调薪计薪规则
        if (CollectionUtils.isNotEmpty(result.getSalaryAdjustmentRules())) {
            salarySobAdjustRuleService.batchInsert(result.getSalaryAdjustmentRules());
        }
        // 复制薪资账套的校验规则
        if (CollectionUtils.isNotEmpty(result.getSalarySobCheckRules())) {
            getSalarySobCheckRuleService(user).batchSave(result.getSalarySobCheckRules());
        }
//        // 记录日志
//        LoggerContext<SalarySobPO> loggerContext = new LoggerContext<>();
//        loggerContext.setTargetId("" + result.getSalarySob().getId());
//        loggerContext.setTargetName(result.getSalarySob().getName());
//        loggerContext.setOperateType(OperateTypeEnum.UPDATE.getValue());
//        loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(98570, "复制薪资账套"));
//        loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(98570, "复制薪资账套") + ": " + salarySobPO.getName());
//        salarySobLoggerTemplate.write(loggerContext);
    }

    @Override
    public SalarySobCycleDTO getSalarySobCycle(Long id, YearMonth salaryMonth) {
        // 查询薪资账套
        SalarySobPO salarySobPO = getById(id);
        if (Objects.isNull(salarySobPO)) {
            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(98379, "参数错误，薪资账套不存在或者已被删除"));
        }
        return SalarySobCycleBO.buildSalarySobCycle(salarySobPO, salaryMonth);
    }
}