package cn.iocoder.yudao.module.iot.service.device.property;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.LocalDateTimeUtil;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.common.util.json.JsonUtils;
import cn.iocoder.yudao.framework.common.util.object.ObjectUtils;
import cn.iocoder.yudao.module.iot.controller.admin.device.vo.property.IotDevicePropertyHistoryListReqVO;
import cn.iocoder.yudao.module.iot.controller.admin.device.vo.property.IotDevicePropertyRespVO;
import cn.iocoder.yudao.module.iot.core.mq.message.IotDeviceMessage;
import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceDO;
import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDevicePropertyDO;
import cn.iocoder.yudao.module.iot.dal.dataobject.product.IotProductDO;
import cn.iocoder.yudao.module.iot.dal.dataobject.thingmodel.IotThingModelDO;
import cn.iocoder.yudao.module.iot.dal.dataobject.thingmodel.model.dataType.ThingModelDateOrTextDataSpecs;
import cn.iocoder.yudao.module.iot.dal.redis.device.DevicePropertyRedisDAO;
import cn.iocoder.yudao.module.iot.dal.redis.device.DeviceReportTimeRedisDAO;
import cn.iocoder.yudao.module.iot.dal.redis.device.DeviceServerIdRedisDAO;
import cn.iocoder.yudao.module.iot.dal.tdengine.IotDevicePropertyMapper;
import cn.iocoder.yudao.module.iot.enums.thingmodel.IotDataSpecsDataTypeEnum;
import cn.iocoder.yudao.module.iot.enums.thingmodel.IotThingModelTypeEnum;
import cn.iocoder.yudao.module.iot.framework.tdengine.core.TDengineTableField;
import cn.iocoder.yudao.module.iot.service.device.IotDeviceService;
import cn.iocoder.yudao.module.iot.service.product.IotProductService;
import cn.iocoder.yudao.module.iot.service.thingmodel.IotThingModelService;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Lazy;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.*;

import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.*;
import static cn.iocoder.yudao.framework.common.util.collection.MapUtils.getBigDecimal;

/**
 * IoT 设备【属性】数据 Service 实现类
 *
 * @author 芋道源码
 */
@Service
@Slf4j
public class IotDevicePropertyServiceImpl implements IotDevicePropertyService {

    /**
     * 物模型的数据类型，与 TDengine 数据类型的映射关系
     *
     * @see <a href="https://docs.taosdata.com/reference/taos-sql/data-type/">TDEngine 数据类型</a>
     */
    private static final Map<String, String> TYPE_MAPPING = MapUtil.<String, String>builder()
            .put(IotDataSpecsDataTypeEnum.INT.getDataType(), TDengineTableField.TYPE_INT)
            .put(IotDataSpecsDataTypeEnum.FLOAT.getDataType(), TDengineTableField.TYPE_FLOAT)
            .put(IotDataSpecsDataTypeEnum.DOUBLE.getDataType(), TDengineTableField.TYPE_DOUBLE)
            .put(IotDataSpecsDataTypeEnum.ENUM.getDataType(), TDengineTableField.TYPE_TINYINT)
            .put(IotDataSpecsDataTypeEnum.BOOL.getDataType(), TDengineTableField.TYPE_TINYINT)
            .put(IotDataSpecsDataTypeEnum.TEXT.getDataType(), TDengineTableField.TYPE_VARCHAR)
            .put(IotDataSpecsDataTypeEnum.DATE.getDataType(), TDengineTableField.TYPE_TIMESTAMP)
            .put(IotDataSpecsDataTypeEnum.STRUCT.getDataType(), TDengineTableField.TYPE_VARCHAR)
            .put(IotDataSpecsDataTypeEnum.ARRAY.getDataType(), TDengineTableField.TYPE_VARCHAR)
            .build();

    @Resource
    private IotThingModelService thingModelService;
    @Resource
    @Lazy  // 延迟加载，解决循环依赖
    private IotProductService productService;
    @Resource
    @Lazy  // 延迟加载，解决循环依赖
    private IotDeviceService deviceService;

    @Resource
    private DevicePropertyRedisDAO deviceDataRedisDAO;
    @Resource
    private DeviceReportTimeRedisDAO deviceReportTimeRedisDAO;
    @Resource
    private DeviceServerIdRedisDAO deviceServerIdRedisDAO;

    @Resource
    private IotDevicePropertyMapper devicePropertyMapper;

    // ========== 设备属性相关操作 ==========

    @Override
    public void defineDevicePropertyData(Long productId) {
        // 1.1 查询产品和物模型
        IotProductDO product = productService.validateProductExists(productId);
        List<IotThingModelDO> thingModels = filterList(thingModelService.getThingModelListByProductId(productId),
                thingModel -> IotThingModelTypeEnum.PROPERTY.getType().equals(thingModel.getType()));
        // 1.2 解析 DB 里的字段
        List<TDengineTableField> oldFields = new ArrayList<>();
        try {
            oldFields.addAll(devicePropertyMapper.getProductPropertySTableFieldList(product.getId()));
        } catch (Exception e) {
            if (!e.getMessage().contains("Table does not exist")) {
                throw e;
            }
        }

        // 2.1 情况一：如果是新增的时候，需要创建表
        List<TDengineTableField> newFields = buildTableFieldList(thingModels);
        if (CollUtil.isEmpty(oldFields)) {
            if (CollUtil.isEmpty(newFields)) {
                log.info("[defineDevicePropertyData][productId({}) 没有需要定义的属性]", productId);
                return;
            }
            devicePropertyMapper.createProductPropertySTable(product.getId(), newFields);
            return;
        }
        // 2.2 情况二：如果是修改的时候，需要更新表
        devicePropertyMapper.alterProductPropertySTable(product.getId(), oldFields, newFields);
    }

    private List<TDengineTableField> buildTableFieldList(List<IotThingModelDO> thingModels) {
        return convertList(thingModels, thingModel -> {
            TDengineTableField field = new TDengineTableField(
                    StrUtil.toUnderlineCase(thingModel.getIdentifier()), // TDengine 字段默认都是小写
                    TYPE_MAPPING.get(thingModel.getProperty().getDataType()));
            String dataType = thingModel.getProperty().getDataType();
            if (Objects.equals(dataType, IotDataSpecsDataTypeEnum.TEXT.getDataType())) {
                field.setLength(((ThingModelDateOrTextDataSpecs) thingModel.getProperty().getDataSpecs()).getLength());
            } else if (ObjectUtils.equalsAny(dataType, IotDataSpecsDataTypeEnum.STRUCT.getDataType(),
                    IotDataSpecsDataTypeEnum.ARRAY.getDataType())) {
                field.setLength(TDengineTableField.LENGTH_VARCHAR);
            }
            return field;
        });
    }

    @Override
    @SuppressWarnings("PatternVariableCanBeUsed")
    public void saveDeviceProperty(IotDeviceDO device, IotDeviceMessage message) {
        if (!(message.getParams() instanceof Map)) {
            log.error("[saveDeviceProperty][消息内容({}) 的 data 类型不正确]", message);
            return;
        }
        Map<?, ?> params = (Map<?, ?>) message.getParams();
        if (CollUtil.isEmpty(params)) {
            log.error("[saveDeviceProperty][消息内容({}) 的 data 为空]", message);
            return;
        }

        // 1. 根据物模型，拼接合法的属性
        // TODO @芋艿：【待定 004】赋能后，属性到底以 thingModel 为准（ik），还是 db 的表结构为准（tl）？
        List<IotThingModelDO> thingModels = thingModelService.getThingModelListByProductIdFromCache(device.getProductId());
        Map<String, Object> properties = new HashMap<>();
        params.forEach((key, value) -> {
            // 忽略大小写匹配物模型，避免设备上报的 key 与 identifier 大小写不一致导致丢失
            IotThingModelDO thingModel = CollUtil.findOne(thingModels,
                    o -> StrUtil.equalsIgnoreCase(o.getIdentifier(), (CharSequence) key));
            if (thingModel == null || thingModel.getProperty() == null) {
                log.error("[saveDeviceProperty][消息({}) 的属性({}) 不存在]", message, key);
                return;
            }
            String identifier = thingModel.getIdentifier(); // 统一以物模型 identifier 作为 key，避免大小写问题
            String dataType = thingModel.getProperty().getDataType();
            if (ObjectUtils.equalsAny(dataType,
                    IotDataSpecsDataTypeEnum.STRUCT.getDataType(), IotDataSpecsDataTypeEnum.ARRAY.getDataType())) {
                // 特殊：STRUCT 和 ARRAY 类型，在 TDengine 里，有没对应数据类型，只能通过 JSON 来存储
                properties.put(identifier, JsonUtils.toJsonString(value));
            } else if (IotDataSpecsDataTypeEnum.INT.getDataType().equals(dataType)) {
                properties.put(identifier, Convert.toInt(value));
            } else if (IotDataSpecsDataTypeEnum.FLOAT.getDataType().equals(dataType)) {
                properties.put(identifier, Convert.toFloat(value));
            } else if (IotDataSpecsDataTypeEnum.DOUBLE.getDataType().equals(dataType)) {
                properties.put(identifier, Convert.toDouble(value));
            } else if (IotDataSpecsDataTypeEnum.BOOL.getDataType().equals(dataType)) {
                properties.put(identifier, Convert.toBool(value, false) ? (byte) 1 : (byte) 0);
            } else {
                properties.put(identifier, value);
            }
        });
        if (CollUtil.isEmpty(properties)) {
            log.error("[saveDeviceProperty][消息({}) 没有合法的属性]", message);
        } else {
            // 2.1 保存设备属性【数据】
            devicePropertyMapper.insert(device, properties,
                    System.currentTimeMillis(),
                    LocalDateTimeUtil.toEpochMilli(message.getReportTime()));

            // 2.2 保存设备属性【日志】
            Map<String, IotDevicePropertyDO> properties2 = convertMap(properties.entrySet(), Map.Entry::getKey, entry ->
                    IotDevicePropertyDO.builder().value(entry.getValue()).updateTime(message.getReportTime()).build());
            deviceDataRedisDAO.putAll(device.getId(), properties2);
        }

        // 2.3 提取 GeoLocation 并更新设备定位
        // 为什么 properties 为空，也要执行定位更新？因为可能上报的属性里，没有合法属性，但是包含 GeoLocation 定位属性
        extractAndUpdateDeviceLocation(device, (Map<?, ?>) message.getParams());
    }

    @Override
    public Map<String, IotDevicePropertyDO> getLatestDeviceProperties(Long deviceId) {
        return deviceDataRedisDAO.get(deviceId);
    }

    @Override
    public List<IotDevicePropertyRespVO> getHistoryDevicePropertyList(IotDevicePropertyHistoryListReqVO listReqVO) {
        try {
            return devicePropertyMapper.selectListByHistory(listReqVO);
        } catch (Exception exception) {
            if (exception.getMessage().contains("Table does not exist")) {
                return Collections.emptyList();
            }
            throw exception;
        }
    }

    // ========== 设备时间相关操作 ==========

    @Override
    public Set<Long> getDeviceIdListByReportTime(LocalDateTime maxReportTime) {
        return deviceReportTimeRedisDAO.range(maxReportTime);
    }

    @Override
    @Async
    public void updateDeviceReportTimeAsync(Long id, LocalDateTime reportTime) {
        deviceReportTimeRedisDAO.update(id, reportTime);
    }

    @Override
    public void updateDeviceServerIdAsync(Long id, String serverId) {
        if (StrUtil.isEmpty(serverId)) {
            return;
        }
        deviceServerIdRedisDAO.update(id, serverId);
    }

    @Override
    public String getDeviceServerId(Long id) {
        return deviceServerIdRedisDAO.get(id);
    }

    // ========== 设备定位相关操作 ==========

    /**
     * 从属性中提取 GeoLocation 并更新设备定位
     *
     * @see <a href="https://help.aliyun.com/zh/iot/user-guide/device-geolocation">阿里云规范</a>
     * GeoLocation 结构体包含：Longitude, Latitude, Altitude, CoordinateSystem
     */
    private void extractAndUpdateDeviceLocation(IotDeviceDO device, Map<?, ?> params) {
        // 1. 解析 GeoLocation 经纬度坐标
        BigDecimal[] location = parseGeoLocation(params);
        if (location == null) {
            return;
        }

        // 2. 更新设备定位
        deviceService.updateDeviceLocation(device, location[0], location[1]);
        log.info("[extractAndUpdateGeoLocation][设备({}) 定位更新: lng={}, lat={}]",
                device.getId(), location[0], location[1]);
    }

    /**
     * 从属性参数中解析 GeoLocation，返回经纬度坐标数组 [longitude, latitude]
     *
     * @param params 属性参数
     * @return [经度, 纬度]，解析失败返回 null
     */
    @SuppressWarnings("unchecked")
    private BigDecimal[] parseGeoLocation(Map<?, ?> params) {
        if (params == null) {
            return null;
        }
        // 1. 查找 GeoLocation 属性（标识符为 GeoLocation 或 geoLocation）
        Object geoValue = params.get("GeoLocation");
        if (geoValue == null) {
            geoValue = params.get("geoLocation");
        }
        if (geoValue == null) {
            return null;
        }

        // 2. 转换为 Map
        Map<String, Object> geoLocation = null;
        if (geoValue instanceof Map) {
            geoLocation = (Map<String, Object>) geoValue;
        } else if (geoValue instanceof String) {
            geoLocation = JsonUtils.parseObject((String) geoValue, Map.class);
        }
        if (geoLocation == null) {
            return null;
        }

        // 3. 提取经纬度（支持阿里云命名规范：首字母大写）
        BigDecimal longitude = getBigDecimal(geoLocation, "Longitude");
        if (longitude == null) {
            longitude = getBigDecimal(geoLocation, "longitude");
        }
        BigDecimal latitude = getBigDecimal(geoLocation, "Latitude");
        if (latitude == null) {
            latitude = getBigDecimal(geoLocation, "latitude");
        }
        if (longitude == null || latitude == null) {
            return null;
        }
        // 校验经纬度范围：经度 -180 到 180，纬度 -90 到 90
        if (longitude.compareTo(BigDecimal.valueOf(-180)) < 0 || longitude.compareTo(BigDecimal.valueOf(180)) > 0
                || latitude.compareTo(BigDecimal.valueOf(-90)) < 0 || latitude.compareTo(BigDecimal.valueOf(90)) > 0) {
            log.warn("[parseGeoLocation][经纬度超出有效范围: lng={}, lat={}]", longitude, latitude);
            return null;
        }
        return new BigDecimal[]{longitude, latitude};
    }

}