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

import com.gkhy.labRiskManage.application.basic.dto.bo.BasicExperimentSiteAppInsertBO;
import com.gkhy.labRiskManage.application.basic.dto.bo.BasicExperimentSiteAppQueryBO;
import com.gkhy.labRiskManage.application.basic.dto.bo.BasicExperimentSiteAppUpdateBO;
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.UserTagEnum;
import com.gkhy.labRiskManage.commons.exception.BusinessException;
import com.gkhy.labRiskManage.commons.utils.BeanCopyUtils;
import com.gkhy.labRiskManage.domain.account.model.dto.UserInfoDomainDTO;
import com.gkhy.labRiskManage.domain.account.service.UserDomainService;
import com.gkhy.labRiskManage.domain.basic.entity.BasicExperimentSite;
import com.gkhy.labRiskManage.domain.basic.entity.BasicExperimentSiteType;
import com.gkhy.labRiskManage.domain.basic.model.dto.*;
import com.gkhy.labRiskManage.domain.basic.repository.jpa.BasicExperimentSiteRepository;
import com.gkhy.labRiskManage.domain.basic.service.BasicExperimentPersonService;
import com.gkhy.labRiskManage.domain.basic.service.BasicExperimentSiteService;
import com.gkhy.labRiskManage.domain.basic.service.BasicExperimentSiteTypeService;
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 BasicExperimentSiteServiceImpl implements BasicExperimentSiteService {

    @Autowired
    private BasicExperimentSiteRepository siteRepository;
    @Autowired
    private UserDomainService userDomainService;
    @Autowired
    private BasicExperimentSiteTypeService siteTypeService;
    @Autowired
    private BasicExperimentPersonService basicPersonService;

    /**
     * 基础场所管理 - 新增
     * */
    @Override
    public BasicExperimentSite insertBasicExperimentSite(Long currentUserId, BasicExperimentSiteAppInsertBO insertParam) {

        if (currentUserId < 0){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无效，请重新登陆");
        }
        //校验参数
        if(ObjectUtils.isEmpty(insertParam.getSiteName())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所名称不能为空");
        }
        if(ObjectUtils.isEmpty(insertParam.getFloor())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所楼层不能为空");
        }
        if(ObjectUtils.isEmpty(insertParam.getRoom())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所房间号不能为空");
        }
        BasicExperimentSite siteByFloorAndRoom = siteRepository.getSiteByFloorAndRoom(insertParam.getSiteName(), insertParam.getRoom());
//        if (!ObjectUtils.isEmpty(siteByFloorAndRoom)){
//            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "该区域已被使用，请检查输入是否正确，或需要改变该区域用处");
//        }

        if(ObjectUtils.isEmpty(insertParam.getPartitionStatus())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请填写该场所是否有隔断情况");
        }
        if(ObjectUtils.isEmpty(insertParam.getFireFacilities())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请填写该场所是否有消防设施");
        }

        if(ObjectUtils.isEmpty(insertParam.getSiteLiabilityPersonId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所负责人不能为空");
        }
        PersonQueryDTO siteLiabilityPerson = basicPersonService.getBasicExperimentPersonById(insertParam.getSiteLiabilityPersonId());
        if(ObjectUtils.isEmpty(siteLiabilityPerson)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所负责人不存在");
        }

        if(ObjectUtils.isEmpty(insertParam.getSafeLiabilityPersonId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所安全员不能为空");
        }
        PersonQueryDTO safeLiabilityPerson = basicPersonService.getBasicExperimentPersonById(insertParam.getSafeLiabilityPersonId());
        if(ObjectUtils.isEmpty(safeLiabilityPerson)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所安全员不存在");
        }

        if(ObjectUtils.isEmpty(insertParam.getSiteTypeId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所类型不能为空");
        }
        BasicExperimentSiteType siteTypeById = siteTypeService.getSiteTypeById(insertParam.getSiteTypeId());
        if(ObjectUtils.isEmpty(siteTypeById)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所类型不存在，请添加后使用");
        }

        UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
        BasicExperimentSite site = BeanCopyUtils.copyBean(insertParam, BasicExperimentSite.class);
        //获取必要参数
        LocalDateTime date = LocalDateTime.now();
        site.setCreateTime(date);
        site.setCreateByUserId(userInfoById.getId());
        site.setUpdateTime(date);
        site.setUpdateByUserId(userInfoById.getId());
        site.setDeleteStatus(StatusEnum.DELETE_NOT.getCode().byteValue());
        site.setSiteLiabilityPerson(siteLiabilityPerson.getPersonName());
        site.setSafeLiabilityPerson(safeLiabilityPerson.getPersonName());
        site.setSiteType(siteTypeById.getSiteType());

        BasicExperimentSite save = siteRepository.save(site);

        return save;
    }

    /**
     * 基础场所管理 - 分页查询
     * */
    @Override
    public SearchResult<SiteQueryDTO> selectBasicExperimentSitePage(Long currentUserId, BasicExperimentSiteAppQueryBO 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.getSiteName() == ""){
            queryParam.setSiteName(null);
        }
        if (queryParam.getRoom()  == ""){
            queryParam.setRoom(null);
        }
        if (queryParam.getFloor()  == ""){
            queryParam.setFloor(null);
        }

        SearchResult searchResult = new SearchResult<>();
        searchResult.setPageIndex(queryParam.getPageIndex());
        searchResult.setPageSize(queryParam.getPageSize());

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

        //封装查询参数
        Specification<BasicExperimentSite> specification = new Specification<BasicExperimentSite>() {
            @Override
            public Predicate toPredicate(Root<BasicExperimentSite> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
                List<Predicate> predicateList = new ArrayList<>();
                if (queryParam.getSiteName() != null && !queryParam.getSiteName().equals("")){
                    predicateList.add(criteriaBuilder.like(root.get("siteName"),"%"+queryParam.getSiteName()+"%"));
                }
                if (queryParam.getFloor() != null && !queryParam.getFloor().equals("")){
                    predicateList.add(criteriaBuilder.equal(root.get("floor"), queryParam.getFloor()));
                }
                if (queryParam.getRoom() != null && !queryParam.getRoom().equals("")){
                    predicateList.add(criteriaBuilder.equal(root.get("room"), queryParam.getRoom()));
                }
                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<BasicExperimentSite> pageResult = siteRepository.findAll(specification, pageParam);

        List<SiteQueryDTO> siteQueryDTOS = BeanCopyUtils.copyBeanList(pageResult.getContent(), SiteQueryDTO.class);

        List<UserInfoDomainDTO> userList = userDomainService.getUserList();
        for (SiteQueryDTO siteQueryDTO : siteQueryDTOS) {
            for (UserInfoDomainDTO userInfo : userList) {
                if (userInfo.getId() == siteQueryDTO.getCreateByUserId()){
                    siteQueryDTO.setCreateByUserName(userInfo.getRealName());
                }
                if (userInfo.getId() == siteQueryDTO.getUpdateByUserId()){
                    siteQueryDTO.setUpdateByUserName(userInfo.getRealName());
                }
            }
        }

        searchResult.setData(siteQueryDTOS);
        searchResult.setTotal(pageResult.getTotalElements());

        return searchResult;
    }

    /**
     * 基础场所管理 - 修改
     * */
    @Override
    public SiteUpdateDTO updateBasicExperimentSite(Long currentUserId, BasicExperimentSiteAppUpdateBO updateParam) {

        if (currentUserId < 0){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无效，请重新登陆");
        }
        //校验参数
        if(ObjectUtils.isEmpty(updateParam.getId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请选择正确的场所进行修改，或确认该场所是否已被删除");
        }
        if(ObjectUtils.isEmpty(updateParam.getSiteName())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所名称不能为空");
        }
        if(ObjectUtils.isEmpty(updateParam.getFloor())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所楼层不能为空");
        }
        if(ObjectUtils.isEmpty(updateParam.getRoom())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所房间号不能为空");
        }
        BasicExperimentSite siteByFloorAndRoom = siteRepository.getSiteByFloorAndRoom(updateParam.getSiteName(), updateParam.getRoom());
//        if (!ObjectUtils.isEmpty(siteByFloorAndRoom) && !updateParam.getId().equals(siteByFloorAndRoom.getId())){
//            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "该区域已被使用，请检查输入是否正确");
//        }

        if(ObjectUtils.isEmpty(updateParam.getPartitionStatus())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请填写该场所是否有隔断情况");
        }
        if(ObjectUtils.isEmpty(updateParam.getFireFacilities())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请填写该场所是否有消防设施");
        }

        if(ObjectUtils.isEmpty(updateParam.getSiteLiabilityPersonId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所负责人不能为空");
        }
        PersonQueryDTO siteLiabilityPerson = basicPersonService.getBasicExperimentPersonById(updateParam.getSiteLiabilityPersonId());
        if(ObjectUtils.isEmpty(siteLiabilityPerson)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所负责人不存在");
        }

        if(ObjectUtils.isEmpty(updateParam.getSafeLiabilityPersonId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所安全员不能为空");
        }
        PersonQueryDTO safeLiabilityPerson = basicPersonService.getBasicExperimentPersonById(updateParam.getSafeLiabilityPersonId());
        if(ObjectUtils.isEmpty(safeLiabilityPerson)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所安全员不存在");
        }

        if(ObjectUtils.isEmpty(updateParam.getSiteTypeId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所类型不能为空");
        }
        BasicExperimentSiteType siteTypeById = siteTypeService.getSiteTypeById(updateParam.getSiteTypeId());
        if(ObjectUtils.isEmpty(siteTypeById)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "场所类型不存在，请添加后使用");
        }

        UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
        BasicExperimentSite siteById = siteRepository.getSiteById(updateParam.getId());
        BasicExperimentSite site = BeanCopyUtils.copyBean(siteById, BasicExperimentSite.class);

        //获取必要参数
        LocalDateTime date  = LocalDateTime.now();
        site.setUpdateTime(date);
        site.setUpdateByUserId(userInfoById.getId());

        site.setSiteName(updateParam.getSiteName());
        site.setFloor(updateParam.getFloor());
        site.setRoom(updateParam.getRoom());
        site.setSiteLiabilityPersonId(updateParam.getSiteLiabilityPersonId());
        site.setSiteLiabilityPerson(siteLiabilityPerson.getPersonName());
        site.setSafeLiabilityPersonId(updateParam.getSafeLiabilityPersonId());
        site.setSafeLiabilityPerson(safeLiabilityPerson.getPersonName());
        site.setFireFacilities(updateParam.getFireFacilities());
        site.setPartitionStatus(updateParam.getPartitionStatus());
        site.setSiteTypeId(updateParam.getSiteTypeId());
        site.setSiteType(siteTypeById.getSiteType());

        BasicExperimentSite updateResult = siteRepository.save(site);

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

    /**
     * 基础场所管理 - 删除
     * */
    @Override
    public SiteDeleteDTO deleteBasicExperimentSite(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(), "请选择正常的内容删除");
        }
        BasicExperimentSite siteById = siteRepository.getSiteById(id);
        if (ObjectUtils.isEmpty(siteById)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请选择正确的内容删除，或确认该实验室是否已经被删除");
        }

        BasicExperimentSite site = BeanCopyUtils.copyBean(siteById, BasicExperimentSite.class);
        UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);

        LocalDateTime date = LocalDateTime.now();
        //设置参数
        site.setId(id);
        site.setUpdateTime(date);
        site.setUpdateByUserId(userInfoById.getId());
        site.setDeleteStatus(StatusEnum.DELETED.getCode().byteValue());

        BasicExperimentSite deleteResult  = siteRepository.save(site);
        return BeanCopyUtils.copyBean(deleteResult, SiteDeleteDTO.class);
    }

    /**
     * 基础场所管理 - 列表
     * */
    @Override
    public List<SiteListDTO> listBasicExperimentSite(Long currentUserId) {

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

        List<BasicExperimentSite> basicExperimentSites = new ArrayList<>();
        if (SearchAuthUtils.basicSearchAuth() == 0){
            basicExperimentSites = siteRepository.listSite();
            return BeanCopyUtils.copyBeanList(basicExperimentSites, SiteListDTO.class);
        }

        if (roleTag != UserTagEnum.USER_TAG_0.getCode()){
            basicExperimentSites = siteRepository.listSite();
        }else {
            basicExperimentSites = siteRepository.listSiteByUserId(currentUserId);
        }
        return BeanCopyUtils.copyBeanList(basicExperimentSites, SiteListDTO.class);
    }

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

        BasicExperimentSite siteById = siteRepository.getSiteById(id);

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

    /**
     * 基础场所管理 - 通过id列表查询
     * */
    @Override
    public List<SiteQueryDTO> getBasicExperimentSiteByIdList(List<Long> ids) {
        if (ids.size() < 1){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode(), "请求参数不能为空");
        }

        List<BasicExperimentSite> listResult = siteRepository.batchById(ids);
        if (listResult.size() < 1){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode(), "查询结果为空");
        }

        return BeanCopyUtils.copyBeanList(listResult,SiteQueryDTO.class);
    }
}