package com.fzzy.igds.service;

import com.fzzy.igds.constant.Constant;
import com.fzzy.igds.constant.RedisConst;
import com.fzzy.igds.repository.InoutConfRepository;
import com.fzzy.igds.repository.InoutSysConfRepository;
import com.fzzy.igds.domain.InoutConf;
import com.fzzy.igds.domain.InoutSysConf;
import com.fzzy.igds.utils.ContextUtil;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.service.ISysDeptService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Date;
import java.util.List;

/**
 * @Description 出入库配置service层，包含流程配置和设备配置
 * @Author CZT
 * @Date 2025/11/28 09:23
 */
@Slf4j
@Service
public class InoutConfService {
    @Resource
    private ISysDeptService iSysDeptService;
    @Resource
    private InoutSysConfRepository inoutSysConfRepository;
    @Resource
    private InoutConfRepository inoutConfRepository;
    @Resource
    private RedisCache redisCache;

    /*--------------- 出入库流程 ---------------*/
    /**
     * JPA-查询流程配置
     *
     * @return
     */
    public List<InoutSysConf> getSysConfData() {

        SysUser user = ContextUtil.getLoginUser();
        SysDept userDept = iSysDeptService.selectDeptById(user.getDeptId());
        if (Constant.DEPT_TYPE_20.equals(userDept.getType())) {
            return inoutSysConfRepository.getDataById(ContextUtil.subDeptId(user));
        }else {
            return inoutSysConfRepository.getDataByParentId(user.getDeptId() + "%");
        }
    }

    /**
     *
     *
     * @param companyId
     * @param deptId
     */
    public void initSysConfData(String companyId, String deptId) {
        InoutSysConf inoutSysConf = new InoutSysConf();
        inoutSysConf.setDeptId(deptId);
        inoutSysConf.setCompanyId(companyId);
        inoutSysConf.setProgressIn("REGISTER-WEIGHT_FULL-HANDLE-WEIGHT_EMPTY-RECORD");
        inoutSysConf.setProgressOut("REGISTER-WEIGHT_EMPTY-HANDLE-WEIGHT_FULL-RECORD");
        this.saveSysConfData(inoutSysConf);

        this.flushInoutSysConfCache(inoutSysConf);
    }

    /**
     *
     * @param deptId
     */
    public void delSysConfData(String deptId) {
        inoutSysConfRepository.deleteById(deptId);
    }

    /**
     * JPA-保存流程配置
     *
     * @param data
     * @return
     */
    public void saveSysConfData(InoutSysConf data) {
        if (StringUtils.isEmpty(data.getCompanyId())) {
            data.setCompanyId(ContextUtil.getCompanyId());
        }
        data.setUpdateBy(ContextUtil.getLoginUserName());
        data.setUpdateTime(new Date());
        inoutSysConfRepository.save(data);
        this.flushInoutSysConfCache(data);
    }

    /**
     * 设置缓存
     *
     * @param data
     */
    public void flushInoutSysConfCache(InoutSysConf data) {
        String key = RedisConst.buildKey(data.getDeptId(), Constant.CACHE_INOUT_SYS_CONF);
        redisCache.setCacheObject(key, data);
    }

    /**
     * 获取缓存信息
     *
     * @param companyId
     * @param deptId
     * @return
     */
    public InoutSysConf getCacheInoutSysConf(String companyId, String deptId) {
        String key = RedisConst.buildKey(deptId, Constant.CACHE_INOUT_SYS_CONF);
        return (InoutSysConf) redisCache.getCacheObject(key);
    }

    /*--------------- 出入库设备 ---------------*/
    /**
     * JPA-查询设备配置
     *
     * @return
     */
    public List<InoutConf> getInoutConfList(String companyId, String deptId) {
        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getCompanyId();
        }
        if (StringUtils.isEmpty(deptId)) {
            deptId = ContextUtil.subDeptId(null);
        }
        return inoutConfRepository.getInoutConfList(companyId, deptId);
    }

    /**
     * JPA-保存设备配置
     * @param data
     * @return
     */
    public String saveData(InoutConf data) {
        if (0 == data.getInOrder()) {
            data.setInOrder(1);
        }
        if (StringUtils.isEmpty(data.getSort())) {
            data.setSort("1");
        }
        if (StringUtils.isEmpty(data.getId())) {
            data.setId(ContextUtil.generateId());
            data.setCreateBy(ContextUtil.getLoginUserName());
            data.setCreateTime(new Date());
        }
        if (StringUtils.isEmpty(data.getCompanyId())) {
            data.setCompanyId(ContextUtil.getCompanyId());
        }
        if (StringUtils.isEmpty(data.getDeptId())) {
            data.setDeptId(ContextUtil.subDeptId(null));
        }
        data.setUpdateBy(ContextUtil.getLoginUserName());
        data.setUpdateTime(new Date());
        inoutConfRepository.save(data);
        return null;
    }

    /**
     * JPA-删除设备配置
     * @param data
     * @return
     */
    public String delData(InoutConf data) {
        inoutConfRepository.delete(data);
        return null;
    }

    /**
     * 设置缓存
     * @param companyId
     * @param deptId
     */
    public void flushInoutConfCache(String companyId, String deptId) {
        List<InoutConf> list = this.getInoutConfList(companyId, deptId);
        String key = RedisConst.buildKey(companyId, Constant.CACHE_INOUT_CONF_LIST, deptId);
        redisCache.setCacheObject(key, list);
    }

    /**
     * 获取缓存
     * @param companyId
     * @param deptId
     * @return
     */
    public List<InoutConf> getCacheInoutConf(String companyId, String deptId) {
        String key = RedisConst.buildKey(companyId, Constant.CACHE_INOUT_CONF_LIST, deptId);
        List<InoutConf> list = redisCache.getCacheObject(key);
        if(null == list){
            list = this.getInoutConfList(companyId, deptId);
            redisCache.setCacheObject(key, list);
        }
        return list;
    }

    /**
     * 获取缓存
     * @param companyId
     * @param deptId
     * @param confId
     * @return
     */
    public InoutConf getCacheInoutConf(String companyId, String deptId, String confId) {
        if (null == companyId || null == deptId || null == confId) {
            return null;
        }

        List<InoutConf> list = getCacheInoutConf(companyId, deptId);
        if (null == list  || list.isEmpty()) {
            return null;
        }
        for (InoutConf inoutConf : list) {
            if (inoutConf.getId().equals(confId)) {
                return inoutConf;
            }
        }
        return null;
    }

    /**
     * 更新出入库设备状态
     * @param ip
     * @param port
     * @param status
     */
    public void updateInoutConfStatus(String ip, Integer port, String status) {
        inoutConfRepository.updateInoutConfStatus(status, ip, port);
    }
}