package com.fzzy.igds.service;

import com.fzzy.igds.constant.Constant;
import com.fzzy.igds.constant.RedisConst;
import com.fzzy.igds.domain.DeviceSer;
import com.fzzy.igds.repository.DeviceSerRepository;
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.*;

/**
 * @Description
 * @Author CZT
 * @Date 2025/11/28 13:48
 */
@Slf4j
@Service
public class DeviceSerService {
    @Resource
    private ISysDeptService iSysDeptService;
    @Resource
    private DeviceSerRepository deviceSerRepository;
    @Resource
    private RedisCache redisCache;

    /**
     * JPA 查询分机列表
     *
     * @return
     */
    public List<DeviceSer> getAllSerByCompanyId(String companyId) {
        return deviceSerRepository.getAllSerByCompanyId(companyId);
    }

    /**
     * JPA 查询分机列表
     *
     * @return
     */
    public List<DeviceSer> getAllSer() {
        SysUser user = ContextUtil.getLoginUser();
        SysDept userDept = iSysDeptService.selectDeptById(user.getDeptId());
        if (Constant.DEPT_TYPE_20.equals(userDept.getType())) {
            return deviceSerRepository.getDataByDeptId(user.getDeptId() + "");
        }else {
            return deviceSerRepository.getDataByParentId(user.getDeptId() + "%");
        }
    }

    /**
     * JPA 查询分机
     *
     * @param companyId
     * @param id
     * @return
     */
    public DeviceSer getDataById(String companyId, String id) {

        if (StringUtils.isEmpty(id)) {
            return null;
        }
        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getCompanyId();
        }
        return deviceSerRepository.getDataById(companyId, id);
    }

    /**
     * JPA 更新保存分机
     *
     * @param ser
     */
    public void saveSer(DeviceSer ser) {
        if (null == ser.getNetworkType()) {
            ser.setNetworkType(Constant.NETWORK_01);
        }
        if (null == ser.getSn()) {
            ser.setSn(ser.getId());
        }
        if (StringUtils.isEmpty(ser.getCompanyId())) {
            ser.setCompanyId(ContextUtil.getCompanyId());
            ser.setCreateBy(ContextUtil.getLoginUserName());
            ser.setCreateTime(new Date());
        }

        ser.setUpdateBy(ContextUtil.getLoginUserName());
        ser.setUpdateTime(new Date());
        deviceSerRepository.save(ser);
        refreshCache(ser.getCompanyId());
    }

    /**
     * JPA 更新保存分机
     *
     * @param ser
     */
    public void delSer(DeviceSer ser) {
        deviceSerRepository.delete(ser);

        //删除缓存
        delCache(ser.getCompanyId(), ser.getId());

    }

    /**
     * 更新分机信息
     * @param status
     * @param ip
     * @param port
     */
    public void updateStatusByIp(String status, String ip, Integer port) {
        String companyId = ContextUtil.getCompanyId();
        DeviceSer ser = this.getCacheSerByIp(companyId, ip);

        ser.setStatus(status);
        ser.setIp(ip);
        ser.setPort(port);
        ser.setUpdateTime(new Date());

        deviceSerRepository.save(ser);
        setCacheSer(ser);
    }

    /**
     * 更新分机信息
     * @param data
     */
    public void updateByData(DeviceSer data) {
        if (null == data) {
            return;
        }
        DeviceSer ser = this.getCacheSer(data.getCompanyId(), data.getId());
        if (null == ser) {
            return;
        }
        ser.setStatus(Constant.YN_Y);
        ser.setIp(data.getIp());
        ser.setPort(data.getPort());
        ser.setUpdateTime(new Date());
        ser.setSn(data.getSn());
        deviceSerRepository.save(ser);

        setCacheSer(ser);
    }

    /**
     * 更新分机信息
     * @param companyId
     * @param serId
     * @param controlModel
     */
    public void updateControlModel(String companyId, String serId, String controlModel) {

        DeviceSer ser = this.getCacheSer(companyId, serId);
        if (null == ser) {
            return;
        }

        ser.setStatus(Constant.YN_Y);
        ser.setControlModel(controlModel);
        ser.setUpdateTime(new Date());
        deviceSerRepository.save(ser);

        setCacheSer(ser);
    }

    /**
     * 刷新缓存
     *
     * @param companyId
     */
    public void refreshCache(String companyId) {
        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getCompanyId();
        }
        List<DeviceSer> list = this.getAllSerByCompanyId(companyId);
        this.setCacheSer(list, companyId);
    }

    /**
     * 设置单个分机缓存
     *
     * @param ser
     */
    public void setCacheSer(DeviceSer ser) {
        if (null == ser) {
            return;
        }
        ContextUtil.addSerCompany(ser.getSn(), ser.getCompanyId());
        String key = RedisConst.buildKey(ser.getCompanyId(), RedisConst.KEY_DEVICE_SER_LIST, ser.getId());
        redisCache.setCacheObject(key, ser);
    }

    /**
     * 设置缓存
     *
     * @param data
     * @param companyId
     */
    public void setCacheSer(List<DeviceSer> data, String companyId) {
        if (null == data) {
            return;
        }
        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getCompanyId();
        }
        String key;
        for (DeviceSer ser : data) {
            ContextUtil.addSerCompany(ser.getSn(), ser.getCompanyId());
            key = RedisConst.buildKey(companyId, RedisConst.KEY_DEVICE_SER_LIST, ser.getId());
            redisCache.setCacheObject(key, ser);
        }
    }

    /**
     * 删除缓存信息
     *
     * @param companyId
     * @param serId
     */
    public void delCache(String companyId, String serId) {
        if (StringUtils.isEmpty(serId)) {
            return;
        }
        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getCompanyId();
        }
        String key = RedisConst.buildKey(companyId, RedisConst.KEY_DEVICE_SER_LIST, serId);
        redisCache.deleteObject(key);
    }

    /**
     * 根据组织编码获取分机列表
     *
     * @param companyId
     * @return
     */
    public List<DeviceSer> getCacheSerList(String companyId) {

        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getCompanyId();
        }
        String pattern = RedisConst.buildKey(companyId, RedisConst.KEY_DEVICE_SER_LIST) + "*";
        Collection<String> keys = redisCache.keys(pattern);

        List<DeviceSer> result = new ArrayList<>();
        if (null == keys) {
            return result;
        }
        for (String key : keys) {
            result.add((DeviceSer) redisCache.getCacheObject(key));
        }
        if (result.size() < 1) {
            result = getAllSer();
        }
        if (result.size() < 1) {
            return null;
        }
        //重新排序
        Collections.sort(result, (p1, p2) -> p1.getOrderNum() - p2.getOrderNum());
        return result;
    }

    /**
     * 根据类型获取分机信息
     * @param companyId
     * @param type
     * @return
     */
    public List<DeviceSer> getSerCacheByType(String companyId, String type) {
        List<DeviceSer> listAll = this.getCacheSerList(companyId);
        if (null == listAll || listAll.isEmpty()){
            return null;
        }
        if (null == type){
            return listAll;
        }
        List<DeviceSer> result = new ArrayList<DeviceSer>();
        for (DeviceSer ser : listAll) {
            if (ser.getType().equals(type))
                result.add(ser);
        }
        return result;
    }

    /**
     * 根据分机ID获取分机信息
     *
     * @param companyId
     * @param serId
     * @return
     */
    public DeviceSer getCacheSer(String companyId, String serId) {
        if (StringUtils.isEmpty(serId)) {
            return null;
        }
        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getCompanyId();
        }
        String key = RedisConst.buildKey(companyId, RedisConst.KEY_DEVICE_SER_LIST, serId);

        DeviceSer ser = (DeviceSer) redisCache.getCacheObject(key);

        if (null == ser) {
            ser = getDataById(companyId, serId);
            if (null == ser) {
                log.error("---------缓存中没有获取到分机缓存----------");
                return null;
            }
            redisCache.setCacheObject(key, ser);
        }
        return ser;
    }

    /**
     * 根据分机IP获取分机信息
     *
     * @param companyId
     * @param ip
     * @return
     */
    public DeviceSer getCacheSerByIp(String companyId, String ip) {
        if (StringUtils.isEmpty(companyId)) {
            return null;
        }
        List<DeviceSer> serList = getCacheSerList(companyId);
        if (null == serList) {
            return null;
        }
        for (DeviceSer deviceSer : serList) {
            if (deviceSer.getIp().equals(ip)) {
                return deviceSer;
            }
        }
        return null;
    }

    /**
     * 根据分机IP和端口获取分机信息
     *
     * @param companyId
     * @param ip
     * @param port
     * @return
     */
    public DeviceSer getCacheSerByIp(String companyId, String ip, Integer port) {
        if (StringUtils.isEmpty(companyId)) {
            return null;
        }
        List<DeviceSer> serList = getCacheSerList(companyId);
        if (null == serList) {
            return null;
        }
        for (DeviceSer deviceSer : serList) {
            if (deviceSer.getIp().equals(ip) && deviceSer.getPort() == port) {
                return deviceSer;
            }
        }
        return null;
    }

    /**
     * 根据分机SN获取分机信息
     *
     * @param companyId
     * @param sn
     * @return
     */
    public DeviceSer getCacheSerBySn(String companyId, String sn) {

        if (StringUtils.isEmpty(companyId)) {
            return null;
        }
        List<DeviceSer> serList = getCacheSerList(companyId);
        if (null == serList) {
            return null;
        }
        for (DeviceSer deviceSer : serList) {
            if (deviceSer.getSn().equals(sn)) {
                return deviceSer;
            }
        }
        return null;
    }

    /**
     * JPA-更新设备全部离线
     * @param companyId
     */
    public void allOffLine(String companyId) {
        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getCompanyId();
        }
        deviceSerRepository.updateSerStatus(companyId, Constant.YN_N);
    }

    /**
     * JPA-根据SN更新状态
     * @param ip
     * @param port
     * @param sn
     * @param status
     */
    public void onlineBySn(String ip, Integer port, String sn, String status) {
        deviceSerRepository.updateBySn(ip, port, status, sn, new Date());
    }

}