package com.fzzy.igds.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.fzzy.igds.constant.Constant;
import com.fzzy.igds.constant.RedisConst;
import com.fzzy.igds.domain.GatewaySer;
import com.fzzy.igds.mapper.GatewaySerMapper;
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.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.*;

/**
 * @Description
 * @Author CZT
 * @Date 2025/12/10 16:48
 */
@Slf4j
@Service
public class GatewaySerService {
    @Resource
    private GatewaySerMapper gatewaySerMapper;
    @Resource
    private ISysDeptService iSysDeptService;
    @Resource
    private RedisCache redisCache;

    /**
     * 根据条件查询分机信息
     *
     * @param companyId
     * @param deptId
     * @param parentId
     * @return
     */
    public List<GatewaySer> listDeviceSer(String companyId, String deptId, String parentId) {

        QueryWrapper<GatewaySer> queryWrapper = new QueryWrapper<>();

        if (StringUtils.isNotBlank(companyId)) {
            queryWrapper.eq("company_id", companyId);
        }
        if (StringUtils.isNotBlank(deptId)) {
            queryWrapper.eq("dept_id", deptId);
        }
        if (StringUtils.isNotBlank(parentId)) {
            queryWrapper.likeRight("dept_id", parentId);
        }

        return gatewaySerMapper.selectList(queryWrapper);
    }

    /**
     * 查询分机列表
     *
     * @return
     */
    public List<GatewaySer> getAllSer() {
        SysUser user = ContextUtil.getLoginUser();
        SysDept userDept = iSysDeptService.selectDeptById(user.getDeptId());
        if (Constant.DEPT_TYPE_20.equals(userDept.getType())) {
            return this.listDeviceSer(null, user.getDeptId() + "", null);
        } else {
            return this.listDeviceSer(null, null, user.getDeptId() + "");
        }
    }

    /**
     * 根据条件查询分机信息
     *
     * @param id
     * @return
     */
    public GatewaySer getById(String id) {
        if(StringUtils.isBlank( id)){
            return null;
        }
        return gatewaySerMapper.selectById(id);
    }

    /**
     * 更新保存分机
     *
     * @param ser
     */
    public void saveSer(GatewaySer ser) {
        if (null == ser.getSn()) {
            ser.setSn(ser.getId());
        }
        if(null == ser.getOrderNum()){
            ser.setOrderNum(1);
        }
        if (StringUtils.isEmpty(ser.getCompanyId())) {
            ser.setCompanyId(ContextUtil.getCompanyId());
        }

        //判断接口路径
        if (StringUtils.isEmpty(ser.getPlateNumUrl())) {
            ser.setPlateNumUrl("/open/api/get-plateNum");
        }
        if (StringUtils.isEmpty(ser.getPlayUrl())) {
            ser.setPlayUrl("/open/api/get-media");
        }
        if (StringUtils.isEmpty(ser.getSnapUrl())) {
            ser.setSnapUrl("/open/api/snap-img");
        }
        if (StringUtils.isEmpty(ser.getPtzUrl())) {
            ser.setPtzUrl("/open/api/ptz-media");
        }

        ser.setUpdateBy(ContextUtil.getLoginUserName());
        ser.setUpdateTime(new Date());
        if (StringUtils.isBlank(ser.getCreateBy())) {
            ser.setCreateBy(ContextUtil.getLoginUserName());
            ser.setCreateTime(new Date());
            gatewaySerMapper.insert(ser);
        } else {
            gatewaySerMapper.updateById(ser);
        }

        refreshCache(ser.getCompanyId());
    }

    /**
     * 异步更新网关状态
     * @param ser  信息
     * @param status  状态
     * @param isUpdateTime  是否更新心跳时间
     */
    @Async
    public void updateStatus(GatewaySer ser, String status, boolean isUpdateTime) {

        if(isUpdateTime){
            //心跳时间
            ser.setHeartbeatTime(new Date());
        }

        ser.setUpdateTime(new Date());
        ser.setStatus(status);
        gatewaySerMapper.updateById(ser);

        setCacheSer(ser);
    }

    /**
     * 更新保存分机
     *
     * @param ser
     */
    public void delSer(GatewaySer ser) {
        gatewaySerMapper.deleteById(ser);

        //删除缓存
        delCache(ser);

    }

    /**
     * 根据分机ID获取分机信息
     *
     * @param deptId
     * @return
     */
    public GatewaySer getCacheSerByDeptId(String deptId) {
        if (StringUtils.isEmpty(deptId)) {
            return null;
        }

        String patten = RedisConst.buildKey(ContextUtil.getCompanyId(), RedisConst.KEY_GATEWAY_SER_LIST) + "*";
        Collection<String> keys = redisCache.keys(patten);
        if (null == keys) {
            return null;
        }

        GatewaySer ser = null;
        for (String key : keys) {
            ser = (GatewaySer) redisCache.getCacheObject(key);
            if(deptId.equals(ser.getDeptId())){
                return ser;
            }
        }
        return null;
    }

    /**
     * 根据分机ID获取分机信息
     *
     * @param companyId
     * @param id
     * @return
     */
    public GatewaySer getCacheSerById(String companyId, String id) {
        if (StringUtils.isEmpty(id)) {
            return null;
        }
        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getCompanyId();
        }

        GatewaySer result = null;
        GatewaySer ser = null;
        String patten = RedisConst.buildKey(companyId, RedisConst.KEY_GATEWAY_SER_LIST) + "*";
        Collection<String> keys = redisCache.keys(patten);
        if (null != keys && !keys.isEmpty()) {
            for (String key : keys) {
                ser = (GatewaySer) redisCache.getCacheObject(key);
                if(id.equals(ser.getId())){
                    result = ser;
                    break;
                }
            }
        }

        if(null == result){
            result = getById(id);
            this.setCacheSer(result);
        }

        return result;
    }

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

    /**
     * 设置缓存
     * @param data
     */
    public void setCacheSer(GatewaySer data) {
        if (null == data) {
            return;
        }
        String key = RedisConst.buildKey(data.getCompanyId(), RedisConst.KEY_GATEWAY_SER_LIST, data.getDeptId(), data.getId());
        redisCache.setCacheObject(key, data);
    }

    /**
     * 设置缓存
     * @param data
     */
    public void setCacheSer(List<GatewaySer> data) {
        if (null == data) {
            return;
        }
        for (GatewaySer ser : data) {
            this.setCacheSer( ser);
        }
    }

    /**
     * 删除缓存信息
     * @param ser
     */
    public void delCache(GatewaySer ser) {
        if (null == ser) {
            return;
        }
        String key = RedisConst.buildKey(ser.getCompanyId(), RedisConst.KEY_GATEWAY_SER_LIST, ser.getDeptId(), ser.getId());
        redisCache.deleteObject(key);
    }

}