package com.mes.device.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.device.entity.DeviceConfig;
import com.mes.device.entity.DeviceStatus;
import com.mes.device.mapper.DeviceConfigMapper;
import com.mes.device.mapper.DeviceStatusMapper;
import com.mes.device.service.DeviceConfigService;
import com.mes.device.service.DeviceStatusService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 设备状态服务实现类
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class DeviceStatusServiceImpl extends ServiceImpl<DeviceStatusMapper, DeviceStatus> 
        implements DeviceStatusService {

    private final DeviceConfigService deviceConfigService;
    private final DeviceConfigMapper deviceConfigMapper;

    @Override
    public DeviceStatus getLatestByDeviceId(String deviceId) {
        if (deviceId == null || deviceId.trim().isEmpty()) {
            return null;
        }
        try {
            return baseMapper.getLatestByDeviceId(deviceId.trim());
        } catch (Exception e) {
            log.error("获取设备状态失败, deviceId={}", deviceId, e);
            return null;
        }
    }

    @Override
    public List<DeviceStatus> getLatestByDeviceIds(List<String> deviceIds) {
        if (deviceIds == null || deviceIds.isEmpty()) {
            return new ArrayList<>();
        }
        try {
            List<String> validIds = deviceIds.stream()
                    .filter(id -> id != null && !id.trim().isEmpty())
                    .map(String::trim)
                    .distinct()
                    .collect(Collectors.toList());
            if (validIds.isEmpty()) {
                return new ArrayList<>();
            }
            return baseMapper.getLatestByDeviceIds(validIds);
        } catch (Exception e) {
            log.error("批量获取设备状态失败, deviceIds={}", deviceIds, e);
            return new ArrayList<>();
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateDeviceOnlineStatus(Long deviceId, String status) {
        if (deviceId == null) {
            log.warn("设备ID不能为空");
            return false;
        }
        if (status == null || status.trim().isEmpty()) {
            log.warn("设备状态不能为空");
            return false;
        }

        try {
            // 获取设备配置
            DeviceConfig device = deviceConfigService.getDeviceById(deviceId);
            if (device == null) {
                log.warn("设备不存在: deviceId={}", deviceId);
                return false;
            }

            String deviceIdStr = device.getDeviceId();
            if (deviceIdStr == null || deviceIdStr.trim().isEmpty()) {
                log.warn("设备配置中device_id字段为空: id={}", deviceId);
                return false;
            }

            // 检查是否已有状态记录
            DeviceStatus existing = getLatestByDeviceId(deviceIdStr);
            Date now = new Date();

            if (existing != null) {
                // 更新现有记录
                existing.setStatus(status);
                existing.setLastHeartbeat(now);
                boolean result = updateById(existing);
                if (result) {
                    log.info("更新设备在线状态成功: deviceId={}, status={}", deviceId, status);
                }
                return result;
            } else {
                // 创建新记录
                DeviceStatus newStatus = new DeviceStatus();
                newStatus.setDeviceId(deviceIdStr);
                newStatus.setStatus(status);
                newStatus.setLastHeartbeat(now);
                newStatus.setCreatedTime(now);
                boolean result = save(newStatus);
                if (result) {
                    log.info("创建设备状态记录成功: deviceId={}, status={}", deviceId, status);
                }
                return result;
            }
        } catch (Exception e) {
            log.error("更新设备在线状态失败: deviceId={}, status={}", deviceId, status, e);
            return false;
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean batchUpdateDeviceOnlineStatus(List<Long> deviceIds, String status) {
        if (deviceIds == null || deviceIds.isEmpty()) {
            log.warn("设备ID列表不能为空");
            return false;
        }
        if (status == null || status.trim().isEmpty()) {
            log.warn("设备状态不能为空");
            return false;
        }

        try {
            boolean allSuccess = true;
            for (Long deviceId : deviceIds) {
                if (!updateDeviceOnlineStatus(deviceId, status)) {
                    allSuccess = false;
                }
            }
            log.info("批量更新设备在线状态完成: deviceIds={}, status={}, success={}", 
                    deviceIds.size(), status, allSuccess);
            return allSuccess;
        } catch (Exception e) {
            log.error("批量更新设备在线状态失败: deviceIds={}, status={}", deviceIds, status, e);
            return false;
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean recordHeartbeat(String deviceId, String status) {
        if (deviceId == null || deviceId.trim().isEmpty()) {
            return false;
        }
        if (status == null || status.trim().isEmpty()) {
            status = DeviceStatus.Status.ONLINE; // 默认在线
        }

        try {
            Date now = new Date();
            DeviceStatus existing = getLatestByDeviceId(deviceId);
            
            if (existing != null) {
                existing.setStatus(status);
                existing.setLastHeartbeat(now);
                return updateById(existing);
            } else {
                DeviceStatus newStatus = new DeviceStatus();
                newStatus.setDeviceId(deviceId);
                newStatus.setStatus(status);
                newStatus.setLastHeartbeat(now);
                newStatus.setCreatedTime(now);
                return save(newStatus);
            }
        } catch (Exception e) {
            log.error("记录设备心跳失败: deviceId={}, status={}", deviceId, status, e);
            return false;
        }
    }

    @Override
    public DeviceStatus getLatestByDeviceConfigId(Long deviceConfigId) {
        if (deviceConfigId == null) {
            return null;
        }
        try {
            DeviceConfig device = deviceConfigService.getDeviceById(deviceConfigId);
            if (device == null || device.getDeviceId() == null) {
                return null;
            }
            return getLatestByDeviceId(device.getDeviceId());
        } catch (Exception e) {
            log.error("根据设备配置ID获取设备状态失败: deviceConfigId={}", deviceConfigId, e);
            return null;
        }
    }
}