package com.engine.salary.service.auth;

import cn.hutool.core.collection.CollectionUtil;
import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service;
import com.engine.hrmelog.entity.dto.LoggerContext;
import com.engine.salary.config.SalaryElogConfig;
import com.engine.salary.constant.SalaryDefaultTenantConstant;
import com.engine.salary.entity.auth.param.AuthRoleSaveParam;
import com.engine.salary.entity.auth.po.AuthLimitPO;
import com.engine.salary.entity.auth.po.AuthRolePO;
import com.engine.salary.entity.taxagent.po.TaxAgentPO;
import com.engine.salary.enums.OperateTypeEnum;
import com.engine.salary.exception.SalaryRunTimeException;
import com.engine.salary.mapper.auth.AuthLimitMapper;
import com.engine.salary.mapper.auth.AuthRoleMapper;
import com.engine.salary.util.SalaryI18nUtil;
import com.engine.salary.util.db.IdGenerator;
import com.engine.salary.util.db.MapperProxyFactory;
import weaver.hrm.User;

import java.util.Collections;
import java.util.Date;
import java.util.List;

public class AuthRoleServiceImpl extends Service implements AuthRoleService {

    private AuthRoleMapper getAuthRoleMapper() {
        return MapperProxyFactory.getProxy(AuthRoleMapper.class);
    }

    private AuthLimitMapper getAuthLimitMapper() {
        return MapperProxyFactory.getProxy(AuthLimitMapper.class);
    }

    private AuthMemberService getAuthMemberService(User user) {
        return ServiceUtil.getService(AuthMemberServiceImpl.class, user);
    }

    private AuthOptService getAuthOptService(User user) {
        return ServiceUtil.getService(AuthOptServiceImpl.class, user);
    }

    private AuthDataService getAuthDataService(User user) {
        return ServiceUtil.getService(AuthDataServiceImpl.class, user);
    }


    @Override
    public List<AuthRolePO> roleList(Long taxAgentId) {
        return getAuthRoleMapper().listSome(AuthRolePO.builder().taxAgentId(taxAgentId).build());
    }

    @Override
    public Long saveRole(AuthRoleSaveParam param) {
        Date now = new Date();
        Long id = param.getId();
        String name = param.getName();
        String description = param.getDescription();
        Long taxAgentId = param.getTaxAgentId();
        List<Long> limitSobIds = param.getLimitSobIds();


        AuthRolePO po;
        if (id == null) {
            po = AuthRolePO.builder()
                    .id(IdGenerator.generate())
                    .name(name)
                    .description(description)
                    .taxAgentId(taxAgentId)
                    .creator((long) user.getUID())
                    .createTime(now)
                    .updateTime(now)
                    .deleteType(0)
                    .tenantKey(SalaryDefaultTenantConstant.DEFAULT_TENANT_KEY)
                    .build();
            getAuthRoleMapper().insertIgnoreNull(po);

            LoggerContext<TaxAgentPO> loggerContext = new LoggerContext<>();
            loggerContext.setUser(user);
            loggerContext.setTargetId(taxAgentId + "");
            loggerContext.setTargetName("角色：" + name);
            loggerContext.setOperateType(OperateTypeEnum.ADD.getValue());
            loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(0, "新增角色"));
            loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(0, "新增角色"));
            loggerContext.setNewValues(po);
            SalaryElogConfig.taxAgentLoggerTemplate.write(loggerContext);

        } else {
            po = getAuthRoleMapper().getById(id);
            if (po == null) {
                throw new SalaryRunTimeException("角色不存在！");
            }
            AuthRolePO newPo = AuthRolePO.builder()
                    .id(id)
                    .name(name)
                    .description(description)
                    .taxAgentId(po.getTaxAgentId())
                    .updateTime(now)
                    .build();
            getAuthRoleMapper().updateIgnoreNull(newPo);

            LoggerContext<TaxAgentPO> loggerContext = new LoggerContext<>();
            loggerContext.setUser(user);
            loggerContext.setTargetId(taxAgentId + "");
            loggerContext.setTargetName("角色：" + name);
            loggerContext.setOperateType(OperateTypeEnum.UPDATE.getValue());
            loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(0, "更新角色"));
            loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(0, "更新角色"));
            loggerContext.setOldValues(po);
            loggerContext.setNewValues(newPo);
            SalaryElogConfig.taxAgentLoggerTemplate.write(loggerContext);
        }

        getAuthLimitMapper().deleteByRoleId(po.getId());
        if(CollectionUtil.isNotEmpty(limitSobIds)){
            limitSobIds.forEach(limitSobId -> {
                AuthLimitPO limitPO = AuthLimitPO.builder()
                        .id(IdGenerator.generate())
                        .roleId(po.getId())
                        .sobId(limitSobId)
                        .creator((long) user.getUID())
                        .createTime(now)
                        .updateTime(now)
                        .deleteType(0)
                        .tenantKey(SalaryDefaultTenantConstant.DEFAULT_TENANT_KEY)
                        .build();
                getAuthLimitMapper().insertIgnoreNull(limitPO);
            });
        }

        return po.getId();
    }

    @Override
    public void deleteRole(List<Long> ids) {
        ids.forEach(roleId -> {
            AuthRolePO po = getAuthRoleMapper().getById(roleId);
            if (po == null) {
                throw new SalaryRunTimeException("角色不存在！");
            }

            getAuthMemberService(user).deleteByRoleId(roleId);
            getAuthOptService(user).deleteByRoleId(roleId);
            getAuthDataService(user).deleteByRoleId(roleId);
            getAuthRoleMapper().deleteByIds(Collections.singleton(roleId));


            LoggerContext<TaxAgentPO> loggerContext = new LoggerContext<>();
            loggerContext.setUser(user);
            loggerContext.setTargetId(po.getTaxAgentId() + "");
            loggerContext.setTargetName("角色：" + po.getName());
            loggerContext.setOperateType(OperateTypeEnum.DELETE.getValue());
            loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(0, "删除角色"));
            loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(0, "删除角色"));
            loggerContext.setNewValues(po);
            SalaryElogConfig.taxAgentLoggerTemplate.write(loggerContext);
        });
    }
}