package com.fzzy.igds.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.fzzy.igds.constant.Constant;
import com.fzzy.igds.constant.RedisConst;
import com.fzzy.igds.domain.DeviceSer;
import com.fzzy.igds.mapper.DeviceSerMapper;
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 DeviceSerMapper deviceSerMapper;
    @Resource
    private RedisCache redisCache;

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

        QueryWrapper<DeviceSer> 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 deviceSerMapper.selectList(queryWrapper);
    }

    /**
     * 查询分机列表
     *
     * @return
     */
    public List<DeviceSer> 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 companyId
     * @param id
     * @return
     */
    public DeviceSer getDataById(String companyId, String id) {

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

        QueryWrapper<DeviceSer> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("company_id", companyId);
        queryWrapper.eq("id", id);

        return deviceSerMapper.selectOne(queryWrapper);
    }

    /**
     * 更新保存分机
     *
     * @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());
        }
        if (StringUtils.isEmpty(ser.getDeptId())) {
            ser.setDeptId(ContextUtil.subDeptId(null));
        }
        if (StringUtils.isBlank(ser.getUpdateBy())) {
            ser.setCreateBy(ContextUtil.getLoginUserName());
            ser.setCreateTime(new Date());
            ser.setUpdateBy(ContextUtil.getLoginUserName());
            ser.setUpdateTime(new Date());
            deviceSerMapper.insert(ser);
        } else {
            ser.setUpdateBy(ContextUtil.getLoginUserName());
            ser.setUpdateTime(new Date());
            deviceSerMapper.updateById(ser);
        }

        refreshCache(ser.getCompanyId());
    }

    /**
     * 更新保存分机
     *
     * @param ser
     */
    public void delSer(DeviceSer ser) {
        deviceSerMapper.deleteById(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());

        deviceSerMapper.updateById(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());
        deviceSerMapper.updateById(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());
        deviceSerMapper.updateById(ser);

        setCacheSer(ser);
    }

    /**
     * 刷新缓存
     *
     * @param companyId
     */
    public void refreshCache(String companyId) {
        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getCompanyId();
        }
        List<DeviceSer> list = this.listDeviceSer(companyId, null, null);
        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;
    }

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

        UpdateWrapper<DeviceSer> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("company_id", companyId).set("status", Constant.YN_N);
        deviceSerMapper.update(null, updateWrapper);
    }

    /**
     * -根据SN更新状态
     *
     * @param ip
     * @param port
     * @param sn
     * @param status
     */
    public void onlineBySn(String ip, Integer port, String sn, String status) {

        UpdateWrapper<DeviceSer> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("sn", sn).set("ip", ip).set("port", port).set("update_time", new Date());
        deviceSerMapper.update(null, updateWrapper);
    }

}