package com.ruoyi.system.service.enterpriseManage.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.system.domain.req.TechnologyTypeAddReqDTO;
import com.ruoyi.system.domain.req.TechnologyTypeDeleteReqDTO;
import com.ruoyi.system.domain.req.TechnologyTypeSelectByIdReqDTO;
import com.ruoyi.system.domain.req.TechnologyTypeUpdateReqDTO;
import com.ruoyi.system.domain.resp.TechnologyTypeListRespDTO;
import com.ruoyi.system.domain.resp.TechnologyTypeSelectByIdRespDTO;
import com.ruoyi.system.domain.resp.TechnologyTypeSelectByPageRespDTO;
import com.ruoyi.system.entity.EnterpriseManageTechnologyType;
import com.ruoyi.system.entity.TechnologyTypeSelectByPageDO;
import com.ruoyi.system.enums.DeleteStatusEnum;
import com.ruoyi.system.service.baseService.EnterpriseManageTechnologyTypeService;
import com.ruoyi.system.service.enterpriseManage.TechnologyTypeService;
import org.apache.commons.lang3.StringUtils;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Service
public class TechnologyTypeServiceImpl implements TechnologyTypeService {

    @Autowired
    private EnterpriseManageTechnologyTypeService manageTechnologyTypeService;

    @Autowired
    private RedissonClient redissonClient;


    /**
     * @description 新增工艺类型
     */
    @Override
    public AjaxResult saveTechnologyType(LoginUser user,TechnologyTypeAddReqDTO technologyTypeAddReqDTO) {
        String technologyName = technologyTypeAddReqDTO.getTechnologyName();
        if (StringUtils.isBlank(technologyName)){
            return AjaxResult.error("工艺类型不能为空");
        }

        String lockName = "XJ_ENTERPRISE_INFORMATION_TECHNOLOGY_ADD_"+technologyName;
        RLock xjEnterpriseInformationTechnologyAddLock = redissonClient.getLock(lockName);
        xjEnterpriseInformationTechnologyAddLock.lock(3, TimeUnit.SECONDS);

        EnterpriseManageTechnologyType technologyTypeResult = manageTechnologyTypeService.getValidTechnologyTypeByName(technologyName);
        if (technologyTypeResult != null){
            return AjaxResult.error("工艺类型已存在");
        }
        Date date = new Date();
        EnterpriseManageTechnologyType technologyType = new EnterpriseManageTechnologyType();
        technologyType.setTechnologyName(technologyName);
        technologyType.setCreateBy(user.getUsername());
        technologyType.setCreateTime(date);
        technologyType.setUpdateBy(user.getUsername());
        technologyType.setUpdateTime(date);
        technologyType.setIsDelete(DeleteStatusEnum.DELECT_NO.getStatus());
        boolean saveResult = manageTechnologyTypeService.save(technologyType);

        xjEnterpriseInformationTechnologyAddLock.unlock();

        if (saveResult){
            return AjaxResult.success("新增工艺类型成功!");
        }else {
            return AjaxResult.error("新增工艺类型失败!");
        }
    }

    /**
     * @description 删除工艺类型
     */
    @Override
    public AjaxResult deleteTechnologyTypeById(LoginUser user, TechnologyTypeDeleteReqDTO deleteReqDTO) {
        Integer id = deleteReqDTO.getId();
        if (id == null){
            return AjaxResult.error("工艺类型id不能为空");
        }

        String lockName = "XJ_ENTERPRISE_INFORMATION_TECHNOLOGY_DELETE_"+id;
        RLock xjEnterpriseInformationTechnologyDeleteLock = redissonClient.getLock(lockName);
        xjEnterpriseInformationTechnologyDeleteLock.lock(3, TimeUnit.SECONDS);

        EnterpriseManageTechnologyType technologyType = manageTechnologyTypeService.getValidTechnologyTypeById(id);
        if (technologyType == null){
            return AjaxResult.error("工艺类型不存在,删除失败!");
        }
        EnterpriseManageTechnologyType updateTechnologyType = new EnterpriseManageTechnologyType();
        updateTechnologyType.setId(id);
        updateTechnologyType.setUpdateBy(user.getUsername());
        updateTechnologyType.setUpdateTime(new Date());
        updateTechnologyType.setIsDelete(DeleteStatusEnum.DELECT_YES.getStatus());
        boolean updateResult = manageTechnologyTypeService.updateById(updateTechnologyType);

        xjEnterpriseInformationTechnologyDeleteLock.unlock();

        if (updateResult){
            return AjaxResult.success("删除工艺类型成功!");
        }else {
            return AjaxResult.error("删除工艺类型失败!");
        }
    }

    /**
     * @description 修改工艺类型
     */
    @Override
    public AjaxResult updateTechnologyTypeById(LoginUser user, TechnologyTypeUpdateReqDTO updateReqDTO) {
        Integer id = updateReqDTO.getId();
        String technologyName = updateReqDTO.getTechnologyName();
        if (id == null){
            return AjaxResult.error("工艺类型id不能为空");
        }
        if (StringUtils.isBlank(technologyName)){
            return AjaxResult.error("工艺类型名称不能为空");
        }
        EnterpriseManageTechnologyType technologyType = manageTechnologyTypeService.getValidTechnologyTypeById(id);
        if (technologyType == null){
            return AjaxResult.error("工艺类型不存在,修改失败!");
        }

        String lockName = "XJ_ENTERPRISE_INFORMATION_TECHNOLOGY_UPDATE_"+technologyName;
        RLock xjEnterpriseInformationTechnologyUpdateLock = redissonClient.getLock(lockName);
        xjEnterpriseInformationTechnologyUpdateLock.lock(3, TimeUnit.SECONDS);

        EnterpriseManageTechnologyType technologyTypeResult = manageTechnologyTypeService.getValidTechnologyTypeByName(technologyName);
        if (technologyTypeResult != null){
            if (id != technologyTypeResult.getId()){
                return AjaxResult.error("工艺类型已存在");
            }
        }
        EnterpriseManageTechnologyType updateTechnologyType = new EnterpriseManageTechnologyType();
        updateTechnologyType.setId(id);
        updateTechnologyType.setTechnologyName(technologyName);
        updateTechnologyType.setUpdateTime(new Date());
        updateTechnologyType.setUpdateBy(user.getUsername());
        boolean updateResult = manageTechnologyTypeService.updateById(updateTechnologyType);

        xjEnterpriseInformationTechnologyUpdateLock.unlock();

        if (updateResult){
            return AjaxResult.success("修改工艺类型成功!");
        }else {
            return AjaxResult.error("修改工艺类型失败!");
        }
    }

    /**
     * @description 根据id查询
     */
    @Override
    public AjaxResult selectTechnologyTypeById(LoginUser user, TechnologyTypeSelectByIdReqDTO selectByIdReqDTO) {
        Integer id = selectByIdReqDTO.getId();
        if (id == null){
            return AjaxResult.error("工艺类型id不能为空");
        }
        EnterpriseManageTechnologyType technologyType = manageTechnologyTypeService.getValidTechnologyTypeById(id);
        TechnologyTypeSelectByIdRespDTO repsDTO = new TechnologyTypeSelectByIdRespDTO();
        if (technologyType == null){
            return AjaxResult.success(technologyType);
        }else {
            BeanUtils.copyProperties(technologyType,repsDTO);
            return AjaxResult.success(repsDTO);
        }
    }

    /**
     * @description 分页查询
     */
    @Override
    public AjaxResult selectTechnologyTypeByPage(LoginUser user, Page pageInfo) {
        IPage technologyTypeByPage = manageTechnologyTypeService.selectTechnologyTypeByPage(pageInfo);
        List<TechnologyTypeSelectByPageDO> records = technologyTypeByPage.getRecords();
        if (CollectionUtils.isEmpty(records)){
            return AjaxResult.success(technologyTypeByPage);
        }else {
            List<TechnologyTypeSelectByPageRespDTO> dtos =  records.stream().map((record)->{
                 TechnologyTypeSelectByPageRespDTO dto = new TechnologyTypeSelectByPageRespDTO();
                 BeanUtils.copyProperties(record,dto);
                 return dto;
             }).collect(Collectors.toList());
            technologyTypeByPage.setRecords(dtos);
            return AjaxResult.success(technologyTypeByPage);
        }
    }

    /**
     * @description 查询所有的工艺类型
     */
    @Override
    public AjaxResult selectTechnologyTypeList(LoginUser user) {
        List<EnterpriseManageTechnologyType> technologyTypeListS =  manageTechnologyTypeService.selectTechnologyTypeList();
        if (CollectionUtils.isEmpty(technologyTypeListS)){
            return AjaxResult.success(technologyTypeListS);
        }else {
            List<TechnologyTypeListRespDTO> dtos = technologyTypeListS.stream().map((technologyTypeList)->{
                TechnologyTypeListRespDTO dto = new TechnologyTypeListRespDTO();
                BeanUtils.copyProperties(technologyTypeList,dto);
                return dto;
            }).collect(Collectors.toList());
            return AjaxResult.success(dtos);
        }
    }
}