Cold_Api/models/Device/DeviceData.go

package Device

import (
	"Cold_Api/conf"
	"Cold_Api/controllers/lib"
	"encoding/json"
	"errors"
	"fmt"
	"sort"
	"strconv"
	"strings"
	"time"

	"github.com/astaxie/beego/cache"
	_ "github.com/astaxie/beego/cache/redis"
	"github.com/astaxie/beego/logs"
	"github.com/beego/beego/v2/adapter/orm"
	orm2 "github.com/beego/beego/v2/client/orm"
	_ "github.com/go-sql-driver/mysql"
)

// 建表
// var CREATEsql = "CREATE TABLE IF NOT EXISTS `z_device_data_" + SN + " ( " +
var CREATEsql = " ( " +
	"`t_id` int(6) NOT NULL," +
	"`t_sp` int(6) NOT NULL," +
	"`t_time` datetime NOT NULL," +
	"`t_t` double(6, 1) NULL DEFAULT NULL," +
	"`t_rh` double(6, 1) NULL DEFAULT NULL," +
	"`t_site` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL," +
	"`create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP," +
	"PRIMARY KEY (`t_time`, `t_id`) USING BTREE" +
	") ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Compact;"

type DeviceData_ struct {
	T_id   int       // 传感器id
	T_sp   int       // 传感器参数id
	T_t    float32   // 温度
	T_rh   float32   // 湿度
	T_site string    // GPS
	T_time time.Time // 采集时间
}

// DeviceData_R1 辅助定位更新redis 结构体
type DeviceData_R1 struct {
	T_t    float32   // 温度
	T_rh   float32   // 湿度
	T_Site string    // GPS
	T_time time.Time // 采集时间
	T_sp   int       // 传感器参数ID
	T_tp   int       // 报警类型
	//create_time
}

// 模板
type DeviceData_R struct {
	T_sn     string  // sn
	T_id     int     // 传感器id
	T_name   string  // 传感器名称
	T_t      float32 // 温度
	T_rh     float32 // 湿度
	T_site   string  // GPS
	T_tl     float32 // 温度下限
	T_tu     float32 // 温度上限
	T_rhl    float32 // 湿度下限
	T_rhu    float32 // 湿度上限
	T_time   string  // 采集时间
	T_sp     int     // 传感器参数id
	T_ist    int     // 温度   1开启   2关闭
	T_ish    int     // 湿度   1开启   2关闭
	T_free   int     // 空库
	T_remark string  // 备注
	Sorts    int     // 排序
}
type DeviceData_R2 struct {
	DeviceData_
	Sn     string `json:"sn"`
	T_name string `json:"t_name"` // 设备名称
	Time   string `json:"t_time"`
}

// 模板
type DeviceData_ChartShow struct {
	T_sn   string  // sn
	T_id   int     // 传感器id
	T_name string  // 传感器名称
	T_t    float32 // 温度
	T_rh   float32 // 湿度
	T_tl   float32 // 温度下限
	T_tu   float32 // 温度上限
	T_rhl  float32 // 湿度下限
	T_rhu  float32 // 湿度上限
	T_time string  // 采集时间
}

// 模板
type DeviceData_Docking struct {
	T_monitor  int     // 监控状态 0 未监控 1 监控
	T_online   int     // 在线状态 0 未启用  1 在线  2 离线
	T_online_s int     // 在线状态-备用  0 未启用  1 在线  2 离线
	T_sn       string  // sn
	T_id       int     // 传感器id
	T_name     string  // 传感器名称
	T_t        float32 // 温度
	T_rh       float32 // 湿度
	T_site     string  // GPS
	T_tl       float32 // 温度下限
	T_tu       float32 // 温度上限
	T_rhl      float32 // 湿度下限
	T_rhu      float32 // 湿度上限
	T_time     string  // 采集时间
	T_sp       int     // 传感器参数id
}

type DeviceData_Pdf struct {
	T_time string   // sn
	T_id1  *float32 // 传感器id1温度
	T_id2  *float32 // 传感器id2温度
}

type DeviceData_BackUp struct {
	T_sn   string
	T_id   int    // 传感器id
	T_name string // 传感器名称
	T_date string // 采集日期
	T_num  int    // 数据量
}

//func (t *DeviceData) TableName() string {
//	return "DeviceData" // 数据库名称   // ************** 替换 FormulaList **************
//}

var redis_DeviceData cache.Cache

func init() {

	config := fmt.Sprintf(`{"key":"%s","conn":"%s","dbNum":"%s","password":"%s"}`,
		"redis_DeviceData", conf.Redis_address, conf.Redis_dbNum, conf.Redis_password)
	fmt.Println(config)
	var err error
	redis_DeviceData, err = cache.NewCache("redis", config)
	if err != nil || redis_DeviceData == nil {
		errMsg := "failed to init redis"
		logs.Error(errMsg, err)
		panic(errMsg)
	}
}

func DeviceData_ToDeviceData_R(d Device, r DeviceData_) (t DeviceData_R) {
	t.T_id = r.T_id
	t.T_t = r.T_t
	t.T_rh = r.T_rh
	t.T_site = r.T_site
	t.T_time = r.T_time.Format("2006-01-02 15:04:05")
	t.T_sp = r.T_sp
	sp := Read_DeviceSensorParameter_Map_Get(r.T_sp)
	t.T_name = sp.T_name
	t.T_tl = sp.T_Tlower
	t.T_tu = sp.T_Tupper
	t.T_rhl = sp.T_RHlower
	t.T_rhu = sp.T_RHupper
	t.T_free = sp.T_free
	if sp.T_free == 1 {
		t.T_remark = "空库"
	} else {
		t.T_remark = "-"
	}

	t.T_sn = d.T_sn
	t.T_ist = d.T_ist
	t.T_ish = d.T_ish

	return t
}

func DeviceDataToDeviceData_R2(d Device, sp DeviceSensorParameter_R, r DeviceData_) (t DeviceData_R) {

	t.T_id = r.T_id
	t.T_t = r.T_t
	t.T_rh = r.T_rh
	t.T_site = r.T_site
	t.T_time = r.T_time.Format("2006-01-02 15:04:05")

	// 传感器参数信息
	t.T_sp = r.T_sp
	t.T_name = sp.T_name
	t.T_tl = sp.T_Tlower
	t.T_tu = sp.T_Tupper
	t.T_rhl = sp.T_RHlower
	t.T_rhu = sp.T_RHupper

	// 设备信息
	t.T_ist = d.T_ist
	t.T_ish = d.T_ish

	return t
}

func DeviceData_ToDeviceData_ChartShow(d Device, r DeviceData_) (t DeviceData_ChartShow) {

	t.T_id = r.T_id
	t.T_t = r.T_t
	t.T_rh = r.T_rh
	t.T_time = r.T_time.Format("2006-01-02 15:04:05")
	sp := Read_DeviceSensorParameter_Map_Get(r.T_sp)
	t.T_name = sp.T_name
	t.T_tl = sp.T_Tlower
	t.T_tu = sp.T_Tupper
	t.T_rhl = sp.T_RHlower
	t.T_rhu = sp.T_RHupper

	return t
}

// ---------------- Redis -------------------
// Redis_Device_Set(m.T_sn,m) // Redis 更新缓存
func RedisDeviceData_Set(key string, r DeviceData_) (err error) {
	if redis_DeviceData.IsExist(key) {
		var t DeviceData_
		v := redis_DeviceData.Get(key)
		json.Unmarshal(v.([]byte), &t)
		if t.T_time.Unix() > r.T_time.Unix() {
			// 储存的 是最新数据
			return
		}
	}

	//json序列化
	str, err := json.Marshal(r)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return
	}
	err = redis_DeviceData.Put(key, str, 1*time.Hour)
	if err != nil {
		logs.Error("set key:", key, ",value:", str, err)
	}
	return
}

// 辅助定位设置redis数据
func RedisDeviceData_SetAssistedPositioning(T_sn string, T_id int, r DeviceData_R1) (err error) {
	key := T_sn + "|" + strconv.Itoa(T_id)

	if redis_DeviceData.IsExist(key) {
		var t DeviceData_R1
		v := redis_DeviceData.Get(key)
		json.Unmarshal(v.([]byte), &t)
		// 防止时间溢出
		if time.Now().Unix() <= r.T_time.Unix() {
			r.T_time = time.Now()
		}

	}

	//json序列化
	str, err := json.Marshal(r)
	if err != nil {
		logs.Error("RedisDeviceData_Set", err)
		return
	}
	err = redis_DeviceData.Put(key, str, 1*time.Hour)
	if err != nil {
		logs.Error("set key:", key, ",value:", str, err)
	}
	return
}

func RedisDeviceData_Get(key string) (r DeviceData_, is bool) {
	if redis_DeviceData.IsExist(key) {
		v := redis_DeviceData.Get(key)
		err := json.Unmarshal(v.([]byte), &r)
		if err != nil {
			logs.Error(lib.FuncName(), err)
			return DeviceData_{}, false
		}

		return r, true
	}
	return DeviceData_{}, false
}

// 辅助定位获取redis数据
func AssistedPositioning_Get(T_sn string, T_id int) (r DeviceData_R1, is bool) {
	key := T_sn + "|" + strconv.Itoa(T_id)
	if redis_DeviceData.IsExist(key) {
		v := redis_DeviceData.Get(key)
		json.Unmarshal(v.([]byte), &r)
		return r, true
	}
	return DeviceData_R1{}, false
}

// Redis_DeviceDataStatistics_Set 设置统计数据缓存
func Redis_DeviceDataStatistics_Set(SN string, T_id int, Time_start string, Time_end string, stats DeviceDataStatistics) error {
	// 构建缓存key: device_data_stats:SN:T_id:Time_start:Time_end
	key := fmt.Sprintf("device_data_stats:%s:%d:%s:%s", SN, T_id, Time_start, Time_end)

	// json序列化
	str, err := json.Marshal(stats)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return err
	}

	// 缓存10分钟
	err = redis_DeviceData.Put(key, str, 10*time.Minute)
	if err != nil {
		logs.Error("Redis_DeviceDataStatistics_Set", "set key:", key, err)
		return err
	}
	return nil
}

// Redis_DeviceDataStatistics_Get 获取统计数据缓存
func Redis_DeviceDataStatistics_Get(SN string, T_id int, Time_start string, Time_end string) (stats DeviceDataStatistics, found bool) {
	// 构建缓存key
	key := fmt.Sprintf("device_data_stats:%s:%d:%s:%s", SN, T_id, Time_start, Time_end)

	if !redis_DeviceData.IsExist(key) {
		return DeviceDataStatistics{}, false
	}

	v := redis_DeviceData.Get(key)
	err := json.Unmarshal(v.([]byte), &stats)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return DeviceDataStatistics{}, false
	}

	return stats, true
}

// -------------------------------------------------------
// 创建数据库  Device.CREATE_DeviceData("")
func CREATE_DeviceData(SN string) bool {

	sql := "CREATE TABLE IF NOT EXISTS `z_device_data_" + SN + "` " + CREATEsql
	o := orm.NewOrm()
	_, err := o.Raw(sql).Exec()
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return false
	}
	return true
}

func DELETE_DeviceDatar(SN string) bool {
	timeStr := time.Now().Format("2006_01_02_15_04_05")
	//sql := "DROP TABLE z_device_data_" + SN
	sql := "ALTER TABLE z_device_data_" + SN + " RENAME TO " + "z_device_data_" + SN + "_dle_" + timeStr + ";"
	logs.Info("DELETE_DeviceDatar sql:", sql)
	o := orm.NewOrm()
	_, err := o.Raw(sql).Exec()
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return false
	}
	return true
}

// ---------------- 特殊方法 ------------------
type DeviceData_T struct {
	T_id   int       // ID
	T_t    float32   // 温度
	T_rh   float32   // 湿度
	T_Site string    // GPS
	T_time time.Time // 采集时间
}

// 添加
func Add_DeviceData(SN string, v DeviceData_T) bool {
	//if(conf.Test_server){
	//	return true
	//}

	// 使用分钟级别的key进行去重判断，忽略秒数差异
	key_time := SN + "|" + strconv.Itoa(v.T_id) + "|" + v.T_time.Format("2006-01-02 15:04")
	logs.Debug(key_time)
	if redis_DeviceData.IsExist(key_time) {
		//println("找到key:",key)
		return true
	}

	o := orm.NewOrm()

	// 检查 超过时间，查询 数据库
	logs.Info("Add_DeviceData 时间差s：", time.Now().Unix()-v.T_time.Unix())
	if time.Now().Unix()-v.T_time.Unix() >= 60*40 {
		// 查看是否 有记录 - 按分钟查询，忽略秒数差异
		var maps_z []orm2.ParamsList
		// 使用 DATE_FORMAT 截断到分钟进行比较
		sql_c := "SELECT COUNT(*) FROM z_device_data_" + SN + " WHERE DATE_FORMAT(t_time,'%Y-%m-%d %H:%i') = '" + v.T_time.Format("2006-01-02 15:04") + "' AND t_id = " + strconv.Itoa(v.T_id)
		logs.Info("检查 超过时间，查询 数据库 SQL:", sql_c)
		_, err := o.Raw(sql_c).ValuesList(&maps_z)
		if err != nil {
			logs.Info(err)
			return false
		}
		if lib.To_int(maps_z[0][0]) > 0 {
			logs.Info("存在记录，跳过！")
			return true
		}
	}

	// 开始插入数据
	sql := "INSERT INTO z_device_data_" + SN + " ( `t_id`, `t_t`, `t_rh`, `t_site`, `t_time`) " +
		"VALUES (" + strconv.Itoa(v.T_id) + ", " + lib.To_string(v.T_t) + ", " + lib.To_string(v.T_rh) + ", '" + v.T_Site + "', '" + v.T_time.Format("2006-01-02 15:04:05") + "')"
	//  这里有时间优化  用于一次 prepare 多次 exec，以提高批量执行的速度
	logs.Debug(sql)
	res, err := o.Raw(sql).Exec()
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return false
	}
	res.RowsAffected()

	return true
}

// 辅助定位更新缓存
func Update_AssistedPositioning(T_sn, longitude, latitude, T_time string) error {
	o := orm.NewOrm()
	tableName := "z_device_data_" + T_sn
	var deviceData []DeviceData_
	tsn, i := Read_DeviceSensor_ByTsn(T_sn)
	if i == 0 {
		return errors.New("获取设备失败")
	}
	for _, v := range tsn {
		r, is := AssistedPositioning_Get(v.T_sn, v.T_id)
		if is {
			r.T_Site = longitude + "," + latitude
			err := RedisDeviceData_SetAssistedPositioning(v.T_sn, v.T_id, r)
			if err != nil {
				return err
			}
			sql := "SELECT * FROM " + tableName + " ORDER BY t_time DESC LIMIT 1"
			fmt.Println(sql)
			rows, err := o.Raw(sql).QueryRows(&deviceData)
			if err != nil {
				logs.Error(lib.FuncName(), err)
				return err
			}
			if rows > 0 {
				for _, data := range deviceData {
					format := data.T_time.Format("2006-01-02 15:04:05")
					sql = "UPDATE " + tableName + " SET t_site = '" + longitude + "," + latitude + "' WHERE t_id = " + strconv.Itoa(v.T_id) + " AND t_time = '" + format + "'"
					_, err := o.Raw(sql).Exec()
					if err != nil {
						logs.Error(lib.FuncName(), err)
						return err
					}
				}
			}
		}
	}
	return nil
}

func Read_DeviceData_ById_List(SN string, T_id int, Time_start_ string, Time_end_ string, page int, page_z int) ([]DeviceData_R, int) {
	o := orm.NewOrm()
	var maps []DeviceData_
	var maps_z []orm2.ParamsList
	var r []DeviceData_R
	var offset int
	if page_z == 0 {
		page_z = conf.Page_size
	}

	if page <= 1 {
		offset = 0
	} else {
		offset = (page - 1) * page_z
	}
	sql_time := ""

	if len(Time_start_) > 1 {
		sql_time += " t_time >= '" + Time_start_ + "' AND "
	}

	if len(Time_end_) > 1 {
		sql_time += " t_time <= '" + Time_end_ + "' AND "
	}

	sql := "SELECT COUNT(t_id) FROM z_device_data_" + SN + " WHERE " + sql_time + " t_id = " + strconv.Itoa(T_id)
	logs.Debug(sql)
	_, err := o.Raw(sql).ValuesList(&maps_z)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return r, 0
	}
	if len(maps_z) == 0 {
		return r, 0
	}

	sql = "SELECT t_id,t_sp,t_t,t_rh,t_site,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_time,t_time AS t_time1 FROM z_device_data_" + SN + " WHERE " + sql_time + " t_id = " + strconv.Itoa(T_id) + " ORDER BY t_time1 DESC,t_id DESC "
	if page_z != 9999 {
		sql = sql + " LIMIT " + strconv.Itoa(offset) + "," + strconv.Itoa(page_z)
	}

	logs.Debug(sql)
	_, err = o.Raw(sql).QueryRows(&maps)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return r, 0
	}

	//value, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", cnt), 64)
	key, _ := strconv.Atoi(maps_z[0][0].(string))
	device, err := Read_Device_ByT_sn(SN)
	if err != nil {
		logs.Error(lib.FuncName(), err)
	}
	for _, v := range maps {
		r = append(r, DeviceData_ToDeviceData_R(device, v))
	}

	return r, key
}

func Read_DeviceData_ById_List_ChartShow(SN string, T_id int, Time_start_ string, Time_end_ string) ([]DeviceData_ChartShow, int) {
	o := orm.NewOrm()
	var maps []DeviceData_

	sql_time := ""

	if len(Time_start_) > 1 {
		sql_time += " t_time >= '" + Time_start_ + "' AND "
	}

	if len(Time_end_) > 1 {
		sql_time += " t_time <= '" + Time_end_ + "' AND "
	}

	// 优化：移除不必要的 COUNT 查询，直接查询数据
	sql := "SELECT t_id,t_sp,t_t,t_rh,t_site,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_time,t_time AS t_time1 FROM z_device_data_" + SN + " WHERE " + sql_time + " t_id = " + strconv.Itoa(T_id) + " ORDER BY t_time1 DESC,t_id DESC "

	logs.Debug(sql)
	_, err := o.Raw(sql).QueryRows(&maps)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return []DeviceData_ChartShow{}, 0
	}

	// 如果没有数据，直接返回
	if len(maps) == 0 {
		return []DeviceData_ChartShow{}, 0
	}

	// 优化：预分配结果切片容量，减少内存重新分配
	r := make([]DeviceData_ChartShow, 0, len(maps))

	// 获取传感器名称和参数（只查询一次）
	deviceSensor, _ := Read_DeviceSensor_ByT_sn(SN, T_id)
	sp, _ := Read_DeviceSensorParameter(deviceSensor.T_sn, deviceSensor.T_id)

	// 转换数据
	for _, v := range maps {
		item := DeviceData_ChartShow{
			T_sn:   SN,
			T_id:   v.T_id,
			T_t:    v.T_t,
			T_rh:   v.T_rh,
			T_time: v.T_time.Format("2006-01-02 15:04:05"),
			T_name: deviceSensor.T_name,
			T_tl:   sp.T_Tlower,
			T_tu:   sp.T_Tupper,
			T_rhl:  sp.T_RHlower,
			T_rhu:  sp.T_RHupper,
		}
		r = append(r, item)
	}

	return r, len(r)
}

// Read_DeviceData_ById_List_ChartShow_WithCache 优化版本：接受预加载的传感器信息，避免重复查询
func Read_DeviceData_ById_List_ChartShow_WithCache(SN string, T_id int, Time_start_ string, Time_end_ string, deviceSensor DeviceSensor, sp DeviceSensorParameter_R) ([]DeviceData_ChartShow, int) {
	o := orm.NewOrm()
	var maps []DeviceData_

	sql_time := ""

	if len(Time_start_) > 1 {
		sql_time += " t_time >= '" + Time_start_ + "' AND "
	}

	if len(Time_end_) > 1 {
		sql_time += " t_time <= '" + Time_end_ + "' AND "
	}

	// 优化：移除不必要的 COUNT 查询，直接查询数据
	sql := "SELECT t_id,t_sp,t_t,t_rh,t_site,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_time,t_time AS t_time1 FROM z_device_data_" + SN + " WHERE " + sql_time + " t_id = " + strconv.Itoa(T_id) + " ORDER BY t_time1 DESC,t_id DESC "

	logs.Debug(sql)
	_, err := o.Raw(sql).QueryRows(&maps)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return []DeviceData_ChartShow{}, 0
	}

	// 如果没有数据，直接返回
	if len(maps) == 0 {
		return []DeviceData_ChartShow{}, 0
	}

	// 优化：预分配结果切片容量，减少内存重新分配
	r := make([]DeviceData_ChartShow, 0, len(maps))

	// 使用传入的传感器信息，无需再次查询
	for _, v := range maps {
		item := DeviceData_ChartShow{
			T_sn:   SN,
			T_id:   v.T_id,
			T_t:    v.T_t,
			T_rh:   v.T_rh,
			T_time: v.T_time.Format("2006-01-02 15:04:05"),
			T_name: deviceSensor.T_name,
			T_tl:   sp.T_Tlower,
			T_tu:   sp.T_Tupper,
			T_rhl:  sp.T_RHlower,
			T_rhu:  sp.T_RHupper,
		}
		r = append(r, item)
	}

	return r, len(r)
}

func Read_DeviceData_ById_List_OrderByTimeAes(SN string, T_id int, Time_start_ string, Time_end_ string, page int, page_z int) ([]DeviceData_R, int) {
	o := orm.NewOrm()
	var maps []DeviceData_
	var maps_z []orm2.ParamsList
	var r []DeviceData_R
	var offset int
	if page_z == 0 {
		page_z = conf.Page_size
	}

	if page <= 1 {
		offset = 0
	} else {
		offset = (page - 1) * page_z
	}
	sql_time := ""

	if len(Time_start_) > 1 {
		sql_time += " t_time >= '" + Time_start_ + "' AND "
	}

	if len(Time_end_) > 1 {
		sql_time += " t_time <= '" + Time_end_ + "' AND "
	}

	sql := "SELECT COUNT(t_id) FROM z_device_data_" + SN + " WHERE " + sql_time + " t_id = " + strconv.Itoa(T_id)
	logs.Debug(sql)
	_, err := o.Raw(sql).ValuesList(&maps_z)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return r, 0
	}
	if len(maps_z) == 0 {
		return r, 0
	}

	sql = "SELECT t_id,t_sp,t_t,t_rh,t_site,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_time,t_time AS t_time1 FROM z_device_data_" + SN + " WHERE " + sql_time + " t_id = " + strconv.Itoa(T_id) + " ORDER BY t_time1,t_id DESC "
	if page_z != 9999 {
		sql = sql + " LIMIT " + strconv.Itoa(offset) + "," + strconv.Itoa(page_z)
	}

	logs.Debug(sql)
	_, err = o.Raw(sql).QueryRows(&maps)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return r, 0
	}

	//value, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", cnt), 64)
	key, _ := strconv.Atoi(maps_z[0][0].(string))
	device, err := Read_Device_ByT_sn(SN)
	if err != nil {
		logs.Error(lib.FuncName(), err)
	}
	for _, v := range maps {
		r = append(r, DeviceData_ToDeviceData_R(device, v))
	}

	return r, key
}

func Read_DeviceData_ByIds(SN string, ids []int, Time_start_ string, Time_end_ string, page int, page_z int) ([]DeviceData_R, int) {
	o := orm.NewOrm()
	var maps []DeviceData_
	var maps_z []orm2.ParamsList
	var r []DeviceData_R
	var offset int
	if page_z == 0 {
		page_z = conf.Page_size
	}

	if page <= 1 {
		offset = 0
	} else {
		offset = (page - 1) * page_z
	}
	sql_time := ""

	if len(Time_start_) > 1 {
		sql_time += " t_time >= '" + Time_start_ + "' AND "
	}

	if len(Time_end_) > 1 {
		sql_time += " t_time <= '" + Time_end_ + "' AND "
	}

	sql := "SELECT COUNT(t_id) FROM z_device_data_" + SN + " WHERE " + sql_time + " t_id in (" + lib.IntListToDotStr(ids) + ")"
	logs.Debug(sql)
	_, err := o.Raw(sql).ValuesList(&maps_z)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return r, 0
	}
	if len(maps_z) == 0 {
		return r, 0
	}
	//t_tl,t_tu,t_rhl,t_rhu,
	sql = "SELECT t_id,t_sp,t_t,t_rh,t_site,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_time,t_time AS t_time1 FROM z_device_data_" + SN + " WHERE " + sql_time + " t_id in (" + lib.IntListToDotStr(ids) + ") ORDER BY t_time1 DESC,t_id ASC "
	if page_z != 9999 {
		sql = sql + " LIMIT " + strconv.Itoa(offset) + "," + strconv.Itoa(page_z)
	}

	logs.Debug(sql)
	_, err = o.Raw(sql).QueryRows(&maps)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return r, 0
	}

	key, _ := strconv.Atoi(maps_z[0][0].(string))
	device, err := Read_Device_ByT_sn(SN)
	if err != nil {
		logs.Error(lib.FuncName(), err)
	}
	for _, v := range maps {
		r = append(r, DeviceData_ToDeviceData_R(device, v))
	}

	return r, key
}
func Read_DeviceData_ByIds_ForPDF(SN string, ids []int, Time_start_ string, Time_end_ string) []DeviceData_Pdf {
	o := orm.NewOrm()
	var r []DeviceData_Pdf
	if len(ids) == 0 || len(ids) > 2 {
		return r
	}

	sql_time := ""

	if len(Time_start_) > 1 {
		sql_time += " t_time >= '" + Time_start_ + "' AND "
	}

	if len(Time_end_) > 1 {
		sql_time += " t_time <= '" + Time_end_ + "' AND "
	}

	selectSql := ""
	for i, v := range ids {
		selectSql += fmt.Sprintf("MAX(CASE WHEN t_id = %d THEN t_t END) AS t_id%d,", v, i+1)
	}
	selectSql = strings.Trim(selectSql, ",")

	sql := "SELECT DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_time," + selectSql + " FROM z_device_data_" + SN + " WHERE " + sql_time + " t_id in (" + lib.IntListToDotStr(ids) + ") GROUP BY t_time ORDER BY t_time"

	logs.Debug(sql)
	_, err := o.Raw(sql).QueryRows(&r)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return r
	}

	return r
}

func Read_SqlRawL(T_SQL string, T_data []string) (string, []orm2.Params) {
	o := orm.NewOrm()
	var lists []orm2.Params
	logs.Debug(T_SQL)
	_, err := o.Raw(T_SQL, T_data).Values(&lists)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return err.Error(), lists
	}

	return "", lists
}

func Read_DeviceData_By_T_snid_List(T_snid string, Time_start_ string, Time_end_ string, page int, page_z int) ([]DeviceData_R, int64) {
	T_snid_list := strings.Split(strings.Trim(T_snid, "|"), "|")
	var maps []DeviceData_R
	var maps_num int64
	var offset, offset_z int
	for _, v := range T_snid_list {
		sn_id := strings.Split(v, ",")
		if len(sn_id) == 3 {
			Read_DeviceSensorParameter_All_Map(sn_id[0], lib.To_int(sn_id[1]))
			r_maps, r_maps_num := Read_DeviceData_ById_List(sn_id[0], lib.To_int(sn_id[1]), Time_start_, Time_end_, 0, 9999)
			for i := range r_maps {
				atoi, _ := strconv.Atoi(sn_id[2])
				r_maps[i].Sorts = atoi
			}
			maps = append(maps, r_maps...)
			maps_num = maps_num + int64(r_maps_num)

			logs.Debug("加载数据：", sn_id[0], sn_id[1], r_maps_num)
		} else if len(sn_id) == 2 {
			Read_DeviceSensorParameter_All_Map(sn_id[0], lib.To_int(sn_id[1]))
			r_maps, r_maps_num := Read_DeviceData_ById_List(sn_id[0], lib.To_int(sn_id[1]), Time_start_, Time_end_, 0, 9999)
			maps = append(maps, r_maps...)
			maps_num = maps_num + int64(r_maps_num)

			logs.Debug("加载数据：", sn_id[0], sn_id[1], r_maps_num)
		}
	}

	if maps_num == 0 {
		return maps, maps_num
	}

	// 倒序
	sort.Slice(maps, func(i, j int) bool {
		if maps[i].T_time == maps[j].T_time {
			return maps[i].Sorts < maps[j].Sorts
		}
		return maps[i].T_time > maps[j].T_time
	})
	if page <= 1 {
		offset = 0
	} else {
		page -= 1
		offset = page * page_z
	}

	offset_z = offset + page_z
	if maps_num < int64(offset_z) {
		offset_z = int(maps_num)
	}
	if offset > offset_z {
		offset = offset_z
	}

	if page_z == 9999 {
		logs.Debug("总数据：", maps_num, " 导出")
		return maps, maps_num
	}
	logs.Debug("总数据：", maps_num, " 截取", offset, offset+page_z)
	return maps[offset:offset_z], maps_num
}

func Read_DeviceData_By_T_snid_List_ChartShow(T_snid string, Time_start_ string, Time_end_ string) ([]DeviceData_ChartShow, int64) {
	T_snid_list := strings.Split(strings.Trim(T_snid, "|"), "|")

	// 优化：批量预加载所有传感器信息和参数，避免 N+1 查询问题
	sensorMap := make(map[string]DeviceSensor)               // key: "SN_T_id"
	parameterMap := make(map[string]DeviceSensorParameter_R) // key: "SN_T_id"

	for _, v := range T_snid_list {
		sn_id := strings.Split(v, ",")
		if len(sn_id) < 2 {
			continue
		}
		sn := sn_id[0]
		sensorId := lib.To_int(sn_id[1])
		key := fmt.Sprintf("%s_%d", sn, sensorId)

		// 预加载传感器信息
		if sensor, ok := Read_DeviceSensor_ByT_sn(sn, sensorId); ok {
			sensorMap[key] = sensor
			// 预加载传感器参数
			if param, ok := Read_DeviceSensorParameter(sn, sensorId); ok {
				parameterMap[key] = param
			}
		}
	}

	// 预估容量以减少内存重新分配
	estimatedCapacity := len(T_snid_list) * 100
	maps := make([]DeviceData_ChartShow, 0, estimatedCapacity)
	var maps_num int64

	// 遍历所有传感器，加载数据
	for _, v := range T_snid_list {
		sn_id := strings.Split(v, ",")
		if len(sn_id) < 2 {
			continue
		}

		// 获取 SN 和传感器 ID
		sn := sn_id[0]
		sensorId := lib.To_int(sn_id[1])

		// 使用优化后的函数，传入预加载的传感器信息
		key := fmt.Sprintf("%s_%d", sn, sensorId)
		sensor, hasSensor := sensorMap[key]
		param, hasParam := parameterMap[key]

		if !hasSensor || !hasParam {
			logs.Debug("跳过传感器（未找到信息）：", sn, sensorId)
			continue
		}

		// 获取数据列表（使用新的优化函数）
		r_maps, r_maps_num := Read_DeviceData_ById_List_ChartShow_WithCache(sn, sensorId, Time_start_, Time_end_, sensor, param)

		maps = append(maps, r_maps...)
		maps_num += int64(r_maps_num)

		logs.Debug("加载数据：", sn, sensorId, r_maps_num)
	}

	// 如果没有数据，直接返回
	if maps_num == 0 {
		return maps, maps_num
	}

	// 按时间倒序排序
	sort.Slice(maps, func(i, j int) bool {
		return maps[i].T_time > maps[j].T_time
	})

	logs.Debug("总数据：", maps_num, " 导出全部")
	return maps, maps_num
}

// DeviceDataStatistics 设备数据统计结构（单个传感器）
type DeviceDataStatistics struct {
	SN          string  `json:"sn"`           // 设备SN
	SensorId    int     `json:"sensor_id"`    // 传感器ID
	SensorName  string  `json:"sensor_name"`  // 传感器名称
	TempMax     float32 `json:"temp_max"`     // 最高温度
	TempMin     float32 `json:"temp_min"`     // 最低温度
	TempAvg     float32 `json:"temp_avg"`     // 平均温度
	HumidityMax float32 `json:"humidity_max"` // 最高湿度
	HumidityMin float32 `json:"humidity_min"` // 最低湿度
	HumidityAvg float32 `json:"humidity_avg"` // 平均湿度
	DataCount   int64   `json:"data_count"`   // 数据条数
}

// DeviceDataStatisticsTotal 所有传感器数据统计汇总结构
type DeviceDataStatisticsTotal struct {
	TempMax     float32 `json:"temp_max"`     // 所有传感器中的最高温度
	TempMin     float32 `json:"temp_min"`     // 所有传感器中的最低温度
	TempAvg     float32 `json:"temp_avg"`     // 所有传感器温度平均值
	HumidityMax float32 `json:"humidity_max"` // 所有传感器中的最高湿度
	HumidityMin float32 `json:"humidity_min"` // 所有传感器中的最低湿度
	HumidityAvg float32 `json:"humidity_avg"` // 所有传感器湿度平均值
	DataCount   int64   `json:"data_count"`   // 总数据条数
}

// Read_DeviceData_Statistics 获取设备数据统计信息
func Read_DeviceData_Statistics(SN string, T_id int, Time_start_ string, Time_end_ string) (DeviceDataStatistics, error) {
	// 先尝试从缓存获取
	if cachedStats, found := Redis_DeviceDataStatistics_Get(SN, T_id, Time_start_, Time_end_); found {
		logs.Debug("从缓存获取统计数据: SN=%s, T_id=%d", SN, T_id)
		return cachedStats, nil
	}

	o := orm.NewOrm()
	var stats DeviceDataStatistics
	var result []orm2.ParamsList

	// 构建时间条件
	sql_time := ""
	if len(Time_start_) > 1 {
		sql_time += " t_time >= '" + Time_start_ + "' AND "
	}
	if len(Time_end_) > 1 {
		sql_time += " t_time <= '" + Time_end_ + "' AND "
	}

	// 查询统计数据：最大值、最小值、平均值、数据条数
	sql := "SELECT " +
		"MAX(t_t) AS temp_max, " +
		"MIN(t_t) AS temp_min, " +
		"AVG(t_t) AS temp_avg, " +
		"MAX(t_rh) AS humidity_max, " +
		"MIN(t_rh) AS humidity_min, " +
		"AVG(t_rh) AS humidity_avg, " +
		"COUNT(*) AS data_count " +
		"FROM z_device_data_" + SN + " " +
		"WHERE " + sql_time + " t_id = " + strconv.Itoa(T_id)

	logs.Debug(sql)
	_, err := o.Raw(sql).ValuesList(&result)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return stats, err
	}

	if len(result) == 0 || result[0][0] == nil {
		return stats, errors.New("没有查询到数据")
	}

	// 填充统计数据
	stats.SN = SN
	stats.SensorId = T_id

	// 解析统计结果
	if result[0][0] != nil {
		if val, err := strconv.ParseFloat(result[0][0].(string), 32); err == nil {
			stats.TempMax = float32(val)
		}
	}
	if result[0][1] != nil {
		if val, err := strconv.ParseFloat(result[0][1].(string), 32); err == nil {
			stats.TempMin = float32(val)
		}
	}
	if result[0][2] != nil {
		if val, err := strconv.ParseFloat(result[0][2].(string), 32); err == nil {
			stats.TempAvg = float32(val)
		}
	}
	if result[0][3] != nil {
		if val, err := strconv.ParseFloat(result[0][3].(string), 32); err == nil {
			stats.HumidityMax = float32(val)
		}
	}
	if result[0][4] != nil {
		if val, err := strconv.ParseFloat(result[0][4].(string), 32); err == nil {
			stats.HumidityMin = float32(val)
		}
	}
	if result[0][5] != nil {
		if val, err := strconv.ParseFloat(result[0][5].(string), 32); err == nil {
			stats.HumidityAvg = float32(val)
		}
	}
	if result[0][6] != nil {
		if val, err := strconv.ParseInt(result[0][6].(string), 10, 64); err == nil {
			stats.DataCount = val
		}
	}

	// 将统计数据存入缓存（10分钟有效期）
	if err := Redis_DeviceDataStatistics_Set(SN, T_id, Time_start_, Time_end_, stats); err != nil {
		logs.Error("缓存统计数据失败: ", err)
		// 即使缓存失败也继续返回数据
	}

	return stats, nil
}

func Read_DeviceData_ById_Year_List(SN string) []orm2.ParamsList {
	o := orm.NewOrm()

	var maps_z []orm2.ParamsList

	//sql = "SELECT t_name,t_t,t_rh,t_tl,t_tu,t_rhl,t_rhu,t_site,DATE_FORMAT(t_time,'%Y-%c-%d %H:%i:%s') AS t_time  FROM z_device_data_"+SN+" WHERE "+sql_time+" t_id = "+ strconv.Itoa(T_id) +" ORDER BY t_time DESC "
	sql := "SELECT DATE_FORMAT(t_time,\"%m\") AS m ,DATE_FORMAT(t_time,\"%d\") AS d FROM z_device_data_" + SN + "  WHERE t_time > '" + strconv.Itoa(time.Now().Year()) + "-0-0 00:00:00' GROUP BY DATE_FORMAT(t_time,\"%m\");"
	logs.Debug(sql)
	num, err := o.Raw(sql).ValuesList(&maps_z)
	if err == nil && num > 0 {
		logs.Debug(maps_z[0][0]) // slene
	}
	//value, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", cnt), 64)
	//key,_ := strconv.Atoi(maps_z[0][0].(string))
	return maps_z
} //
func Read_DeviceData_ById_Month_List(SN string) []orm2.ParamsList {
	o := orm.NewOrm()

	var maps_z []orm2.ParamsList
	currentTime := time.Now() //获取当前时间，类型是Go的时间类型Time

	time_x := currentTime.Format("2006-01") + "-00 00:00:00"

	//sql = "SELECT t_name,t_t,t_rh,t_tl,t_tu,t_rhl,t_rhu,t_site,DATE_FORMAT(t_time,'%Y-%c-%d %H:%i:%s') AS t_time  FROM z_device_data_"+SN+" WHERE "+sql_time+" t_id = "+ strconv.Itoa(T_id) +" ORDER BY t_time DESC "
	sql := "SELECT DATE_FORMAT(t_time,\"%d\") AS d FROM z_device_data_" + SN + "  WHERE t_time > '" + time_x + "' GROUP BY DATE_FORMAT(t_time,\"%d\");"
	logs.Debug(sql)
	o.Raw(sql).ValuesList(&maps_z)

	//value, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", cnt), 64)
	//key,_ := strconv.Atoi(maps_z[0][0].(string))
	return maps_z
}
func Read_DeviceData_ById_Day_List(SN string) []orm2.ParamsList {
	o := orm.NewOrm()

	var maps_z []orm2.ParamsList
	currentTime := time.Now() //获取当前时间，类型是Go的时间类型Time

	time_x := currentTime.Format("2006-01-02") + " 00:00:00"

	//sql = "SELECT t_name,t_t,t_rh,t_tl,t_tu,t_rhl,t_rhu,t_site,DATE_FORMAT(t_time,'%Y-%c-%d %H:%i:%s') AS t_time  FROM z_device_data_"+SN+" WHERE "+sql_time+" t_id = "+ strconv.Itoa(T_id) +" ORDER BY t_time DESC "
	sql := "SELECT DATE_FORMAT(t_time,\"%H\") AS m FROM z_device_data_" + SN + "  WHERE t_time > '" + time_x + "' GROUP BY DATE_FORMAT(t_time,\"%H\");"
	logs.Debug(sql)
	o.Raw(sql).ValuesList(&maps_z)

	//value, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", cnt), 64)
	//key,_ := strconv.Atoi(maps_z[0][0].(string))
	return maps_z
}

func Read_DeviceData_List_GROUP_BY_t_time(SN string, Time_start_ string, Time_end_ string) []orm2.ParamsList {
	o := orm.NewOrm()

	var maps_z []orm2.ParamsList

	sql_time := ""
	if len(Time_start_) > 1 {
		sql_time += " t_time >= '" + Time_start_ + "' AND " + " t_time <= '" + Time_end_ + "' "
	}

	sql := "SELECT DATE_FORMAT(t_time,'%Y-%c-%d %H:%i:%s') AS t_time FROM z_device_data_" + SN + " WHERE " + sql_time + "   GROUP BY t_time  ORDER BY t_time DESC "
	logs.Debug(sql)
	_, err := o.Raw(sql).ValuesList(&maps_z)
	if err != nil {
		logs.Error(lib.FuncName(), err)
	}
	return maps_z
}

func Read_DeviceData(T_sn string, T_id int) (t DeviceData_) {
	key := T_sn + "|" + strconv.Itoa(T_id)
	if t, is := RedisDeviceData_Get(key); is {
		return t
	}
	o := orm.NewOrm()
	var maps []DeviceData_
	sql := "SELECT t_id,t_sp,t_t,t_rh,t_site,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_time,t_time AS t_time1 FROM z_device_data_" + T_sn + " WHERE" + " t_id = " + strconv.Itoa(T_id) + " ORDER BY t_time1 DESC LIMIT 0,1"

	logs.Debug(sql)
	_, err := o.Raw(sql).QueryRows(&maps)

	if err != nil {
		logs.Error(lib.FuncName(), err)
		return t
	}

	if len(maps) == 0 {
		RedisDeviceData_Set(key, t)
		return t
	}

	RedisDeviceData_Set(key, maps[0])

	return maps[0]
}

// 获取数据备份
func Read_DeviceData_BackUp_List(T_snid string, Time_start_ string, Time_end_ string, page int, page_z int) ([]DeviceData_BackUp, int64) {
	T_snid_list := strings.Split(T_snid, "|")
	var maps []DeviceData_BackUp
	var maps_num int64
	var offset, offset_z int

	for _, v := range T_snid_list {
		sn_id := strings.Split(v, ",")

		if len(sn_id) >= 2 {

			r_maps, r_maps_num := Read_DeviceData_BackUp(sn_id[0], lib.To_int(sn_id[1]), Time_start_, Time_end_)

			maps = append(maps, r_maps...)
			maps_num = maps_num + int64(r_maps_num)

			logs.Debug("加载数据：", sn_id[0], sn_id[1], r_maps_num)
		}
	}
	if page <= 1 {
		offset = 0
	} else {
		page -= 1
		offset = page * page_z
	}

	offset_z = offset + page_z
	if maps_num < int64(offset_z) {
		offset_z = int(maps_num)
	}
	if offset > offset_z {
		offset = offset_z
	}

	if page_z == 9999 {
		logs.Debug("总数据：", maps_num, " 导出")
		return maps, maps_num
	}
	logs.Debug("总数据：", maps_num, " 截取", offset, offset+page_z)
	return maps[offset:offset_z], maps_num
}

func Read_DeviceData_BackUp(T_sn string, T_id int, Time_start_ string, Time_end_ string) ([]DeviceData_BackUp, int) {
	o := orm.NewOrm()
	var maps []DeviceData_BackUp

	sql_time := ""

	if len(Time_start_) > 0 {
		sql_time += " t_time >= '" + Time_start_ + "' AND"
	}

	if len(Time_end_) > 0 {
		sql_time += " t_time <= '" + Time_end_ + "' AND"
	}

	sql := "SELECT t_id,date_format(t_time, '%Y-%m-%d') t_date, count(*) t_num FROM z_device_data_" + T_sn + " WHERE " + sql_time + " t_id = " + strconv.Itoa(T_id) + " GROUP BY t_date ORDER BY t_time DESC "

	logs.Debug(sql)
	_, err := o.Raw(sql).QueryRows(&maps)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return maps, 0
	}

	deviceSensor, _ := Read_DeviceSensor_ByT_sn(T_sn, T_id)

	for i := 0; i < len(maps); i++ {
		maps[i].T_sn = T_sn
		maps[i].T_name = deviceSensor.T_name
	}

	return maps, len(maps)
}

func Read_DeviceData_By_Time(T_sn string, T_id int, Time string) (t DeviceData_) {

	o := orm.NewOrm()
	var maps DeviceData_
	sql := "SELECT t_id,t_sp,t_t,t_rh,t_site,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_time,t_time AS t_time1 FROM z_device_data_" + T_sn + " WHERE" + " t_id = " + strconv.Itoa(T_id) + " AND t_time <= '" + Time + "'" + " ORDER BY t_time1 DESC LIMIT 0,1"

	logs.Debug(sql)
	err := o.Raw(sql).QueryRow(&maps)

	if err != nil {
		logs.Error(lib.FuncName(), err)
		return t
	}

	return maps
}
func Read_DeviceData_Start_Time(T_sn string, T_id int, StartTime, EndTime string) (t []DeviceData_, count int64) {
	o := orm.NewOrm()
	var maps []DeviceData_
	var sql string
	if len(StartTime) > 0 && len(EndTime) > 0 {
		sql = "SELECT t_id,t_sp,t_t,t_rh,t_site,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_time,t_time AS t_time1 FROM z_device_data_" + T_sn + " WHERE" + " t_id = " + strconv.Itoa(T_id) + " AND t_time >= '" + StartTime + "'" + " AND t_time <= '" + EndTime + "'" + " ORDER BY t_time1 DESC"
	} else if len(StartTime) > 0 && len(EndTime) == 0 {
		sql = "SELECT t_id,t_sp,t_t,t_rh,t_site,DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_time,t_time AS t_time1 FROM z_device_data_" + T_sn + " WHERE" + " t_id = " + strconv.Itoa(T_id) + " AND t_time >= '" + StartTime + "'" + " ORDER BY t_time1 DESC"
	}
	logs.Debug(sql)
	count, err := o.Raw(sql).QueryRows(&maps)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return t, 0
	}
	return maps, count
}

// 获取最新轨迹信息
func GetNewLocus(T_sn string, T_id int, list *[]DeviceData_) error {
	task, err := Read_DeviceTask_List_By_Condition(T_sn)
	if err != nil {
		logs.Error(lib.FuncName(), err.Error())
		return errors.New("设备未开启监控")
	}
	// 当最新设备状态为1时，证明设备正在启动中，查询大于开始时间的所有轨迹，设备状态为2时，查询开始时间到结束时间的轨迹
	if task.T_State == 1 {
		deviceData, count := Read_DeviceData_Start_Time(T_sn, T_id, task.T_Ut_start.Format("2006-01-02 15:04:05"), "")
		if count >= 0 {
			*list = appendUniqueDeviceData(*list, deviceData)
		} else {
			logs.Error(lib.FuncName(), err)
			return errors.New("获取设备轨迹失败")
		}

	} else if task.T_State == 2 {
		deviceData, count := Read_DeviceData_Start_Time(T_sn, T_id, task.T_Ut_start.Format("2006-01-02 15:04:05"), task.T_Ut_end.Format("2006-01-02 15:04:05"))
		if count >= 0 {
			*list = appendUniqueDeviceData(*list, deviceData)
		} else {
			logs.Error(lib.FuncName(), err)
			return errors.New("获取设备轨迹失败")
		}
	}
	return nil
}

// 去重并追加设备数据
func appendUniqueDeviceData(list []DeviceData_, newData []DeviceData_) []DeviceData_ {
	// 使用分钟级别的时间戳进行去重，忽略秒数差异
	uniqueMap := make(map[string]bool)
	for _, d := range list {
		// 截断到分钟级别
		timeKey := d.T_time.Format("2006-01-02 15:04")
		uniqueMap[timeKey] = true
	}
	for _, d := range newData {
		timeKey := d.T_time.Format("2006-01-02 15:04")
		if !uniqueMap[timeKey] {
			if len(d.T_site) > 0 && d.T_site != "0,0" {
				split := strings.Split(d.T_site, ",")
				defer func() {
					if r := recover(); r != nil {
						fmt.Println("数组下标越界:", r)
					}
				}()
				Lng := split[0]
				Lat := split[1]
				Lngs, _ := strconv.ParseFloat(Lng, 64)
				Lats, _ := strconv.ParseFloat(Lat, 64)
				mLng, mLat := lib.Wgs84ToGcj02(Lngs, Lats)
				d.T_site = fmt.Sprintf("%v,%v", mLng, mLat)
				list = append(list, d)
				uniqueMap[timeKey] = true // 标记该分钟的数据已添加
			}
		}
	}
	//排序
	sort.Slice(list, func(i, j int) bool {
		return list[i].T_time.After(list[j].T_time)
	})
	return list
}

// 数据缺失检测结果结构体
type DeviceDataMissingInfo struct {
	T_sn           string          // 设备序列号
	T_id           int             // 传感器ID
	Time_start     string          // 开始时间
	Time_end       string          // 结束时间
	T_saveT        int             // 数据保存间隔（秒）
	ExpectedCount  int             // 期望的数据条数
	ActualCount    int             // 实际的数据条数
	MissingMinutes []string        // 缺失的分钟点（忽略秒）
	MissingPeriods []MissingPeriod // 缺失时间段列表
}

// 缺失时间段
type MissingPeriod struct {
	StartTime    string // 缺失开始时间
	EndTime      string // 缺失结束时间
	Duration     int    // 缺失时长（秒）
	MissingCount int    // 该时间段缺失的数据条数
}

// Read_DeviceData_Missing_Check 检测设备数据缺失情况
func Read_DeviceData_Missing_Check(T_sn string, T_id int, Time_start_ string, Time_end_ string) (DeviceDataMissingInfo, error) {
	var result DeviceDataMissingInfo
	result.T_sn = T_sn
	result.T_id = T_id
	result.Time_start = Time_start_
	result.Time_end = Time_end_

	// 1. 获取设备参数，获取 T_saveT
	deviceParams := Read_DeviceParameter_SN(T_sn)
	if len(deviceParams) == 0 {
		return result, errors.New("未找到设备参数")
	}
	result.T_saveT = deviceParams[0].T_saveT
	if result.T_saveT <= 0 {
		result.T_saveT = 60 // 默认60秒
	}

	// 2. 解析时间
	startTime, err := time.Parse("2006-01-02 15:04:05", Time_start_)
	if err != nil {
		return result, errors.New("开始时间格式错误")
	}
	endTime, err := time.Parse("2006-01-02 15:04:05", Time_end_)
	if err != nil {
		return result, errors.New("结束时间格式错误")
	}
	if startTime.After(endTime) {
		return result, errors.New("开始时间不能晚于结束时间")
	}

	// 3. 计算期望的数据条数
	duration := int(endTime.Sub(startTime).Seconds())
	//按区间步长计算并包含起点（例如：0、5、10 分钟应为 3 条）
	result.ExpectedCount = duration/result.T_saveT + 1

	// 4. 查询实际数据，获取所有时间点
	o := orm.NewOrm()
	var timePoints []orm2.ParamsList
	sql := "SELECT DISTINCT DATE_FORMAT(t_time,'%Y-%m-%d %H:%i:%s') AS t_time FROM z_device_data_" + T_sn +
		" WHERE t_id = " + strconv.Itoa(T_id) +
		" AND t_time >= '" + Time_start_ + "'" +
		" AND t_time <= '" + Time_end_ + "'" +
		" ORDER BY t_time ASC"

	logs.Debug(sql)
	_, err = o.Raw(sql).ValuesList(&timePoints)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return result, errors.New("查询数据失败")
	}

	result.ActualCount = len(timePoints)

	// 4.1 计算缺失的分钟点（逐分钟对齐，忽略秒）
	// 构建已存在的分钟集合
	presentMinutes := make(map[string]struct{})
	for _, tp := range timePoints {
		if len(tp) > 0 {
			if timeStr, ok := tp[0].(string); ok {
				if t, err := time.Parse("2006-01-02 15:04:05", timeStr); err == nil {
					minute := time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), 0, 0, t.Location())
					presentMinutes[minute.Format("2006-01-02 15:04")] = struct{}{}
				}
			}
		}
	}
	// 构建 presentMinutes 已去重，不再需要对 actualMinuteTimes 进行去重收集

	// 基于保存间隔（分钟）生成应有的时间点，再找缺失
	startMinute := time.Date(startTime.Year(), startTime.Month(), startTime.Day(), startTime.Hour(), startTime.Minute(), 0, 0, startTime.Location())
	endMinute := time.Date(endTime.Year(), endTime.Month(), endTime.Day(), endTime.Hour(), endTime.Minute(), 0, 0, endTime.Location())
	intervalMin := result.T_saveT / 60
	if intervalMin <= 0 {
		intervalMin = 1
	}
	// 将起点对齐到间隔边界（例如 5 分钟对齐到 00/05/10/...）
	firstExpected := startMinute
	if intervalMin > 1 {
		rem := firstExpected.Minute() % intervalMin
		if rem != 0 {
			firstExpected = firstExpected.Add(time.Duration(intervalMin-rem) * time.Minute)
		}
	}
	var missingMinutes []string
	for t := firstExpected; !t.After(endMinute); t = t.Add(time.Duration(intervalMin) * time.Minute) {
		mk := t.Format("2006-01-02 15:04")
		if _, ok := presentMinutes[mk]; !ok {
			missingMinutes = append(missingMinutes, mk)
		}
	}
	result.MissingMinutes = missingMinutes

	// 5. 计算缺失时间段
	result.MissingPeriods = calculateMissingPeriods(startTime, endTime, timePoints, result.T_saveT)

	return result, nil
}

// calculateMissingPeriods 计算缺失时间段
func calculateMissingPeriods(startTime, endTime time.Time, timePoints []orm2.ParamsList, saveInterval int) []MissingPeriod {
	var missingPeriods []MissingPeriod

	if len(timePoints) == 0 {
		// 完全没有数据
		duration := int(endTime.Sub(startTime).Seconds())
		missingPeriods = append(missingPeriods, MissingPeriod{
			StartTime:    startTime.Format("2006-01-02 15:04:05"),
			EndTime:      endTime.Format("2006-01-02 15:04:05"),
			Duration:     duration,
			MissingCount: duration / saveInterval,
		})
		return missingPeriods
	}

	// 解析实际数据时间点
	var actualTimes []time.Time
	for _, tp := range timePoints {
		if len(tp) > 0 {
			if timeStr, ok := tp[0].(string); ok {
				if t, err := time.Parse("2006-01-02 15:04:05", timeStr); err == nil {
					actualTimes = append(actualTimes, t)
				}
			}
		}
	}

	// 检查开始时间之前是否有缺失
	if len(actualTimes) > 0 && actualTimes[0].After(startTime) {
		duration := int(actualTimes[0].Sub(startTime).Seconds())
		if duration >= saveInterval {
			missingPeriods = append(missingPeriods, MissingPeriod{
				StartTime:    startTime.Format("2006-01-02 15:04:05"),
				EndTime:      actualTimes[0].Format("2006-01-02 15:04:05"),
				Duration:     duration,
				MissingCount: duration / saveInterval,
			})
		}
	}

	// 检查中间缺失的时间段
	for i := 0; i < len(actualTimes)-1; i++ {
		currentTime := actualTimes[i]
		nextTime := actualTimes[i+1]

		// 截断到分钟级别进行比较，忽略秒数差异
		currentMinute := time.Date(currentTime.Year(), currentTime.Month(), currentTime.Day(),
			currentTime.Hour(), currentTime.Minute(), 0, 0, currentTime.Location())
		nextMinute := time.Date(nextTime.Year(), nextTime.Month(), nextTime.Day(),
			nextTime.Hour(), nextTime.Minute(), 0, 0, nextTime.Location())

		gap := int(nextMinute.Sub(currentMinute).Seconds())

		// 如果时间间隔大于保存间隔的2倍，认为有缺失
		if gap >= saveInterval*2 {
			duration := gap - saveInterval // 减去正常间隔
			missingPeriods = append(missingPeriods, MissingPeriod{
				StartTime:    currentMinute.Add(time.Duration(saveInterval) * time.Second).Format("2006-01-02 15:04:05"),
				EndTime:      nextMinute.Format("2006-01-02 15:04:05"),
				Duration:     duration,
				MissingCount: duration / saveInterval,
			})
		}
	}

	// 检查结束时间之前是否有缺失
	if len(actualTimes) > 0 && actualTimes[len(actualTimes)-1].Before(endTime) {
		lastTime := actualTimes[len(actualTimes)-1]
		duration := int(endTime.Sub(lastTime).Seconds())
		if duration >= saveInterval {
			missingPeriods = append(missingPeriods, MissingPeriod{
				StartTime:    lastTime.Add(time.Duration(saveInterval) * time.Second).Format("2006-01-02 15:04:05"),
				EndTime:      endTime.Format("2006-01-02 15:04:05"),
				Duration:     duration,
				MissingCount: duration / saveInterval,
			})
		}
	}

	return missingPeriods
}