package com.gkhy.labRiskManage.domain.basic.service.impl;

import com.gkhy.labRiskManage.application.basic.dto.bo.BasicRiskUnitAppInsertBO;
import com.gkhy.labRiskManage.application.basic.dto.bo.BasicRiskUnitAppQueryBO;
import com.gkhy.labRiskManage.application.basic.dto.bo.BasicRiskUnitAppUpdateBO;
import com.gkhy.labRiskManage.commons.domain.SearchResult;
import com.gkhy.labRiskManage.commons.enums.ResultCode;
import com.gkhy.labRiskManage.commons.enums.StatusEnum;
import com.gkhy.labRiskManage.commons.enums.UserRoleEnum;
import com.gkhy.labRiskManage.commons.enums.UserTagEnum;
import com.gkhy.labRiskManage.commons.exception.BusinessException;
import com.gkhy.labRiskManage.commons.utils.BeanCopyUtils;
import com.gkhy.labRiskManage.domain.account.model.dto.SysUserRoleBindDomainDTO;
import com.gkhy.labRiskManage.domain.account.model.dto.UserInfoDomainDTO;
import com.gkhy.labRiskManage.domain.account.service.UserDomainService;
import com.gkhy.labRiskManage.domain.basic.entity.BasicRiskUnit;
import com.gkhy.labRiskManage.domain.basic.model.dto.*;
import com.gkhy.labRiskManage.domain.basic.repository.jpa.BasicRiskUnitRepository;
import com.gkhy.labRiskManage.domain.basic.service.BasicExperimentDeviceService;
import com.gkhy.labRiskManage.domain.basic.service.BasicExperimentSiteService;
import com.gkhy.labRiskManage.domain.basic.service.BasicRiskUnitService;
import com.gkhy.labRiskManage.domain.riskReport.entity.RiskUnit;
import com.gkhy.labRiskManage.domain.riskReport.utils.GetRoleTagUtils;
import com.gkhy.labRiskManage.domain.riskReport.utils.SearchAuthUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;


/**
 * 基础风险单元管理
 */
@Service
public class BasicRiskUnitServiceImpl implements BasicRiskUnitService {

    @Autowired
    private BasicRiskUnitRepository riskUnitRepository;
    @Autowired
    private BasicExperimentDeviceService basicExperimentDeviceService;
    @Autowired
    private BasicExperimentSiteService basicExperimentSiteService;
    @Autowired
    private UserDomainService userDomainService;

    /**
     * 基础风险单元管理 - 插入
     */
    @Override
    public RiskUnitInsertDTO insertBasicRiskUnit(Long currentUserId, BasicRiskUnitAppInsertBO insertReqBO) {

        if (currentUserId < 0){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无效，请重新登陆");
        }
        //参数校验、
        if (ObjectUtils.isEmpty(insertReqBO)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请求参数不能为空");
        }
        if (ObjectUtils.isEmpty(insertReqBO.getRiskCode())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险单元编号不能为空");
        }
        BasicRiskUnit riskUnitByCode = riskUnitRepository.getRiskUnitByCode(insertReqBO.getRiskCode());
//        if (!ObjectUtils.isEmpty(riskUnitByCode)){
//            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "风险单元编号已被使用");
//        }
        if (ObjectUtils.isEmpty(insertReqBO.getRiskName())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险单元名字不能为空");
        }
        BasicRiskUnit riskUnitByName = riskUnitRepository.getRiskUnitByName(insertReqBO.getRiskName());
//        if (!ObjectUtils.isEmpty(riskUnitByName)){
//            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "风险单元名称已被使用");
//        }
        // todo 人员和部门先不做校验
        if (ObjectUtils.isEmpty(insertReqBO.getLiabilityUserId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "责任人不能为空");
        }
//        if (ObjectUtils.isEmpty(insertReqBO.getLiabilityDepId())){
//            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "责任部门不能为空");
//        }
        UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
        BasicRiskUnit riskUnit = BeanCopyUtils.copyBean(insertReqBO, BasicRiskUnit.class);
        //设置必要参数
        LocalDateTime date  = LocalDateTime.now();
        riskUnit.setCreateTime(date);
        riskUnit.setCreateByUserId(userInfoById.getId());
        riskUnit.setUpdateTime(date);
        riskUnit.setUpdateByUserId(userInfoById.getId());
        riskUnit.setEvaluateStatus(StatusEnum.EVALUATE_NOT.getCode().byteValue());
        riskUnit.setDeleteStatus(StatusEnum.DELETE_NOT.getCode().byteValue());

        BasicRiskUnit insertResult = riskUnitRepository.save(riskUnit);

        return BeanCopyUtils.copyBean(insertResult, RiskUnitInsertDTO.class);
    }

    /**
     * 基础风险单元管理 - 分页查询
     */
    @Override
    public SearchResult<RiskUnitBasicQueryDTO> selectBasicRiskUnitPage(Long currentUserId, BasicRiskUnitAppQueryBO queryParam) {

        //校验参数
        if (ObjectUtils.isEmpty(queryParam.getPageSize())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode() ,"分页信息不能为空");
        }
        if (ObjectUtils.isEmpty(queryParam.getPageIndex())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode() ,"分页信息不能为空");
        }
        if (queryParam.getRiskName() == ""){
            queryParam.setRiskName(null);
        }
        if (queryParam.getRiskCode() == ""){
            queryParam.setRiskCode(null);
        }
        SearchResult searchResult = new SearchResult<>();
        searchResult.setPageIndex(queryParam.getPageIndex());
        searchResult.setPageSize(queryParam.getPageSize());

        UserInfoDomainDTO user = userDomainService.getUserById(currentUserId);
        int roleTag = GetRoleTagUtils.GetRoleTagUtils(user);
        //封装查询参数
        Specification<BasicRiskUnit> specification = new Specification<BasicRiskUnit>() {
            @Override
            public Predicate toPredicate(Root<BasicRiskUnit> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
                List<Predicate> predicateList = new ArrayList<>();
                if (queryParam.getRiskName() != null && !queryParam.getRiskName().equals("")){
                    predicateList.add(criteriaBuilder.like(root.get("riskName"),"%"+queryParam.getRiskName()+"%"));
                }
                if (queryParam.getRiskCode() != null && !queryParam.getRiskCode().equals("")){
                    predicateList.add(criteriaBuilder.equal(root.get("riskCode"), queryParam.getRiskCode()));
                }
                if (queryParam.getRiskSourceType() != null && !queryParam.getRiskSourceType().equals("")){
                    predicateList.add(criteriaBuilder.equal(root.get("riskSourceType"), queryParam.getRiskSourceType()));
                }
                if (SearchAuthUtils.basicSearchAuth() == 1){
                    if (roleTag == UserTagEnum.USER_TAG_0.getCode()){
                        predicateList.add(criteriaBuilder.equal(root.get("createByUserId"), currentUserId));
                    }
                }
                predicateList.add(criteriaBuilder.equal(root.get("deleteStatus"),StatusEnum.DELETE_NOT.getCode()));
                return criteriaBuilder.and(predicateList.toArray(new Predicate[0]));
            }
        };

        PageRequest pageParam = PageRequest.of(queryParam.getPageIndex() - 1, queryParam.getPageSize(), Sort.Direction.DESC, "updateTime");
        Page<BasicRiskUnit> pageResult = riskUnitRepository.findAll(specification, pageParam);

        List<RiskUnitBasicQueryDTO> riskUnitBasicQueryDTOS = BeanCopyUtils.copyBeanList(pageResult.getContent(), RiskUnitBasicQueryDTO.class);

        List<UserInfoDomainDTO> userList = userDomainService.getUserList();
        for (RiskUnitBasicQueryDTO riskUnitBasicQueryDTO : riskUnitBasicQueryDTOS) {
            for (UserInfoDomainDTO userInfo : userList) {
                if (userInfo.getId() == riskUnitBasicQueryDTO.getCreateByUserId()){
                    riskUnitBasicQueryDTO.setCreateByUserName(userInfo.getRealName());
                }
                if (userInfo.getId() == riskUnitBasicQueryDTO.getUpdateByUserId()){
                    riskUnitBasicQueryDTO.setUpdateByUserName(userInfo.getRealName());
                }
                if (userInfo.getId() == riskUnitBasicQueryDTO.getLiabilityUserId()){
                    riskUnitBasicQueryDTO.setLiabilityUserName(userInfo.getRealName());
                }
            }
        }

        searchResult.setData(riskUnitBasicQueryDTOS);
        searchResult.setTotal(pageResult.getTotalElements());
        return searchResult;
    }

    /**
     * 基础风险单元管理 - 修改
     */
    @Override
    public RiskUnitUpdateDTO updateBasicRiskUnit(Long currentUserId, BasicRiskUnitAppUpdateBO updateParam) {

        if (currentUserId < 0){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无效，请重新登陆");
        }
        //参数校验、
        if (ObjectUtils.isEmpty(updateParam)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请求参数不能为空");
        }
        if (ObjectUtils.isEmpty(updateParam.getRiskCode())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险单元编号不能为空");
        }
        BasicRiskUnit riskUnitByCode = riskUnitRepository.getRiskUnitByCode(updateParam.getRiskCode());
//        if (!ObjectUtils.isEmpty(riskUnitByCode) && !riskUnitByCode.getId().equals(updateParam.getId())){
//            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "风险单元编号已被使用");
//        }
        if (ObjectUtils.isEmpty(updateParam.getRiskName())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险单元名字不能为空");
        }
        BasicRiskUnit riskUnitByName = riskUnitRepository.getRiskUnitByName(updateParam.getRiskName());
//        if (!ObjectUtils.isEmpty(riskUnitByName) && !riskUnitByName.getId().equals(updateParam.getId())){
//            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "风险单元名称已被使用");
//        }
        //校验，如果类型是1或者2，则风险源id不可为空
        if (updateParam.getRiskSourceType() == 1 || updateParam.getRiskSourceType() == 2){
            if (ObjectUtils.isEmpty(updateParam.getRiskSourceId())){
                throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险源不能为空");
            }
            //如果riskType为1-区域
            if (updateParam.getRiskSourceType() == 1){
                SiteQueryDTO siteById = basicExperimentSiteService.getBasicExperimentSiteById(updateParam.getRiskSourceId());
                //设置参数
                updateParam.setRiskSourceId(siteById.getId());
            }
            //如果riskType为2-设备
            if (updateParam.getRiskSourceType() == 2){
                DeviceQueryDTO deviceById = basicExperimentDeviceService.getBasicExperimentDeviceById(updateParam.getRiskSourceId());
                //设置参数
                updateParam.setRiskSourceId(deviceById.getId());
            }
        }else {
            updateParam.setRiskSourceId(null);
        }
        // todo 部门先不做校验
        if (ObjectUtils.isEmpty(updateParam.getLiabilityUserId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "责任人不能为空");
        }
//        if (ObjectUtils.isEmpty(updateParam.getLiabilityDepId())){
//            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "责任部门不能为空");
//        }
        BasicRiskUnit riskUnitById = riskUnitRepository.getRiskUnitById(updateParam.getId());
        if (ObjectUtils.isEmpty(riskUnitById)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "要修改的单元不存在，请确定是否输入正确或该单元已被删除");
        }
        UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
        BasicRiskUnit riskUnit = BeanCopyUtils.copyBean(riskUnitById, BasicRiskUnit.class);
        //设置必要参数
        LocalDateTime date  = LocalDateTime.now();
        riskUnit.setUpdateTime(date);
        riskUnit.setUpdateByUserId(userInfoById.getId());
        riskUnit.setRiskCode(updateParam.getRiskCode());
        riskUnit.setRiskName(updateParam.getRiskName());
        riskUnit.setRiskSourceType(updateParam.getRiskSourceType());
        riskUnit.setRiskSourceId(updateParam.getRiskSourceId());
        riskUnit.setLiabilityUserId(updateParam.getLiabilityUserId());
        if (ObjectUtils.isEmpty(updateParam.getLiabilityDepId())){
            riskUnit.setLiabilityDepId(updateParam.getLiabilityDepId());
        }
        riskUnit.setImage(updateParam.getImage());
        riskUnit.setDescription(updateParam.getDescription());

        BasicRiskUnit updateResult = riskUnitRepository.save(riskUnit);

        return BeanCopyUtils.copyBean(updateResult, RiskUnitUpdateDTO.class);
    }

    /**
     * 基础风险单元管理 - 删除
     */
    @Override
    public RiskUnitBasicDeleteDTO deleteBasicRiskUnit(Long currentUserId, Long id) {

        if (currentUserId < 0){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无效，请重新登陆");
        }
        if (ObjectUtils.isEmpty(id)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请求参数为空");
        }
        BasicRiskUnit riskUnitById = riskUnitRepository.getRiskUnitById(id);
        if (ObjectUtils.isEmpty(riskUnitById)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险单元不存在，请检查是否输入有误或已被删除");
        }
        UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
        BasicRiskUnit riskUnit = BeanCopyUtils.copyBean(riskUnitById, BasicRiskUnit.class);
        //设置必要参数
        LocalDateTime date = LocalDateTime.now();

        riskUnit.setUpdateTime(date);
        riskUnit.setUpdateByUserId(userInfoById.getId());
        riskUnit.setDeleteStatus(StatusEnum.DELETED.getCode().byteValue());

        BasicRiskUnit deleteResult = riskUnitRepository.save(riskUnit);

        return BeanCopyUtils.copyBean(deleteResult, RiskUnitBasicDeleteDTO.class);
    }

    /**
     * 基础风险单元管理 - 列表
     */
    @Override
    public List<RiskUnitListDTO> listBasicRiskUnit(Long currentUserId) {

        UserInfoDomainDTO user = userDomainService.getUserById(currentUserId);
        int roleTag = GetRoleTagUtils.GetRoleTagUtils(user);

        List<BasicRiskUnit> listResult = new ArrayList<>();
        if (SearchAuthUtils.basicSearchAuth() == 0){
            listResult = riskUnitRepository.listRiskUnit();
            return BeanCopyUtils.copyBeanList(listResult, RiskUnitListDTO.class);
        }


        if (roleTag != UserTagEnum.USER_TAG_0.getCode()){
           listResult = riskUnitRepository.listRiskUnit();
        }else {
            listResult = riskUnitRepository.listRiskUnitByUserId(currentUserId);
        }
        return BeanCopyUtils.copyBeanList(listResult, RiskUnitListDTO.class);
    }

    /**
     * 基础风险单元管理 - 通过id查询
     */
    @Override
    public RiskUnitBasicQueryDTO getBasicRiskUnitById(Long id) {
        if (ObjectUtils.isEmpty(id)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请求参数不能为空");
        }

        BasicRiskUnit riskUnitById = riskUnitRepository.getRiskUnitById(id);

        if (ObjectUtils.isEmpty(riskUnitById)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode(), "风险源信息不存在，请检查是否输入有误或已被删除");
        }
        return BeanCopyUtils.copyBean(riskUnitById, RiskUnitBasicQueryDTO.class);
    }

    /**
     * 基础风险单元管理 - 通过id列表查询
     */
    @Override
    public List<RiskUnitBasicQueryDTO> getBasicRiskUnitByIdList(List<Long> ids) {

        if (ids.size() < 1){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode(), "请求参数不能为空");
        }

        List<BasicRiskUnit> listResult = riskUnitRepository.batchById(ids);

        if (listResult.size() < 1){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode(), "查询结果为空");
        }
        return BeanCopyUtils.copyBeanList(listResult, RiskUnitBasicQueryDTO.class);
    }

    @Override
    public RiskUnitUpdateDTO updateRiskUnitStatus(Long riskUnitId, int status) {
        BasicRiskUnit riskUnitById = riskUnitRepository.getRiskUnitById(riskUnitId);
        riskUnitById.setEvaluateStatus((byte) status);
        return BeanCopyUtils.copyBean(riskUnitRepository.save(riskUnitById),RiskUnitUpdateDTO.class);
    }
}