package com.hr.service.impl;

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.hr.param.InterfaceConfigParam;
import com.hr.param.IpInterfaceParam;
import com.hr.param.SwitchStatusParam;
import com.hr.repository.domain.IpInterfacePO;
import com.hr.repository.jpa.IpInterfaceRepository;
import com.hr.service.IpInterfaceService;
import com.hr.util.SnowflakeIdWorker;
import com.hr.vo.IpAccountVO;
import com.hr.vo.IpInterfaceVO;
import com.hr.vo.NameValueVO;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.*;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * 接口表;(ip_interface)表服务接口实现类
 * @author : http://www.yonsum.com
 * @date : 2025-10-10
 */
@Service
public class IpInterfaceServiceImpl implements IpInterfaceService {
    @Autowired
    private IpInterfaceRepository ipInterfaceRepository;

    private static final Cache<String, IpInterfaceVO> QUERY_CACHE = CacheBuilder.newBuilder()
            .expireAfterWrite(100, TimeUnit.SECONDS)
            .build();
    
    /** 
     * 通过ID查询单条数据 
     *
     * @param id 主键
     * @return 实例对象
     */
    public IpInterfaceVO queryById(Long id){
//        IpInterfacePO ipInterfacePO = ipInterfaceRepository.findById(id).get();
        Optional<IpInterfacePO> optional = ipInterfaceRepository.findById(id);
        if(optional.isPresent()) {
            IpInterfacePO ipInterfacePO=optional.get();
            IpInterfaceVO ipInterfaceVO = new IpInterfaceVO();
            if (ipInterfacePO != null) {
                BeanUtils.copyProperties(ipInterfacePO, ipInterfaceVO);
                return ipInterfaceVO;
            }
        }
        return null;
    }

     @Override
     public Page<IpInterfaceVO> paginQuery(IpInterfaceParam interfaceParam, Integer current, Integer size) {
         IpInterfacePO ipInterfacePO = new IpInterfacePO();
         BeanUtils.copyProperties(interfaceParam, ipInterfacePO);
         ExampleMatcher matcher = ExampleMatcher.matchingAll()
                 .withIgnoreNullValues()                              // 忽略 null 字段
                 .withIgnoreCase();
         Pageable pageAble = PageRequest.of(current - 1 , size);
         Example<IpInterfacePO> example = Example.of(ipInterfacePO, matcher);
         Page<IpInterfacePO> page = ipInterfaceRepository.findAll(example, pageAble);
         List<IpInterfaceVO> resultList = new ArrayList<>();

         page.getContent().forEach(item -> {
             IpInterfaceVO vo = new IpInterfaceVO();
             BeanUtils.copyProperties(item, vo);
             resultList.add(vo);
         });
         Page<IpInterfaceVO> resultPage = new PageImpl(resultList);
         BeanUtils.copyProperties(page, resultPage);
         return resultPage;
     }

     /**
     * 新增数据
     *
     * @param IpInterfacePO 实例对象
     * @return 实例对象
     */
    public void insert(IpInterfacePO IpInterfacePO){
        ipInterfaceRepository.save(IpInterfacePO);
    }
    
    /** 
     * 更新数据
     * @param IpInterfacePO 实例对象
     * @return 实例对象
     */
    public void  update(IpInterfacePO IpInterfacePO){
        ipInterfaceRepository.save(IpInterfacePO);
    }

    @Override
    public IpInterfaceVO queryByInterfaceCode(String interfaceCode) {
        String key = "queryByInterfaceCode";
        IpInterfaceVO vo = QUERY_CACHE.getIfPresent(key);
        if(vo != null){
            return vo;
        }else{
            vo = new IpInterfaceVO();
            IpInterfacePO interfaceNo = ipInterfaceRepository.findByInterfaceNo(interfaceCode);
            BeanUtils.copyProperties(interfaceNo,vo);
            QUERY_CACHE.put(key, vo);
        }
        return vo;
    }

    @Override
    public void interfaceConfig(InterfaceConfigParam param) {

    }

    @Override
    public List<NameValueVO> optionList() {
        List<IpInterfacePO> list = ipInterfaceRepository.findAll();
        List<IpInterfacePO> resultList = list.stream().filter(item -> item.getStatus().equals("normal")).collect(Collectors.toList());
        List<NameValueVO> result = new ArrayList<>();
        resultList.forEach(item -> {
            NameValueVO vo = new NameValueVO();
            vo.setName(item.getInterfaceName());
            vo.setId(item.getId());
            result.add(vo);
        });
        return result;
    }

    @Override
    public Boolean switchStatus(SwitchStatusParam switchStatusParam) {
        Optional<IpInterfacePO> optional = ipInterfaceRepository.findById(switchStatusParam.getId());
        if(!optional.isPresent()){
            throw new RuntimeException("接口不存在");
        }
        IpInterfacePO ipInterfacePO = optional.get();

        ipInterfacePO.setStatus(switchStatusParam.getStatus());
        ipInterfaceRepository.save(ipInterfacePO);
        return true;
    }

    @Override
    public void saveOrUpdate(IpInterfaceParam ipInterfaceParam, String username, Long userid) {
        IpInterfacePO ipInterfacePO ;
        if(ipInterfaceParam.getId() == null){
            ipInterfacePO = ipInterfaceRepository.findByInterfaceName(ipInterfaceParam.getInterfaceName());
            if(ipInterfacePO != null){
                throw new RuntimeException("接口名称已存在");
            }
            ipInterfacePO = ipInterfaceRepository.findByInterfaceNo(ipInterfaceParam.getInterfaceNo());
            if(ipInterfacePO != null){
                throw new RuntimeException("接口编号已存在");
            }
            ipInterfacePO = new IpInterfacePO();
        }else{
            ipInterfacePO = ipInterfaceRepository.findByInterfaceName(ipInterfaceParam.getInterfaceName());
            if(ipInterfaceParam != null && ipInterfacePO.getInterfaceName().equals(ipInterfaceParam.getInterfaceName()) && !ipInterfacePO.getId().equals(ipInterfaceParam.getId())){
                throw new RuntimeException("接口名称已存在");
            }
            ipInterfacePO = ipInterfaceRepository.findByInterfaceNo(ipInterfaceParam.getInterfaceNo());
            if(ipInterfaceParam != null && ipInterfacePO.getInterfaceNo().equals(ipInterfaceParam.getInterfaceNo()) && !ipInterfacePO.getId().equals(ipInterfaceParam.getId())){
                throw new RuntimeException("接口编号已存在");
            }
        }

        com.yy.basedevelop.common.BeanUtils.copyPropertiesIgnoreNullAndEmptyStr(ipInterfaceParam, ipInterfacePO);
        if(ipInterfaceParam.getId() == null){
            ipInterfacePO.setId(SnowflakeIdWorker.nextId());
            ipInterfacePO.setAddTime(LocalDateTime.now());
            ipInterfacePO.setAddUserId(userid);
            ipInterfacePO.setAddUserName(username);
        }
        ipInterfacePO.setUpdateTime(LocalDateTime.now());
        ipInterfacePO.setUpdateUserId(userid);
        ipInterfacePO.setUpdateUserName(username);
        ipInterfaceRepository.save(ipInterfacePO);
    }

    /**
     * 通过主键删除数据
     *
     * @param iid 主键
     * @return 是否成功
     */
    public boolean deleteById(Long iid){
        ipInterfaceRepository.deleteById(iid);
        return true;
    }
}