package cn.huge.module.ctuser.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.base.common.utils.ReturnFailUtils;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.constant.BaseConsts;
import cn.huge.module.ctuser.dao.mapper.CtDeptMapper;
import cn.huge.module.ctuser.domain.po.CtDept;
import cn.huge.module.ctuser.domain.po.CtUser;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @title: 客户部门表业务逻辑处理
 * @Description 客户部门表业务逻辑处理
 * @company hugeinfo
 * @author liyj
 * @Time 2024-08-19 20:04:19
 * @version 1.0.0
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class CtDeptService extends ServiceImpl<CtDeptMapper, CtDept>{

    @Autowired
    private CtDeptMapper mapper;

    @Autowired
    private UtilsClientImpl utilsClient;

    @Autowired
    private CtUserService ctUserService;

    /**
    * 更新对象
    * @param entity 对象
    */
    public void updateCtDept(CtDept entity){
        try{
            mapper.updateCtDept(entity);
        }catch (Exception e){
            log.error("[CtDeptService.updateCtDept]调用失败，异常信息："+e, e);
            throw new ServiceException("CtDeptService.updateCtDept", e);
        }
    }

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    public void updateCtDeptTerms(CtDept entity, Map<String, Object> terms){
        try{
            mapper.updateCtDeptTerms(entity, terms);
        }catch (Exception e){
            log.error("[CtDeptService.updateCtDeptTerms]调用失败，异常信息："+e, e);
            throw new ServiceException("CtDeptService.updateCtDeptTerms", e);
        }
    }

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    public void deleteCtDept(String id){
        try{
            mapper.deleteCtDept(id);
        }catch (Exception e){
            log.error("[CtDeptService.deleteCtDept]调用失败，异常信息："+e, e);
            throw new ServiceException("CtDeptService.deleteCtDept", e);
        }
    }

    /**
    * 按条件查询
    * @param terms 条件
    * @return List
    */
    public List<CtDept> listTerms(Map<String, Object> terms){
        return mapper.listTerms(terms);
    }

    /**
    * 按条件统计
    * @param terms 条件
    * @return long
    */
    public long countTerms(Map<String, Object> terms){
        return mapper.countTerms(terms);
    }

    /**
    * 按条件分页查询
    * @param page 分页对象
    * @param terms 条件
    * @return Page
    */
    public Page<CtDept> pageQuery(PageRequest page, Map<String, Object> terms){
        long total = mapper.countTerms(terms);
        List<CtDept> content = mapper.pageTerms(page, terms);
        return new PageImpl<CtDept>(content, page, total);
    }

    /**
     * 创建某一级部门下树形结构
     * @param ctDeptList 所有部门集合
     * @param firstId 某一级组织编号
     * @return List
     */
    public List<CtDept> createTree(List<CtDept> ctDeptList, String firstId) {
        List<CtDept> firstMapList= new ArrayList<>();
        for (CtDept ctDept: ctDeptList ){
            for(CtDept deptParam: ctDeptList ) {
                if (deptParam.getId().equals(ctDept.getParentId())) {
                    addToMBean(deptParam, ctDept);
                    break;
                }
            }
        }
        //取第一级节点
        for (CtDept dept: ctDeptList ){
            if (StringUtils.isNotEmpty(firstId)){
                if (firstId.equals(dept.getId())) {
                    firstMapList.add(dept);
                }
            }else{
                if (BaseConsts.ROOT.equals(dept.getParentId()) || StringUtils.isEmpty(dept.getParentId())) {
                    firstMapList.add(dept);
                }
            }
        }
        return firstMapList;
    }

    /**
     * 获取部门的子级部门
     * @param targetUnit 目标部门
     * @param currentUnit 子级部门
     */
    public void addToMBean(CtDept targetUnit, CtDept currentUnit){
        List<CtDept> childListObj = targetUnit.getChildren();
        List<CtDept> childList = null;
        if(CollectionUtils.isEmpty(childListObj)) {
            childList = new ArrayList();
            targetUnit.setChildren(childList);
        }else{
            childList = childListObj;
        }
        childList.add(currentUnit);
    }

    /**
     * 新增或更新对象部门
     * @param ctDept 实体对象
     */
    public void saveCtDept(CtDept ctDept, String userId){
        try{
            // 获取当前登录用户
            CtUser loginCtUser = ctUserService.getById(userId);

            // 保存新增更新组织
            ctDept.setCustId(loginCtUser.getCustId());

            Date nowDate = DateUtils.getNowDate();
            // 判断是否新增
            if (IdUtils.checkNewId(ctDept.getId())){
                ctDept.setId(utilsClient.getNewTimeId());
                ctDept.setCreateTime(nowDate);
                // 新增上级部门
                if (StringUtils.isNotEmpty(ctDept.getDeptId())){
                    // 更新子级部门的父级编号为当前新增部门的编号
                    CtDept childCtDept = mapper.selectById(ctDept.getDeptId());
                    childCtDept.setParentId(ctDept.getId());
                    mapper.updateById(childCtDept);
                }else{
                    // 新增下级部门，如果没有指定上级编号，则默认为根级
                    if (StringUtils.isBlank(ctDept.getParentId())) {
                        ctDept.setParentId(BaseConsts.ROOT);
                    }
                }
            }
            ctDept.setUpdateTime(nowDate);
            ctDept.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
            // 部门下成员
            QueryWrapper<CtUser> ctUserQueryWrapper = new QueryWrapper<>();
            ctUserQueryWrapper.eq("dept_id", ctDept.getId());
            List<CtUser> matchUsers = ctUserService.list(ctUserQueryWrapper);
            for (CtUser ctUser : matchUsers){
                ctUser.setDeptId(null);
                ctUser.setDeptName(null);
                ctUserService.saveOrUpdate(ctUser);
            }
            List<CtUser> ctUsers = ctDept.getMatchUsers();
            for (CtUser ctUser : ctUsers){
                CtUser ctUser1 = ctUserService.getById(ctUser.getId());
                ctUser1.setDeptId(ctDept.getId());
                ctUser1.setDeptName(ctDept.getName());
                ctUserService.saveOrUpdate(ctUser1);
            }
            this.saveOrUpdate(ctDept);
        }catch (Exception e){
            log.error("service方法[CtDeptService.saveCtDept]调用异常："+e, e);
            throw new ServiceException("CtDeptService.saveCtDept", e);
        }
    }

}