package com.fzzy.igds.sys;

import com.fzzy.igds.dzhwk.constant.*;
import com.fzzy.igds.dzhwk.constant.RedisConst;
import com.fzzy.igds.dzhwk.domain.Depot;
import com.fzzy.igds.dzhwk.domain.DepotStore;
import com.fzzy.igds.sys.repository.DepotRepository;
import com.fzzy.igds.util.ContextUtil;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.mapper.SysDeptMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.*;

/**
 * @Description
 * @Author CZT
 * @Date 2024/11/22 16:56
 */
@Slf4j
@Service("sys.depotService")
public class DepotService {

    @Resource
    private DepotRepository depotRepository;
    @Resource
    private RedisCache redisCache;
    @Resource
    private SysDeptMapper deptMapper;
    @Resource
    private DepotStoreService depotStoreService;


    /**
     * jpa查询仓库列表
     * @param companyId
     * @param deptId
     * @return
     */
    public List<Depot> getData(String companyId, String deptId) {

        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getCompanyId();
        }
        if (StringUtils.isEmpty(deptId)) {
            deptId = ContextUtil.subDeptId(null);
        }
        return depotRepository.getDepot(companyId, deptId);
    }

    /**
     * jpa查询仓库列表
     * @param ids
     * @return
     */
    public List<Depot> getDepotByIds(List<String> ids) {
        if (null == ids ||ids.isEmpty()) {
            return null;
        }
        return depotRepository.getDepotByIds(ids);
    }

    /**
     * jpa保存更新仓库信息
     * @param depot
     */
    public void saveDepot(Depot depot) {
        if (StringUtils.isEmpty(depot.getCompanyId())) {
            depot.setCompanyId(ContextUtil.getCompanyId());
        }
        if (StringUtils.isEmpty(depot.getDeptId())) {
            depot.setDeptId(ContextUtil.subDeptId(null));
        }
        if(null == depot.getOrderNum()){
            depot.setOrderNum(1);
        }
        depotRepository.save(depot);
        flushCache(depot.getCompanyId());
    }

    /**
     * jpa更新仓库状态
     * @param depotId
     * @param status
     */
    public void updateDepotStatus(String depotId, String status) {
        if (StringUtils.isEmpty(depotId)) {
            return;
        }
        depotRepository.updateDepotStatus(status, depotId);
    }

    /**
     * jpa删除仓库货位信息
     * @param depot
     */
    public void deleteDepot(Depot depot) {
        depotRepository.delete(depot);

        //删除配置缓存
        this.delCacheDepot(depot, depot.getCompanyId());
    }

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

        List<Depot> list = depotRepository.getDepotByCompanyId(companyId);

        this.setCacheDepotList(list, companyId);
    }

    /**
     * 设置缓存
     * @param list
     * @param companyId
     */
    public void setCacheDepotList(List<Depot> list, String companyId) {
        if (null == list) return;
        String key;
        for (Depot depot : list) {
            key = RedisConst.buildKey(companyId, RedisConst.KEY_DEPOT, depot.getId());
            redisCache.setCacheObject(key, depot);
        }
    }

    /**
     * 删除缓存信息
     * @param depot
     * @param companyId
     */
    public void delCacheDepot(Depot depot, String companyId) {
        if (null == depot) {
            return;
        }
        if(StringUtils.isEmpty(companyId)){
            companyId = ContextUtil.getCompanyId();
        }
        String key = RedisConst.buildKey(companyId, RedisConst.KEY_DEPOT, depot.getId());
        redisCache.deleteObject(key);
    }

    /**
     * 获取缓存-根据组织编码获取仓库集合
     * @param companyId
     * @return
     */
    public List<Depot> getCacheDepotList(String companyId) {
        if(StringUtils.isEmpty(companyId)){
            companyId = ContextUtil.getCompanyId();
        }
        String patten = RedisConst.buildKey(companyId, RedisConst.KEY_DEPOT) + "*";

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

        List<Depot> list = new ArrayList<>();
        for (String key : keys) {
            list.add((Depot) redisCache.getCacheObject(key));
        }
        //缓存获取为空，则查询数据库
        if(list.size() < 1){
            list = depotRepository.getDepotByCompanyId(companyId);
            setCacheDepotList(list, companyId);
        }

        //重新排序
        Collections.sort(list, (p1, p2) -> p1.getOrderNum() - p2.getOrderNum());
        return list;
    }

    /**
     * 获取缓存-根据组织编码和库区编码获取仓库集合
     * @param companyId
     * @param deptId
     * @return
     */
    public List<Depot> getCacheDepotList(String companyId, String deptId) {
        if (StringUtils.isEmpty(deptId)) {
            return null;
        }
        List<Depot> list = getCacheDepotList(companyId);
        if(null == list || list.isEmpty()){
            return null;
        }
        List<Depot> result = new ArrayList<>();
        for (Depot depot : list) {
            if (deptId.equals(depot.getDeptId())) {
                result.add(depot);
            }
        }
        //重新排序
        Collections.sort(result, (p1, p2) -> p1.getOrderNum() - p2.getOrderNum());
        return result;
    }

    /**
     * 获取仓库信息-根据仓库编码获取缓存信息
     * @param companyId
     * @param depotId
     * @return
     */
    public Depot getCacheDepot(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, depotId);
        Depot depot = redisCache.getCacheObject(key);
        if(null == depot){
            depot = depotRepository.getDepotById(companyId, depotId);
            redisCache.setCacheObject(key, depot);
        }
        return depot;
    }

    /**
     * 根据当前仓库编号信息获取与当前仓库相同建筑物的所有仓库集合
     * @param companyId
     * @param depotId
     * @return
     */
    public List<Depot> getCacheCommonBuildingDepot(String companyId, String depotId) {
        //若仓库未配置仓房编码，则直接返回对应仓库
        Depot depot = getCacheDepot(companyId, depotId);

        if (StringUtils.isEmpty(depot.getBuildingId())) {
            List<Depot> list = new ArrayList<>();
            list.add(depot);
            return list;
        }

        List<Depot> list = getCacheDepotList(companyId);
        if (null == list) {
            return null;
        }
        String buildingId = null;
        Map<String, List<Depot>> mapList = new HashMap<>();// 定义一个以建筑物ID为KEY的MAP集合对象

        for (Depot item : list) {
            if (item.getId().equals(depotId)) {
                buildingId = item.getBuildingId();
            }
            if (null == mapList.get(item.getBuildingId())) {
                mapList.put(item.getBuildingId(), new ArrayList<>());
            }
            mapList.get(item.getBuildingId()).add(item);
        }
        return mapList.get(buildingId);
    }

    /**
     * 根据库存信息更新仓库信息
     * @param data
     */
    public void updateByStore(DepotStore data) {

        Depot depot = this.getCacheDepot(data.getCompanyId(), data.getDepotId());
        if (null == depot) {
            return;
        }

        depot.setStorageReal(data.getStorageReal());
        depot.setDepotStatus(data.getDepotStatus());
        depot.setFoodLevel(data.getFoodLevel());
        depot.setFoodLocation(data.getFoodLocation());
        depot.setFoodVariety(data.getFoodVariety());
        depot.setFoodType(data.getFoodType());
        depot.setFoodYear(data.getFoodYear());
        if (null != data.getStoreDate()) {
            depot.setStoreDate(data.getStoreDate());
        }

        this.saveDepot(depot);
    }

    /**
     * 初始化控制柜仓库的虚拟用户
     * @param companyId
     */
    public void initUserDeptMap(String companyId) {
        List<Depot> list = this.getCacheDepotList(companyId);
        if (null == list || list.isEmpty()) return;
        for (Depot depot : list) {
            ContextUtil.updateSubDept(depot.getId(), depot.getDeptId());
        }
    }

}