package com.ruoyi.system.service.impl;

import java.net.Inet6Address;
import java.net.InetAddress;
import java.util.List;
import java.util.Locale;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.ip.IpUtils;
import com.ruoyi.system.domain.TDetectionCabinet;
import com.ruoyi.system.mapper.TDetectionCabinetMapper;
import com.ruoyi.system.service.ITDetectionCabinetService;

/**
 * 检测柜 Service 业务层处理
 *
 * @author ruoyi
 */
@Service
public class TDetectionCabinetServiceImpl implements ITDetectionCabinetService
{
    private static final String NORMAL = "0";
    private static final String DISABLED = "1";
    private static final String TESTING = "1";

    private final TDetectionCabinetMapper detectionCabinetMapper;

    /**
     * 构造检测柜业务服务。
     *
     * @param detectionCabinetMapper 检测柜数据访问对象
     */
    public TDetectionCabinetServiceImpl(TDetectionCabinetMapper detectionCabinetMapper)
    {
        this.detectionCabinetMapper = detectionCabinetMapper;
    }

    /**
     * 查询指定检测柜，并在记录不存在或已逻辑删除时统一抛出业务异常。
     *
     * @param cabinetId 检测柜主键
     * @return 检测柜信息
     */
    @Override
    public TDetectionCabinet selectDetectionCabinetById(Long cabinetId)
    {
        TDetectionCabinet detectionCabinet = detectionCabinetMapper.selectDetectionCabinetById(cabinetId);
        if (StringUtils.isNull(detectionCabinet))
        {
            throw new ServiceException("检测柜不存在或已删除");
        }
        return detectionCabinet;
    }

    /**
     * 查询检测柜列表；查询 MAC 地址时先转换为统一格式，避免分隔符和大小写导致漏查。
     *
     * @param detectionCabinet 查询条件
     * @return 检测柜列表
     */
    @Override
    public List<TDetectionCabinet> selectDetectionCabinetList(TDetectionCabinet detectionCabinet)
    {
        if (StringUtils.isNotBlank(detectionCabinet.getMacAddress()))
        {
            detectionCabinet.setMacAddress(normalizeMacAddress(detectionCabinet.getMacAddress()));
        }
        return detectionCabinetMapper.selectDetectionCabinetList(detectionCabinet);
    }

    /**
     * 新增检测柜，统一基础字段格式并校验 IP、设备编码和 MAC 地址后初始化运行状态。
     *
     * @param detectionCabinet 检测柜信息
     * @return 影响行数
     */
    @Override
    public int insertDetectionCabinet(TDetectionCabinet detectionCabinet)
    {
        normalizeBasicFields(detectionCabinet);
        validateIpAddress(detectionCabinet.getIpAddress());
        validateUniqueFields(detectionCabinet);
        detectionCabinet.setOnlineStatus(NORMAL);
        detectionCabinet.setTestStatus(NORMAL);
        detectionCabinet.setCurrentTest(null);
        detectionCabinet.setStatus(NORMAL);
        detectionCabinet.setDelFlag(NORMAL);
        try
        {
            return detectionCabinetMapper.insertDetectionCabinet(detectionCabinet);
        }
        catch (DuplicateKeyException exception)
        {
            throw buildDuplicateException(detectionCabinet, exception);
        }
    }

    /**
     * 修改检测柜基础信息；先确认目标记录存在，再执行字段规范化和唯一性校验。
     *
     * @param detectionCabinet 检测柜信息
     * @return 影响行数
     */
    @Override
    public int updateDetectionCabinet(TDetectionCabinet detectionCabinet)
    {
        requireCabinetId(detectionCabinet.getCabinetId());
        selectDetectionCabinetById(detectionCabinet.getCabinetId());
        normalizeBasicFields(detectionCabinet);
        validateIpAddress(detectionCabinet.getIpAddress());
        validateUniqueFields(detectionCabinet);
        try
        {
            return detectionCabinetMapper.updateDetectionCabinet(detectionCabinet);
        }
        catch (DuplicateKeyException exception)
        {
            throw buildDuplicateException(detectionCabinet, exception);
        }
    }

    /**
     * 修改检测柜启禁用状态；测试中的检测柜禁止被禁用，重复状态更新直接返回成功。
     *
     * @param detectionCabinet 检测柜主键、目标状态及更新人
     * @return 影响行数
     */
    @Override
    public int updateDetectionCabinetStatus(TDetectionCabinet detectionCabinet)
    {
        requireCabinetId(detectionCabinet.getCabinetId());
        if (!NORMAL.equals(detectionCabinet.getStatus()) && !DISABLED.equals(detectionCabinet.getStatus()))
        {
            throw new ServiceException("检测柜状态值不正确");
        }
        TDetectionCabinet current = selectDetectionCabinetById(detectionCabinet.getCabinetId());
        if (DISABLED.equals(detectionCabinet.getStatus()))
        {
            validateCabinetNotTesting(current, "禁用");
        }
        if (detectionCabinet.getStatus().equals(current.getStatus()))
        {
            return 1;
        }
        return detectionCabinetMapper.updateDetectionCabinetStatus(detectionCabinet);
    }

    /**
     * 批量逻辑删除检测柜；先完成全部目标记录校验，再执行删除，避免部分成功。
     *
     * @param cabinetIds 检测柜主键数组
     * @param updateBy 更新人
     * @return 影响行数
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int deleteDetectionCabinetByIds(Long[] cabinetIds, String updateBy)
    {
        if (StringUtils.isEmpty(cabinetIds))
        {
            throw new ServiceException("请选择要删除的检测柜");
        }
        for (Long cabinetId : cabinetIds)
        {
            TDetectionCabinet detectionCabinet = selectDetectionCabinetById(cabinetId);
            validateCabinetNotTesting(detectionCabinet, "删除");
        }
        int rows = 0;
        for (Long cabinetId : cabinetIds)
        {
            rows += detectionCabinetMapper.deleteDetectionCabinetById(cabinetId, updateBy);
        }
        return rows;
    }

    /**
     * 校验设备编码唯一性，编辑当前记录时允许命中自身。
     *
     * @param detectionCabinet 待校验检测柜
     * @return true 表示唯一
     */
    @Override
    public boolean checkCabinetCodeUnique(TDetectionCabinet detectionCabinet)
    {
        Long cabinetId = StringUtils.isNull(detectionCabinet.getCabinetId()) ? -1L : detectionCabinet.getCabinetId();
        TDetectionCabinet info = detectionCabinetMapper.selectByCabinetCode(detectionCabinet.getCabinetCode());
        if (StringUtils.isNotNull(info) && info.getCabinetId().longValue() != cabinetId.longValue())
        {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 校验 MAC 地址唯一性，调用方应传入规范化后的地址。
     *
     * @param detectionCabinet 待校验检测柜
     * @return true 表示唯一
     */
    @Override
    public boolean checkMacAddressUnique(TDetectionCabinet detectionCabinet)
    {
        Long cabinetId = StringUtils.isNull(detectionCabinet.getCabinetId()) ? -1L : detectionCabinet.getCabinetId();
        TDetectionCabinet info = detectionCabinetMapper.selectByMacAddress(detectionCabinet.getMacAddress());
        if (StringUtils.isNotNull(info) && info.getCabinetId().longValue() != cabinetId.longValue())
        {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    private void validateUniqueFields(TDetectionCabinet detectionCabinet)
    {
        if (!checkCabinetCodeUnique(detectionCabinet))
        {
            throw new ServiceException("设备编码已存在");
        }
        if (!checkMacAddressUnique(detectionCabinet))
        {
            throw new ServiceException("MAC地址已存在");
        }
    }

    private void normalizeBasicFields(TDetectionCabinet detectionCabinet)
    {
        detectionCabinet.setCabinetCode(StringUtils.trim(detectionCabinet.getCabinetCode()));
        detectionCabinet.setCabinetName(StringUtils.trim(detectionCabinet.getCabinetName()));
        detectionCabinet.setIpAddress(StringUtils.trim(detectionCabinet.getIpAddress()));
        detectionCabinet.setMacAddress(normalizeMacAddress(detectionCabinet.getMacAddress()));
        detectionCabinet.setManufacturer(StringUtils.trim(detectionCabinet.getManufacturer()));
        detectionCabinet.setModel(StringUtils.trim(detectionCabinet.getModel()));
        detectionCabinet.setRemark(StringUtils.trim(detectionCabinet.getRemark()));
    }

    private String normalizeMacAddress(String macAddress)
    {
        return StringUtils.trim(macAddress).replace('-', ':').toUpperCase(Locale.ROOT);
    }

    private void validateIpAddress(String ipAddress)
    {
        if (IpUtils.isIP(ipAddress))
        {
            return;
        }
        try
        {
            InetAddress address = InetAddress.getByName(ipAddress);
            if (ipAddress.contains(":") && address instanceof Inet6Address)
            {
                return;
            }
        }
        catch (Exception ignored)
        {
        }
        throw new ServiceException("IP地址格式不正确");
    }

    /**
     * 校验检测柜是否处于可操作状态。
     *
     * @param detectionCabinet 检测柜当前数据
     * @param operation 业务操作名称
     */
    private void validateCabinetNotTesting(TDetectionCabinet detectionCabinet, String operation)
    {
        if (TESTING.equals(detectionCabinet.getTestStatus()))
        {
            throw new ServiceException("检测柜正在测试，不能" + operation);
        }
    }

    private void requireCabinetId(Long cabinetId)
    {
        if (StringUtils.isNull(cabinetId))
        {
            throw new ServiceException("检测柜ID不能为空");
        }
    }

    private ServiceException buildDuplicateException(TDetectionCabinet detectionCabinet, DuplicateKeyException cause)
    {
        String message = checkCabinetCodeUnique(detectionCabinet) ? "MAC地址已存在" : "设备编码已存在";
        return new ServiceException(message).setDetailMessage(cause.getMessage());
    }
}