package com.fzzy.igds.sys;

import com.fzzy.igds.dzhwk.constant.RedisConst;
import com.fzzy.igds.dzhwk.domain.Depot;
import com.fzzy.igds.dzhwk.domain.DepotConf;
import com.fzzy.igds.sys.repository.DepotConfRepository;
import com.fzzy.igds.util.ContextUtil;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.utils.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description
 * @Author CZT
 * @Date 2024/11/25 14:56
 */
@Slf4j
@Service("sys.depotConfService")
public class DepotConfService {

    @Resource
    private DepotConfRepository depotConfRepository;
    @Resource
    private DepotService depotService;
    @Resource
    private RedisCache redisCache;

    /**
     * jpa查询配置信息
     *
     * @param companyId
     * @param deptId
     * @return
     */
    public List<DepotConf> getConfList(String companyId, String deptId) {

        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getCompanyId();
        }
        if (StringUtils.isEmpty(deptId)) {
            deptId = ContextUtil.subDeptId(null);
        }
        //查询配置信息
        List<DepotConf> list = depotConfRepository.getDepotConf(companyId, deptId);
        //配置信息为空，则自动生成
        if(null == list || list.isEmpty()){
            addConfByDepot(companyId);
        }
        return depotConfRepository.getDepotConf(companyId, deptId);
    }

    /**
     * jpa更新保存配置信息
     *
     * @param conf
     */
    public void saveConf(DepotConf conf) {
        if (StringUtils.isEmpty(conf.getCompanyId())) {
            conf.setCompanyId(ContextUtil.getCompanyId());
        }
        if (StringUtils.isEmpty(conf.getDeptId())) {
            conf.setDeptId(ContextUtil.subDeptId(null));
        }
        depotConfRepository.save(conf);
        flushConfCache(conf.getCompanyId());
    }

    /**
     * jpa删除配置信息
     *
     * @param conf
     * @return
     */
    public void deleteDepotConf(DepotConf conf) {
        depotConfRepository.delete(conf);

        //删除配置缓存
        this.delCacheDepotConf(conf, conf.getCompanyId());
    }

    /**
     * 设置缓存信息
     *
     * @param list
     * @param companyId
     */
    public void setCacheDepotConf(List<DepotConf> list, String companyId) {
        if (null != list) {
            Depot depot;
            String key;
            for (DepotConf depotConf : list) {
                depot = depotService.getCacheDepot(companyId, depotConf.getDepotId());
                if (null != depot) {
                    depotConf.setDepotName(depot.getName());
                    depotConf.setDepotType(depot.getDepotType());
                }
                key = RedisConst.buildKey(companyId, RedisConst.KEY_DEPOT_CONF, depotConf.getDepotId());
                redisCache.setCacheObject(key, depotConf);
            }
        }
    }

    /**
     * 删除缓存信息
     *
     * @param depotConf
     * @param companyId
     */
    public void delCacheDepotConf(DepotConf depotConf, String companyId) {
        if (null == depotConf) {
            return;
        }
        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getCompanyId();
        }
        String key = RedisConst.buildKey(companyId, RedisConst.KEY_DEPOT_CONF, depotConf.getDepotId());
        redisCache.deleteObject(key);
    }

    /**
     * 获取缓存-根据组织编码获取配置信息集合
     *
     * @param companyId
     * @return
     */
    public List<DepotConf> getCacheDepotConfList(String companyId) {
        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getCompanyId();
        }
        String patten = RedisConst.buildKey(companyId, RedisConst.KEY_DEPOT_CONF) + "*";

        Collection<String> keys = redisCache.keys(patten);
        if (null == keys || keys.isEmpty()) {
            return null;
        }

        List<DepotConf> result = new ArrayList<>();
        for (String key : keys) {
            result.add((DepotConf) redisCache.getCacheObject(key));
        }

        return result;
    }

    /**
     * 获取缓存-根据组织编码和粮情分机ID获取配置信息集合
     *
     * @param companyId
     * @param serId
     * @return
     */
    public List<DepotConf> getCacheDepotConfList(String companyId, String serId) {
        List<DepotConf> list = getCacheDepotConfList(companyId);

        if (null == list || list.isEmpty()) {
            return null;
        }
        return list.stream()
                .filter(item -> null != item.getGrainSer() && item.getGrainSer().equals(serId))
                .collect(Collectors.toList());
    }

    /**
     * 获取缓存-根据组织编码和粮情分机ID获取配置信息
     *
     * @param companyId
     * @param serId
     * @return
     */
    public DepotConf getCacheDepotConfBySerId(String companyId, String serId) {
        List<DepotConf> data = getCacheDepotConfList(companyId);
        if (null == data) {
            return null;
        }

        return data.stream().filter(item -> (serId.equals(item.getGrainSer()) || serId.equals(item.getGasSer()) || serId.equals(item.getEsSer())))
                .findAny().orElse(null);
    }

    /**
     * 获取缓存-根据组织编码和仓库编码获取配置信息
     *
     * @param companyId
     * @param depotId
     * @return
     */
    public DepotConf getCacheDepotConfByDepotId(String companyId, String depotId) {
        if (StringUtils.isEmpty(depotId)) {
            return null;
        }
        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getCompanyId();
        }
        String key = RedisConst.buildKey(companyId, RedisConst.KEY_DEPOT_CONF, depotId);
        DepotConf depotConf = redisCache.getCacheObject(key);
        if (null == depotConf) {
            depotConf = depotConfRepository.getDepotConfByDepotId(companyId, depotId);
            redisCache.setCacheObject(key, depotConf);
        }

        return depotConf;
    }

    /**
     * 根据仓库列表，自动生成仓库配置信息
     * @param companyId
     */
    private void addConfByDepot(String companyId) {
        List<Depot> list = depotService.getCacheDepotList(companyId);
        if (null == list || list.isEmpty()) {
            return;
        }
        DepotConf conf;
        for (Depot depot : list) {
            conf = new DepotConf();
            conf.setDepotId(depot.getId());
            conf.setCompanyId(depot.getCompanyId());
            conf.setDeptId(depot.getDeptId());
            this.saveConf(conf);
        }
    }

    /**
     * 刷新仓库配置缓存
     * @param companyId
     */
    public void flushConfCache(String companyId) {
        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getCompanyId();
        }

        List<DepotConf> list = depotConfRepository.getDepotConfByCompanyId(companyId);

        this.setCacheDepotConf(list, companyId);
    }

    /**
     * 更新粮情保存频率
     * @param freq
     */
    public void updateFreq(String freq) {
        depotConfRepository.updateGrainFreq(ContextUtil.getCompanyId(), ContextUtil.subDeptId(null), freq);
    }
}