package com.engine.salary.service.impl;

import com.engine.core.impl.Service;
import com.engine.salary.biz.SalarySobBiz;
import com.engine.salary.entity.salarysob.bo.SalarySobBO;
import com.engine.salary.entity.salarysob.bo.SalarySobCycleBO;
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.SalarySobPO;
import com.engine.salary.enums.salarysob.IncomeCategoryEnum;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.service.SalaryItemService;
import com.engine.salary.service.SalarySobDefaultItemService;
import com.engine.salary.service.SalarySobService;
import com.engine.salary.service.SysSalaryItemService;
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 org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.transaction.annotation.Transactional;

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

/**
 * 薪资账套
 * <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 SalarySobRangeService salarySobRangeService;

//    private SalarySobDefaultEmpFieldService salarySobDefaultEmpFieldService;

//    private SalarySobEmpFieldService salarySobEmpFieldService;
//
    private SalarySobDefaultItemService salarySobDefaultItemService;



//
//    private SalarySobItemService salarySobItemService;
//
    private SalaryItemService salaryItemService;
//
    private SysSalaryItemService sysSalaryItemService;
//
//    private SalarySobItemGroupService salarySobItemGroupService;
//
//    private SalarySobAdjustRuleService salarySobAdjustRuleService;
//
//    private SalarySobCheckRuleService salarySobCheckRuleService;
//
//    private LoggerTemplate salarySobLoggerTemplate;
//
//    private SalaryAcctRecordService salaryAcctRecordService;

    @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 = salarySobDefaultEmpFieldService.list();
//        // 转换成薪资账套员工信息字段po
//        List<SalarySobEmpFieldPO> salarySobEmpFieldPOS = SalarySobItemBO.convert2EmpFieldPO(salarySobPO.getId(), salarySobDefaultEmpFieldPOS, employeeId, tenantKey);
//        // 保存
//        salarySobEmpFieldService.batchSave(salarySobEmpFieldPOS);
    }

    /**
     * todo
     * 新建薪资账套时，保存默认的薪资项目
     * 1、薪资账套默认引用的系统薪资项目
     * 2、自定义薪资项目中开启了"默认使用"的薪资项目
     *
     * @param salarySobPO 薪资账套
     */
    private void saveDefaultItem(SalarySobPO salarySobPO) {
//        // 1、根据薪资类型查询薪资账套默认引用的系统薪资项目
//        List<SalarySobDefaultItemPO> salarySobDefaultItemPOS = salarySobDefaultItemService.listByIncomeCategory(IncomeCategoryEnum.parseByValue(salarySobPO.getIncomeCategory()));
//        // 2、薪资账套默认引用的系统薪资项目如果没有添加到薪资项目中，这里要给添加保存
//        // 2.1、查询已经添加到薪资项目中的系统薪资项目
//        Set<Long> defaultSysSalaryItemIds = SalaryEntityUtil.properties(salarySobDefaultItemPOS, SalarySobDefaultItemPO::getSysSalaryItemId);
//        List<SalaryItemPO> salaryItemPOS = salaryItemService.listBySysSalaryItemIds(defaultSysSalaryItemIds, tenantKey);
//        Set<Long> sysSalaryItemIds = SalaryEntityUtil.properties(salaryItemPOS, SalaryItemPO::getSysSalaryItemId);
//        // 2.2、需要添加进薪资项目中的系统薪资项目id
//        Set<Long> needAddSysSalaryItemIds = salarySobDefaultItemPOS.stream()
//                .filter(salarySobDefaultItemPO -> !sysSalaryItemIds.contains(salarySobDefaultItemPO.getSysSalaryItemId()))
//                .map(SalarySobDefaultItemPO::getSysSalaryItemId)
//                .collect(Collectors.toSet());
//        List<SysSalaryItemPO> needAddSysSalaryItemPOS = sysSalaryItemService.listByIds(needAddSysSalaryItemIds);
//        // 2.3、需要保存的薪资项目
//        List<SalaryItemPO> needInsertSalaryItemPOS = SysSalaryItemBO.convert2SalaryItemPO(needAddSysSalaryItemPOS, (long)user.getUID());
//        if (CollectionUtils.isNotEmpty(needInsertSalaryItemPOS)) {
//            salaryItemService.batchSave(needInsertSalaryItemPOS);
//        }
//
//        // 3、查询开启了"默认使用"的自定义薪资项目
//        List<SalaryItemPO> useDefaultSalaryItemPOS = salaryItemService.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、保存
//        List<SalarySobItemPO> salarySobItemPOS = SalarySobItemBO.convert2ItemPO(salarySobPO.getId(), defaultSalaryItemPOS, employeeId);
//        if (CollectionUtils.isNotEmpty(salarySobItemPOS)) {
//            salarySobItemService.batchSave(salarySobItemPOS);
//        }
    }

    @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.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, "参数错误，薪资账套不存在或者已被删除"));
        }
        //fixme 关联其他的删除
        ids = SalaryEntityUtil.properties(salarySobPOS, SalarySobPO::getId);
        // 根据薪资账套id查询薪资核算记录，存在薪资核算记录就不能删除账套了
//        List<SalaryAcctRecordPO> salaryAcctRecordPOS = salaryAcctRecordService.listBySalarySobIds(ids);
//        if (CollectionUtils.isNotEmpty(salaryAcctRecordPOS)) {
//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(99713, "账套已用于薪资核算，不能删除"));
//        }
//        // 删除薪资账套
//        salarySobMapper.deleteByIds(ids, tenantKey);
//        // 删除薪资账套的人员范围
//        salarySobRangeService.deleteBySalarySobIds(ids, tenantKey);
//        // 删除薪资账套的人员信息字段
//        salarySobEmpFieldService.deleteBySalarySobIds(ids, tenantKey);
//        // 删除薪资账套的薪资项目
//        salarySobItemService.deleteBySalarySobIds(ids, tenantKey);
//        // 删除薪资账套的薪资项目分类
//        salarySobItemGroupService.deleteBySalarySobIds(ids, tenantKey);
//        // 删除薪资账套的调薪计薪规则
//        salarySobAdjustRuleService.deleteBySalarySobIds(ids, tenantKey);
//        // 删除薪资账套的校验规则
//        salarySobCheckRuleService.deleteBySalarySobIds(ids, tenantKey);
//        // 记录日志
//        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.listBySalarySobId(duplicateParam.getId());
//        // 查询薪资账套的薪资项目副本
//        List<SalarySobItemPO> salarySobItemPOS = salarySobItemService.listBySalarySobId(duplicateParam.getId());
//        // 查询薪资账套的薪资项目分类
//        List<SalarySobItemGroupPO> salarySobItemGroupPOS = salarySobItemGroupService.listBySalarySobId(duplicateParam.getId(), tenantKey);
//        // 查询薪资账套的调薪计薪规则
//        List<SalarySobAdjustRulePO> salarySobAdjustRulePOS = salarySobAdjustRuleService.listBySalarySobId(duplicateParam.getId(), tenantKey);
//        // 查询薪资账套的校验规则
//        List<SalarySobCheckRulePO> salarySobCheckRulePOS = salarySobCheckRuleService.listBySalarySobId(duplicateParam.getId(), tenantKey);
//
//        // 复制
//        SalarySobDuplicateBO salarySobDuplicateBO = new SalarySobDuplicateBO(salarySobPO, salarySobEmpFieldPOS, salarySobItemPOS,
//                salarySobItemGroupPOS, salarySobAdjustRulePOS, salarySobCheckRulePOS);
//        SalarySobDuplicateBO.Result result = salarySobDuplicateBO.duplicate(duplicateParam.getName(), employeeId, tenantKey);
//        // 复制薪资账套的基础设置
//        salarySobMapper.insert(result.getSalarySob());
//        // 复制薪资账套的员工信息字段
//        if (CollectionUtils.isNotEmpty(result.getSalarySobEmpFields())) {
//            salarySobEmpFieldService.batchSave(result.getSalarySobEmpFields());
//        }
//        // 复制薪资账套的薪资项目副本
//        if (CollectionUtils.isNotEmpty(result.getSalarySobItems())) {
//            salarySobItemService.batchSave(result.getSalarySobItems());
//        }
//        // 复制薪资账套的薪资项目分类
//        if (CollectionUtils.isNotEmpty(result.getSalarySobItemGroups())) {
//            salarySobItemGroupService.batchSave(result.getSalarySobItemGroups());
//        }
//        // 复制薪资账套的调薪计薪规则
//        if (CollectionUtils.isNotEmpty(result.getSalaryAdjustmentRules())) {
//            salarySobAdjustRuleService.batchSave(result.getSalaryAdjustmentRules());
//        }
//        // 复制薪资账套的校验规则
//        if (CollectionUtils.isNotEmpty(result.getSalarySobCheckRules())) {
//            salarySobCheckRuleService.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);
    }
}