FranklinWH-Toolbox/service/repositories/api/fwh_pro/fwh_eventAlarmLog.go

package fwh_pro

import (
	"errors"
	"fmt"
	"fwh-toolbox-server/domain"
	"net/url"
	"strconv"
	"time"

	"go.uber.org/zap"
)

type EventAlarmType int

const (
	All   EventAlarmType = iota // 0
	Event                       // 1
	Alarm                       // 2
)

// 查询事件事件日志
func queryEventAndAlarmLog(sn string, params url.Values) (*domain.FwhResponse[[]domain.EventAlarmItem], error) {
	userId := getUserId()

	// 构造 query 参数
	params.Add("userId", strconv.FormatUint(uint64(userId), 10))
	params.Add("searchName", sn)
	params.Add("timeType", strconv.Itoa(1)) // 0-通讯时间；1-设备时间
	params.Add("pageSize", strconv.FormatUint(REQ_PAGE_SIZE, 10))
	params.Add("pageNum", strconv.Itoa(1))
	params.Add("land", "ZH_CN")

	response, err := FwhHttpGetUnmarshal[[]domain.EventAlarmItem](getFullEnergyUrl("/hes-gateway/manage/iotDeviceRunLogs"), params)
	if err != nil {
		return nil, err
	}
	return response, nil
}

// 查询所有事件告警
// startTime&endTime 格式 YYYY-MM-DD HH:mm:SS
func queryAllEventAlarm(sn, startTime, endTime string) (*domain.FwhResponse[[]domain.EventAlarmItem], error) {
	// 构造 query 参数
	params := url.Values{}
	params.Add("startTime", startTime)
	params.Add("endTime", endTime)

	return queryEventAndAlarmLog(sn, params)
}

// 查询事件日志
// startTime&endTime 格式 YYYY-MM-DD HH:mm:SS
func queryEventLog(sn, startTime, endTime string) (*domain.FwhResponse[[]domain.EventAlarmItem], error) {
	// 构造 query 参数
	params := url.Values{}
	params.Add("logType", strconv.Itoa(0))
	params.Add("startTime", startTime)
	params.Add("endTime", endTime)

	return queryEventAndAlarmLog(sn, params)
}

// 查询告警日志
// startTime&endTime 格式 YYYY-MM-DD HH:mm:SS
// alarmCode - 支持多个code，用‘,’隔开，“”代表查询所有
func queryAlarmLog(sn, startTime, endTime, alarmCode string) (*domain.FwhResponse[[]domain.EventAlarmItem], error) {
	// 构造 query 参数
	params := url.Values{}
	params.Add("logType", strconv.Itoa(1))
	params.Add("alarmCode", alarmCode)
	params.Add("startTime", startTime)
	params.Add("endTime", endTime)

	return queryEventAndAlarmLog(sn, params)
}

// 查询实时告警
func queryRealtimeAlarm(sn string) (*domain.FwhResponse[[]domain.EventAlarmItem], error) {
	// 构造 query 参数
	params := url.Values{}
	params.Add("logType", strconv.Itoa(2))

	return queryEventAndAlarmLog(sn, params)
}

func queryEventOrAlarmListOnePage(sn string, startTime, endTime time.Time, t EventAlarmType) ([]domain.EventAlarmItem, error) {
	// 三次请求尝试
	for i := 0; i < 3; i++ {
		eventLogRes, err := queryEventOrAlarmListOnePageExec(sn, startTime, endTime, t)
		if err != nil {
			zap.L().Warn("queryEventOrAlarmListOnePageExec failed and retry", zap.String("err", err.Error()))
			continue
		}

		if eventLogRes.Code != 200 {
			// return nil, fmt.Errorf("查询失败 code: %d, message: %s", eventLogRes.Code, eventLogRes.Message)
			zap.L().Warn("queryEventOrAlarmListOnePage 查询失败 retry", zap.Int("code", eventLogRes.Code), zap.String("msg", eventLogRes.Message))
			time.Sleep(time.Second * 5)
			continue
		}

		return *eventLogRes.Result, nil
	}

	return nil, errors.New("retry failed")
}

func queryEventOrAlarmListOnePageExec(sn string, startTime, endTime time.Time, t EventAlarmType) (*domain.FwhResponse[[]domain.EventAlarmItem], error) {
	startTimeStr := startTime.Format(time.DateTime)
	endTimeStr := endTime.Format(time.DateTime)
	// TEST
	fmt.Printf("startTime = %s\n", startTimeStr)
	fmt.Printf("endTime = %s\n", endTimeStr)
	var eventLogRes *domain.FwhResponse[[]domain.EventAlarmItem]
	var err error
	switch t {
	case Event:
		eventLogRes, err = queryEventLog(sn, startTimeStr, endTimeStr)
	case Alarm:
		eventLogRes, err = queryAlarmLog(sn, startTimeStr, endTimeStr, "")
	default:
		eventLogRes, err = queryAllEventAlarm(sn, startTimeStr, endTimeStr)
	}
	if err != nil {
		return nil, err
	}

	return eventLogRes, nil
}

// 从FWH获取事件或告警log数据
//
// 限制条件（重要）：startTime/endTime 必须为「不含时区」的字面时间（用 UTC 表示）。
// 本函数按天拆分时间段时用 time.Truncate(24h) 推进游标，Truncate 按 UTC 零点对齐；
// 若传入带非 UTC 时区（如 America/Chicago）的时间，游标会回退到前一天，
// currTime.Before(endTime) 恒成立，periods 切片无限 append，导致内存 OOM。
// 调用方（DataDownload）需先用 stripTimeLocation 剥离时区再传入。
func QueryEventOrAlarmListOnTimeRange(sn string, startTime, endTime time.Time, t EventAlarmType) ([]domain.EventAlarmItem, error) {
	// 保证 startTime <= endTime
	if startTime.After(endTime) {
		return nil, errors.New("startTime > endTime")
	}

	// 按天拆分时间段
	var periods []struct{ Start, End time.Time }
	currTime := startTime
	for currTime.Before(endTime) {
		// 当天结束时间
		dayEnd := time.Date(currTime.Year(), currTime.Month(), currTime.Day(), 23, 59, 59, 0, currTime.Location())

		// 如果当天结束大于 endTime，使用 endTime
		if dayEnd.After(endTime) {
			dayEnd = endTime
		}

		periods = append(periods, struct{ Start, End time.Time }{Start: currTime, End: dayEnd})

		// 下一天开始
		currTime = dayEnd.Add(time.Second).Truncate(24 * time.Hour)
		currTime = time.Date(currTime.Year(), currTime.Month(), currTime.Day(), 0, 0, 0, 0, currTime.Location())
	}
	zap.L().Debug("[fwh_pro] 事件/告警 periods 构建完成",
		zap.String("sn", sn), zap.Int("logType", int(t)),
		zap.Time("start", startTime), zap.Time("end", endTime),
		zap.Int("periods", len(periods)),
	)

	// 按天查询
	var eventLogList []domain.EventAlarmItem
	for _, period := range periods {
		var eventLogRes []domain.EventAlarmItem = nil
		periodEndTime := period.End
		pages := 0
		// 检查数据是否超过1000(单次查询上限)
		for {
			var err error
			pages++
			zap.L().Debug("[fwh_pro] 事件/告警分页请求发起",
				zap.String("sn", sn), zap.Int("logType", int(t)),
				zap.Time("periodStart", period.Start), zap.Time("periodEnd", periodEndTime),
				zap.Int("page", pages), zap.Int("accumulated", len(eventLogList)),
			)
			eventLogRes, err = queryEventOrAlarmListOnePage(sn, period.Start, periodEndTime, t)
			if err != nil {
				return nil, err
			}

			eventLogList = append(eventLogList, eventLogRes...)

			// 观测：累计规模，用于定位内存放大。正常一天一页即结束。
			zap.L().Debug("[fwh_pro] 事件/告警分页请求返回",
				zap.String("sn", sn),
				zap.Int("logType", int(t)),
				zap.Int("page", pages),
				zap.Int("pageRows", len(eventLogRes)),
				zap.Int("accumulated", len(eventLogList)),
			)

			// 判断是否未查完
			if len(eventLogRes) < int(REQ_PAGE_SIZE) {
				// 请求完成，退出
				break
			}

			// 跳转时间段，再次请求
			// 提取最后一条数据的设备时间
			next, err := time.Parse(time.DateTime, eventLogRes[len(eventLogRes)-1].LogTime)
			if err != nil {
				return nil, err
			}

			// 游标未能前进：说明同一秒内 >= REQ_PAGE_SIZE(1000) 条数据，
			// 单页游标无法翻过这一秒，继续循环会死循环并 OOM。现实中基本不会发生，
			// 此处仅作防护：记录错误并返回，不再无限拉取。
			if !next.Before(periodEndTime) {
				zap.L().Error("[fwh_pro] 事件/告警日志分页游标停滞，疑似同一秒内数据超过单页上限",
					zap.String("sn", sn),
					zap.Int("logType", int(t)),
					zap.Time("stuckAt", next),
					zap.Int("pageSize", int(REQ_PAGE_SIZE)),
					zap.Int("accumulated", len(eventLogList)),
				)
				return nil, fmt.Errorf("event/alarm log pagination stalled at %s: more than %d rows within one second", next.Format(time.DateTime), REQ_PAGE_SIZE)
			}
			periodEndTime = next
		}
	}

	return eventLogList, nil
}

// 查询快照信息
// logTime 格式 YYYY-MM-DD
func queryAlarmSnapshotInfo(sn, logTime string, page int) (*domain.FwhPageResponse[[]domain.AlarmSnapshotInfo], error) {
	// 构造 query 参数
	params := url.Values{}
	params.Add("logTime", logTime)
	params.Add("linkId", sn)
	params.Add("pageSize", strconv.FormatUint(REQ_PAGE_SIZE, 10))
	params.Add("pageNum", strconv.Itoa(page))
	params.Add("land", "ZH_CN")

	response, err := FwhHttpGetUnmarshalPage[[]domain.AlarmSnapshotInfo](getFullEnergyUrl("/hes-gateway/manage/selectAlarmSnapshotList"), params)
	if err != nil {
		return nil, err
	}
	return response, nil
}

func QueryAlarmSnapshotInfo(sn, logTime string) ([]domain.AlarmSnapshotInfo, error) {
	var page int = 1
	var infoList []domain.AlarmSnapshotInfo

	for {
		// 查询告警快照数据
		alarmSnapshotRes, err := queryAlarmSnapshotInfo(sn, logTime, page)
		if err != nil {
			return nil, fmt.Errorf("[QueryAlarmSnapshotInfo] %s", err.Error())
		}

		if alarmSnapshotRes.Code != 200 {
			return nil, fmt.Errorf("[QueryAlarmSnapshotInfo] 查询失败 code: %d, message: %s", alarmSnapshotRes.Code, alarmSnapshotRes.Message)
		}

		if alarmSnapshotRes.Total > 10000 {
			return nil, fmt.Errorf("[QueryAlarmSnapshotInfo] 数据超过10000条")
		}

		infoList = append(infoList, *alarmSnapshotRes.Result...)

		if alarmSnapshotRes.Total <= uint64(page*int(REQ_PAGE_SIZE)) {
			break
		}

		page++
	}

	return infoList, nil
}