package alarm

import (
	"context"
	"errors"
	"strconv"

	"git.huangwc.com/pig/pig-farm-controller/internal/app/controller"
	"git.huangwc.com/pig/pig-farm-controller/internal/app/dto"
	"git.huangwc.com/pig/pig-farm-controller/internal/app/service"
	"git.huangwc.com/pig/pig-farm-controller/internal/infra/logs"
	"git.huangwc.com/pig/pig-farm-controller/internal/infra/repository"

	"github.com/labstack/echo/v4"
	"gorm.io/gorm"
)

// ThresholdAlarmController 阈值告警控制器，封装了所有与阈值告警配置相关的业务逻辑
type ThresholdAlarmController struct {
	ctx                   context.Context
	thresholdAlarmService service.ThresholdAlarmService
}

// NewThresholdAlarmController 创建一个新的阈值告警控制器实例
func NewThresholdAlarmController(
	ctx context.Context,
	thresholdAlarmService service.ThresholdAlarmService,
) *ThresholdAlarmController {
	return &ThresholdAlarmController{
		ctx:                   ctx,
		thresholdAlarmService: thresholdAlarmService,
	}
}

// SnoozeThresholdAlarm godoc
// @Summary      忽略阈值告警
// @Description  根据告警ID忽略一个活跃的阈值告警，或更新其忽略时间
// @Tags         告警管理
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        id path string true "告警ID"
// @Param        request body dto.SnoozeAlarmRequest true "忽略告警请求体"
// @Success      200 {object} controller.Response "成功忽略告警"
// @Router       /api/v1/alarm/threshold/{id}/snooze [post]
func (t *ThresholdAlarmController) SnoozeThresholdAlarm(ctx echo.Context) error {
	reqCtx, logger := logs.Trace(ctx.Request().Context(), t.ctx, "SnoozeThresholdAlarm")

	const actionType = "忽略阈值告警"
	alarmIDStr := ctx.Param("id")

	alarmID, err := strconv.ParseUint(alarmIDStr, 10, 64)
	if err != nil {
		logger.Errorf("%s: 无效的告警ID: %s", actionType, alarmIDStr)
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的告警ID: "+alarmIDStr, actionType, "无效的告警ID", alarmIDStr)
	}

	var req dto.SnoozeAlarmRequest
	if err := ctx.Bind(&req); err != nil {
		logger.Errorf("%s: 参数绑定失败: %v", actionType, err)
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的请求体: "+err.Error(), actionType, "请求体绑定失败", req)
	}

	if err := t.thresholdAlarmService.SnoozeThresholdAlarm(reqCtx, uint32(alarmID), req.DurationMinutes); err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			logger.Warnf("%s: 告警不存在, ID: %d", actionType, alarmID)
			return controller.SendErrorWithAudit(ctx, controller.CodeNotFound, "告警未找到", actionType, "告警不存在", alarmID)
		}
		logger.Errorf("%s: 服务层忽略告警失败: %v, ID: %d", actionType, err, alarmID)
		return controller.SendErrorWithAudit(ctx, controller.CodeInternalError, "忽略告警失败: "+err.Error(), actionType, "服务层忽略告警失败", alarmID)
	}

	logger.Infof("%s: 告警已成功忽略, ID: %d", actionType, alarmID)
	return controller.SendSuccessWithAudit(ctx, controller.CodeSuccess, "告警已成功忽略", nil, actionType, "告警已成功忽略", alarmID)
}

// CancelSnoozeThresholdAlarm godoc
// @Summary      取消忽略阈值告警
// @Description  根据告警ID取消对一个阈值告警的忽略状态
// @Tags         告警管理
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        id path string true "告警ID"
// @Success      200 {object} controller.Response "成功取消忽略告警"
// @Router       /api/v1/alarm/threshold/{id}/cancel-snooze [post]
func (t *ThresholdAlarmController) CancelSnoozeThresholdAlarm(ctx echo.Context) error {
	reqCtx, logger := logs.Trace(ctx.Request().Context(), t.ctx, "CancelSnoozeThresholdAlarm")

	const actionType = "取消忽略阈值告警"
	alarmIDStr := ctx.Param("id")

	alarmID, err := strconv.ParseUint(alarmIDStr, 10, 64)
	if err != nil {
		logger.Errorf("%s: 无效的告警ID: %s", actionType, alarmIDStr)
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的告警ID: "+alarmIDStr, actionType, "无效的告警ID", alarmIDStr)
	}

	if err := t.thresholdAlarmService.CancelSnoozeThresholdAlarm(reqCtx, uint32(alarmID)); err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			logger.Warnf("%s: 告警不存在, ID: %d", actionType, alarmID)
			return controller.SendErrorWithAudit(ctx, controller.CodeNotFound, "告警未找到", actionType, "告警不存在", alarmID)
		}
		logger.Errorf("%s: 服务层取消忽略告警失败: %v, ID: %d", actionType, err, alarmID)
		return controller.SendErrorWithAudit(ctx, controller.CodeInternalError, "取消忽略告警失败: "+err.Error(), actionType, "服务层取消忽略告警失败", alarmID)
	}

	logger.Infof("%s: 告警忽略状态已成功取消, ID: %d", actionType, alarmID)
	return controller.SendSuccessWithAudit(ctx, controller.CodeSuccess, "告警忽略状态已成功取消", nil, actionType, "告警忽略状态已成功取消", alarmID)
}

// ListActiveAlarms godoc
// @Summary      批量查询活跃告警
// @Description  根据过滤条件和分页参数查询活跃告警列表
// @Tags         告警管理
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        query query dto.ListActiveAlarmRequest true "查询参数"
// @Success      200 {object} controller.Response{data=dto.ListActiveAlarmResponse} "成功获取活跃告警列表"
// @Router       /api/v1/alarm/threshold/active-alarms [get]
func (t *ThresholdAlarmController) ListActiveAlarms(ctx echo.Context) error {
	reqCtx, logger := logs.Trace(ctx.Request().Context(), t.ctx, "ListActiveAlarms")

	const actionType = "批量查询活跃告警"
	var req dto.ListActiveAlarmRequest
	if err := ctx.Bind(&req); err != nil {
		logger.Errorf("%s: 参数绑定失败: %v", actionType, err)
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的请求参数: "+err.Error(), actionType, "请求参数绑定失败", nil)
	}

	resp, err := t.thresholdAlarmService.ListActiveAlarms(reqCtx, &req)
	if err != nil {
		// 捕获 ErrInvalidPagination 错误，并返回 Bad Request
		if errors.Is(err, repository.ErrInvalidPagination) {
			logger.Warnf("%s: 无效的分页参数: %v", actionType, err)
			return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的分页参数: "+err.Error(), actionType, "无效分页参数", req)
		}
		logger.Errorf("%s: 服务层查询活跃告警失败: %v", actionType, err)
		return controller.SendErrorWithAudit(ctx, controller.CodeInternalError, "查询活跃告警失败: "+err.Error(), actionType, "服务层查询活跃告警失败", req)
	}

	logger.Infof("%s: 成功, 获取到 %d 条记录, 总计 %d 条", actionType, len(resp.List), resp.Pagination.Total)
	return controller.SendSuccessWithAudit(ctx, controller.CodeSuccess, "成功获取活跃告警列表", resp, actionType, "成功获取活跃告警列表", req)
}

// ListHistoricalAlarms godoc
// @Summary      批量查询历史告警
// @Description  根据过滤条件和分页参数查询历史告警列表
// @Tags         告警管理
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        query query dto.ListHistoricalAlarmRequest true "查询参数"
// @Success      200 {object} controller.Response{data=dto.ListHistoricalAlarmResponse} "成功获取历史告警列表"
// @Router       /api/v1/alarm/threshold/historical-alarms [get]
func (t *ThresholdAlarmController) ListHistoricalAlarms(ctx echo.Context) error {
	reqCtx, logger := logs.Trace(ctx.Request().Context(), t.ctx, "ListHistoricalAlarms")

	const actionType = "批量查询历史告警"
	var req dto.ListHistoricalAlarmRequest
	if err := ctx.Bind(&req); err != nil {
		logger.Errorf("%s: 参数绑定失败: %v", actionType, err)
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的请求参数: "+err.Error(), actionType, "请求参数绑定失败", nil)
	}

	resp, err := t.thresholdAlarmService.ListHistoricalAlarms(reqCtx, &req)
	if err != nil {
		// 捕获 ErrInvalidPagination 错误，并返回 Bad Request
		if errors.Is(err, repository.ErrInvalidPagination) {
			logger.Warnf("%s: 无效的分页参数: %v", actionType, err)
			return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的分页参数: "+err.Error(), actionType, "无效分页参数", req)
		}
		logger.Errorf("%s: 服务层查询历史告警失败: %v", actionType, err)
		return controller.SendErrorWithAudit(ctx, controller.CodeInternalError, "查询历史告警失败: "+err.Error(), actionType, "服务层查询历史告警失败", req)
	}

	logger.Infof("%s: 成功, 获取到 %d 条记录, 总计 %d 条", actionType, len(resp.List), resp.Pagination.Total)
	return controller.SendSuccessWithAudit(ctx, controller.CodeSuccess, "成功获取历史告警列表", resp, actionType, "成功获取历史告警列表", req)
}

// ListDeviceThresholdAlarms godoc
// @Summary      批量查询设备阈值告警
// @Description  根据过滤条件和分页参数查询设备阈值告警列表
// @Tags         告警管理
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        query query dto.ListDeviceThresholdAlarmRequest true "查询参数"
// @Success      200 {object} controller.Response{data=dto.ListDeviceThresholdAlarmResponse} "成功获取设备阈值告警列表"
// @Router       /api/v1/alarm/threshold/device [get]
func (t *ThresholdAlarmController) ListDeviceThresholdAlarms(ctx echo.Context) error {
	reqCtx, logger := logs.Trace(ctx.Request().Context(), t.ctx, "ListDeviceThresholdAlarms")

	const actionType = "批量查询设备阈值告警"
	var req dto.ListDeviceThresholdAlarmRequest
	if err := ctx.Bind(&req); err != nil {
		logger.Errorf("%s: 参数绑定失败: %v", actionType, err)
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的请求参数: "+err.Error(), actionType, "请求参数绑定失败", nil)
	}

	resp, err := t.thresholdAlarmService.ListDeviceThresholdAlarms(reqCtx, &req)
	if err != nil {
		// 捕获 ErrInvalidPagination 错误，并返回 Bad Request
		if errors.Is(err, repository.ErrInvalidPagination) {
			logger.Warnf("%s: 无效的分页参数: %v", actionType, err)
			return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的分页参数: "+err.Error(), actionType, "无效分页参数", req)
		}
		logger.Errorf("%s: 服务层查询设备阈值告警失败: %v", actionType, err)
		return controller.SendErrorWithAudit(ctx, controller.CodeInternalError, "查询设备阈值告警失败: "+err.Error(), actionType, "服务层查询设备阈值告警失败", req)
	}

	logger.Infof("%s: 成功, 获取到 %d 条记录, 总计 %d 条", actionType, len(resp.List), resp.Pagination.Total)
	return controller.SendSuccessWithAudit(ctx, controller.CodeSuccess, "成功获取设备阈值告警列表", resp, actionType, "成功获取设备阈值告警列表", req)
}

// ListAreaThresholdAlarms godoc
// @Summary      批量查询区域阈值告警
// @Description  根据过滤条件和分页参数查询区域阈值告警列表
// @Tags         告警管理
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        query query dto.ListAreaThresholdAlarmRequest true "查询参数"
// @Success      200 {object} controller.Response{data=dto.ListAreaThresholdAlarmResponse} "成功获取区域阈值告警列表"
// @Router       /api/v1/alarm/threshold/area [get]
func (t *ThresholdAlarmController) ListAreaThresholdAlarms(ctx echo.Context) error {
	reqCtx, logger := logs.Trace(ctx.Request().Context(), t.ctx, "ListAreaThresholdAlarms")

	const actionType = "批量查询区域阈值告警"
	var req dto.ListAreaThresholdAlarmRequest
	if err := ctx.Bind(&req); err != nil {
		logger.Errorf("%s: 参数绑定失败: %v", actionType, err)
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的请求参数: "+err.Error(), actionType, "请求参数绑定失败", nil)
	}

	resp, err := t.thresholdAlarmService.ListAreaThresholdAlarms(reqCtx, &req)
	if err != nil {
		// 捕获 ErrInvalidPagination 错误，并返回 Bad Request
		if errors.Is(err, repository.ErrInvalidPagination) {
			logger.Warnf("%s: 无效的分页参数: %v", actionType, err)
			return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的分页参数: "+err.Error(), actionType, "无效分页参数", req)
		}
		logger.Errorf("%s: 服务层查询区域阈值告警失败: %v", actionType, err)
		return controller.SendErrorWithAudit(ctx, controller.CodeInternalError, "查询区域阈值告警失败: "+err.Error(), actionType, "服务层查询区域阈值告警失败", req)
	}

	logger.Infof("%s: 成功, 获取到 %d 条记录, 总计 %d 条", actionType, len(resp.List), resp.Pagination.Total)
	return controller.SendSuccessWithAudit(ctx, controller.CodeSuccess, "成功获取区域阈值告警列表", resp, actionType, "成功获取区域阈值告警列表", req)
}

// CreateDeviceThresholdAlarm godoc
// @Summary      创建设备阈值告警
// @Description  为单个设备创建一条新的阈值告警规则
// @Tags         告警管理
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        request body dto.CreateDeviceThresholdAlarmDTO true "创建设备阈值告警请求体"
// @Success      200 {object} controller.Response "成功创建设备阈值告警"
// @Router       /api/v1/alarm/threshold/device [post]
func (t *ThresholdAlarmController) CreateDeviceThresholdAlarm(ctx echo.Context) error {
	reqCtx, logger := logs.Trace(ctx.Request().Context(), t.ctx, "CreateDeviceThresholdAlarm")
	const actionType = "创建设备阈值告警"

	var req dto.CreateDeviceThresholdAlarmDTO
	if err := ctx.Bind(&req); err != nil {
		logger.Errorf("%s: 参数绑定失败: %v", actionType, err)
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的请求体: "+err.Error(), actionType, "请求体绑定失败", req)
	}

	if err := t.thresholdAlarmService.CreateDeviceThresholdAlarm(reqCtx, &req); err != nil {
		logger.Errorf("%s: 服务层创建失败: %v", actionType, err)
		return controller.SendErrorWithAudit(ctx, controller.CodeInternalError, "创建失败: "+err.Error(), actionType, "服务层创建失败", req)
	}

	logger.Infof("%s: 成功, DeviceID: %d, SensorType: %s", actionType, req.DeviceID, req.SensorType)
	return controller.SendSuccessWithAudit(ctx, controller.CodeSuccess, "创建成功", nil, actionType, "创建成功", req)
}

// GetDeviceThresholdAlarm godoc
// @Summary      获取设备阈值告警
// @Description  根据任务ID获取单个设备阈值告警规则的详细信息
// @Tags         告警管理
// @Security     BearerAuth
// @Produce      json
// @Param        task_id path int true "任务ID"
// @Success      200 {object} controller.Response{data=dto.DeviceThresholdAlarmDTO} "成功获取设备阈值告警"
// @Router       /api/v1/alarm/threshold/device/{task_id} [get]
func (t *ThresholdAlarmController) GetDeviceThresholdAlarm(ctx echo.Context) error {
	reqCtx, logger := logs.Trace(ctx.Request().Context(), t.ctx, "GetDeviceThresholdAlarm")
	const actionType = "获取设备阈值告警"

	taskID, err := strconv.Atoi(ctx.Param("task_id"))
	if err != nil {
		logger.Errorf("%s: 无效的任务ID: %s", actionType, ctx.Param("task_id"))
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的任务ID", actionType, "无效的任务ID", ctx.Param("task_id"))
	}

	resp, err := t.thresholdAlarmService.GetDeviceThresholdAlarm(reqCtx, taskID)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			logger.Warnf("%s: 任务不存在, ID: %d", actionType, taskID)
			return controller.SendErrorWithAudit(ctx, controller.CodeNotFound, "任务未找到", actionType, "任务不存在", taskID)
		}
		logger.Errorf("%s: 服务层获取失败: %v, ID: %d", actionType, err, taskID)
		return controller.SendErrorWithAudit(ctx, controller.CodeInternalError, "获取失败: "+err.Error(), actionType, "服务层获取失败", taskID)
	}

	logger.Infof("%s: 成功, ID: %d", actionType, taskID)
	return controller.SendSuccessWithAudit(ctx, controller.CodeSuccess, "获取成功", resp, actionType, "获取成功", taskID)
}

// UpdateDeviceThresholdAlarm godoc
// @Summary      更新设备阈值告警
// @Description  根据任务ID更新已存在的设备阈值告警规则
// @Tags         告警管理
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        task_id path int true "任务ID"
// @Param        request body dto.UpdateDeviceThresholdAlarmDTO true "更新设备阈值告警请求体"
// @Success      200 {object} controller.Response "成功更新设备阈值告警"
// @Router       /api/v1/alarm/threshold/device/{task_id} [put]
func (t *ThresholdAlarmController) UpdateDeviceThresholdAlarm(ctx echo.Context) error {
	reqCtx, logger := logs.Trace(ctx.Request().Context(), t.ctx, "UpdateDeviceThresholdAlarm")
	const actionType = "更新设备阈值告警"

	taskID, err := strconv.Atoi(ctx.Param("task_id"))
	if err != nil {
		logger.Errorf("%s: 无效的任务ID: %s", actionType, ctx.Param("task_id"))
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的任务ID", actionType, "无效的任务ID", ctx.Param("task_id"))
	}

	var req dto.UpdateDeviceThresholdAlarmDTO
	if err := ctx.Bind(&req); err != nil {
		logger.Errorf("%s: 参数绑定失败: %v", actionType, err)
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的请求体: "+err.Error(), actionType, "请求体绑定失败", req)
	}

	if err := t.thresholdAlarmService.UpdateDeviceThresholdAlarm(reqCtx, taskID, &req); err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			logger.Warnf("%s: 任务不存在, ID: %d", actionType, taskID)
			return controller.SendErrorWithAudit(ctx, controller.CodeNotFound, "任务未找到", actionType, "任务不存在", taskID)
		}
		logger.Errorf("%s: 服务层更新失败: %v, ID: %d", actionType, err, taskID)
		return controller.SendErrorWithAudit(ctx, controller.CodeInternalError, "更新失败: "+err.Error(), actionType, "服务层更新失败", taskID)
	}

	logger.Infof("%s: 成功, ID: %d", actionType, taskID)
	return controller.SendSuccessWithAudit(ctx, controller.CodeSuccess, "更新成功", nil, actionType, "更新成功", taskID)
}

// DeleteDeviceThresholdAlarm godoc
// @Summary      删除设备阈值告警
// @Description  根据任务ID删除设备阈值告警规则
// @Tags         告警管理
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        task_id path int true "任务ID"
// @Param        request body dto.DeleteDeviceThresholdAlarmDTO true "删除设备阈值告警请求体"
// @Success      200 {object} controller.Response "成功删除设备阈值告警"
// @Router       /api/v1/alarm/threshold/device/{task_id} [delete]
func (t *ThresholdAlarmController) DeleteDeviceThresholdAlarm(ctx echo.Context) error {
	reqCtx, logger := logs.Trace(ctx.Request().Context(), t.ctx, "DeleteDeviceThresholdAlarm")
	const actionType = "删除设备阈值告警"

	taskID, err := strconv.Atoi(ctx.Param("task_id"))
	if err != nil {
		logger.Errorf("%s: 无效的任务ID: %s", actionType, ctx.Param("task_id"))
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的任务ID", actionType, "无效的任务ID", ctx.Param("task_id"))
	}

	var req dto.DeleteDeviceThresholdAlarmDTO
	if err := ctx.Bind(&req); err != nil {
		logger.Errorf("%s: 参数绑定失败: %v", actionType, err)
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的请求体: "+err.Error(), actionType, "请求体绑定失败", req)
	}

	if err := t.thresholdAlarmService.DeleteDeviceThresholdAlarm(reqCtx, taskID, &req); err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			logger.Warnf("%s: 任务不存在, ID: %d", actionType, taskID)
			return controller.SendErrorWithAudit(ctx, controller.CodeNotFound, "任务未找到", actionType, "任务不存在", taskID)
		}
		logger.Errorf("%s: 服务层删除失败: %v, ID: %d", actionType, err, taskID)
		return controller.SendErrorWithAudit(ctx, controller.CodeInternalError, "删除失败: "+err.Error(), actionType, "服务层删除失败", taskID)
	}

	logger.Infof("%s: 成功, ID: %d", actionType, taskID)
	return controller.SendSuccessWithAudit(ctx, controller.CodeSuccess, "删除成功", nil, actionType, "删除成功", taskID)
}

// CreateAreaThresholdAlarm godoc
// @Summary      创建区域阈值告警
// @Description  为指定的区域主控创建一个新的阈值告警规则
// @Tags         告警管理
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        request body dto.CreateAreaThresholdAlarmDTO true "创建区域阈值告警请求体"
// @Success      200 {object} controller.Response "成功创建区域阈值告警"
// @Router       /api/v1/alarm/threshold/area [post]
func (t *ThresholdAlarmController) CreateAreaThresholdAlarm(ctx echo.Context) error {
	reqCtx, logger := logs.Trace(ctx.Request().Context(), t.ctx, "CreateAreaThresholdAlarm")
	const actionType = "创建区域阈值告警"

	var req dto.CreateAreaThresholdAlarmDTO
	if err := ctx.Bind(&req); err != nil {
		logger.Errorf("%s: 参数绑定失败: %v", actionType, err)
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的请求体: "+err.Error(), actionType, "请求体绑定失败", req)
	}

	if err := t.thresholdAlarmService.CreateAreaThresholdAlarm(reqCtx, &req); err != nil {
		logger.Errorf("%s: 服务层创建失败: %v", actionType, err)
		return controller.SendErrorWithAudit(ctx, controller.CodeInternalError, "创建失败: "+err.Error(), actionType, "服务层创建失败", req)
	}

	logger.Infof("%s: 成功, AreaControllerID: %d, SensorType: %s", actionType, req.AreaControllerID, req.SensorType)
	return controller.SendSuccessWithAudit(ctx, controller.CodeSuccess, "创建成功", nil, actionType, "创建成功", req)
}

// GetAreaThresholdAlarm godoc
// @Summary      获取区域阈值告警
// @Description  根据任务ID获取单个区域阈值告警规则的详细信息
// @Tags         告警管理
// @Security     BearerAuth
// @Produce      json
// @Param        task_id path int true "任务ID"
// @Success      200 {object} controller.Response{data=dto.AreaThresholdAlarmDTO} "成功获取区域阈值告警"
// @Router       /api/v1/alarm/threshold/area/{task_id} [get]
func (t *ThresholdAlarmController) GetAreaThresholdAlarm(ctx echo.Context) error {
	reqCtx, logger := logs.Trace(ctx.Request().Context(), t.ctx, "GetAreaThresholdAlarm")
	const actionType = "获取区域阈值告警"

	taskID, err := strconv.Atoi(ctx.Param("task_id"))
	if err != nil {
		logger.Errorf("%s: 无效的任务ID: %s", actionType, ctx.Param("task_id"))
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的任务ID", actionType, "无效的任务ID", ctx.Param("task_id"))
	}

	resp, err := t.thresholdAlarmService.GetAreaThresholdAlarm(reqCtx, taskID)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			logger.Warnf("%s: 任务不存在, ID: %d", actionType, taskID)
			return controller.SendErrorWithAudit(ctx, controller.CodeNotFound, "任务未找到", actionType, "任务不存在", taskID)
		}
		logger.Errorf("%s: 服务层获取失败: %v, ID: %d", actionType, err, taskID)
		return controller.SendErrorWithAudit(ctx, controller.CodeInternalError, "获取失败: "+err.Error(), actionType, "服务层获取失败", taskID)
	}

	logger.Infof("%s: 成功, ID: %d", actionType, taskID)
	return controller.SendSuccessWithAudit(ctx, controller.CodeSuccess, "获取成功", resp, actionType, "获取成功", taskID)
}

// UpdateAreaThresholdAlarm godoc
// @Summary      更新区域阈值告警
// @Description  根据任务ID更新已存在的区域阈值告警规则
// @Tags         告警管理
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        task_id path int true "任务ID"
// @Param        request body dto.UpdateAreaThresholdAlarmDTO true "更新区域阈值告警请求体"
// @Success      200 {object} controller.Response "成功更新区域阈值告警"
// @Router       /api/v1/alarm/threshold/area/{task_id} [put]
func (t *ThresholdAlarmController) UpdateAreaThresholdAlarm(ctx echo.Context) error {
	reqCtx, logger := logs.Trace(ctx.Request().Context(), t.ctx, "UpdateAreaThresholdAlarm")
	const actionType = "更新区域阈值告警"

	taskID, err := strconv.Atoi(ctx.Param("task_id"))
	if err != nil {
		logger.Errorf("%s: 无效的任务ID: %s", actionType, ctx.Param("task_id"))
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的任务ID", actionType, "无效的任务ID", ctx.Param("task_id"))
	}

	var req dto.UpdateAreaThresholdAlarmDTO
	if err := ctx.Bind(&req); err != nil {
		logger.Errorf("%s: 参数绑定失败: %v", actionType, err)
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的请求体: "+err.Error(), actionType, "请求体绑定失败", req)
	}

	if err := t.thresholdAlarmService.UpdateAreaThresholdAlarm(reqCtx, taskID, &req); err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			logger.Warnf("%s: 任务不存在, ID: %d", actionType, taskID)
			return controller.SendErrorWithAudit(ctx, controller.CodeNotFound, "任务未找到", actionType, "任务不存在", taskID)
		}
		logger.Errorf("%s: 服务层更新失败: %v, ID: %d", actionType, err, taskID)
		return controller.SendErrorWithAudit(ctx, controller.CodeInternalError, "更新失败: "+err.Error(), actionType, "服务层更新失败", taskID)
	}

	logger.Infof("%s: 成功, ID: %d", actionType, taskID)
	return controller.SendSuccessWithAudit(ctx, controller.CodeSuccess, "更新成功", nil, actionType, "更新成功", taskID)
}

// DeleteAreaThresholdAlarm godoc
// @Summary      删除区域阈值告警
// @Description  根据任务ID删除区域阈值告警规则
// @Tags         告警管理
// @Security     BearerAuth
// @Produce      json
// @Param        task_id path int true "任务ID"
// @Success      200 {object} controller.Response "成功删除区域阈值告警"
// @Router       /api/v1/alarm/threshold/area/{task_id} [delete]
func (t *ThresholdAlarmController) DeleteAreaThresholdAlarm(ctx echo.Context) error {
	reqCtx, logger := logs.Trace(ctx.Request().Context(), t.ctx, "DeleteAreaThresholdAlarm")
	const actionType = "删除区域阈值告警"

	taskID, err := strconv.Atoi(ctx.Param("task_id"))
	if err != nil {
		logger.Errorf("%s: 无效的任务ID: %s", actionType, ctx.Param("task_id"))
		return controller.SendErrorWithAudit(ctx, controller.CodeBadRequest, "无效的任务ID", actionType, "无效的任务ID", ctx.Param("task_id"))
	}

	if err := t.thresholdAlarmService.DeleteAreaThresholdAlarm(reqCtx, taskID); err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			logger.Warnf("%s: 任务不存在, ID: %d", actionType, taskID)
			return controller.SendErrorWithAudit(ctx, controller.CodeNotFound, "任务未找到", actionType, "任务不存在", taskID)
		}
		logger.Errorf("%s: 服务层删除失败: %v, ID: %d", actionType, err, taskID)
		return controller.SendErrorWithAudit(ctx, controller.CodeInternalError, "删除失败: "+err.Error(), actionType, "服务层删除失败", taskID)
	}

	logger.Infof("%s: 成功, ID: %d", actionType, taskID)
	return controller.SendSuccessWithAudit(ctx, controller.CodeSuccess, "删除成功", nil, actionType, "删除成功", taskID)
}
