app-api/internal/handler/share_code.go

package handler

import (
	"encoding/json"
	"net/http"
	"strings"

	"github.com/gin-gonic/gin"
	"github.com/luxsin/app-api/internal/cache"
	"github.com/luxsin/app-api/internal/model"
	"github.com/luxsin/app-api/pkg/encode"
	"go.uber.org/zap"
)

type ShareCodeHandler struct {
	cache     *cache.ShareCodeCache
	log       *zap.Logger
	maxPerMac int
}

func NewShareCodeHandler(shareCache *cache.ShareCodeCache, log *zap.Logger, maxPerMac int) *ShareCodeHandler {
	return &ShareCodeHandler{cache: shareCache, log: log, maxPerMac: maxPerMac}
}

// ExportShareCode 导出分享码
//
//	@Summary		创建 EQ 分享码
//	@Description	将用户的 EQ 数据生成一个 5 位分享码，有效期由 SHARE_CODE_TTL_MIN 配置决定（支持 30、30m、24h、30d 等格式）
//	@Tags			ShareCode
//	@Accept			json
//	@Produce		json
//	@Param			body	body		object{mac=string,model=string,eq_data=object}	true	"分享请求，model 取值 Luxsin-X9 或 Luxsin-X8"
//	@Success		200		{object}	map[string]any						"成功返回 share_code、expire_at、eq_data"
//	@Failure		400		{object}	map[string]any						"参数校验失败"
//	@Failure		500		{object}	map[string]any						"系统错误"
//	@Router			/audio/shareCreate [post]
//
// POST /audio/shareCreate
// Body: {"mac": "xx", "model": "Luxsin-X9", "eq_data": {...}}
func (h *ShareCodeHandler) ExportShareCode(c *gin.Context) {
	var req struct {
		Mac    string          `json:"mac"`
		Model  string          `json:"model"`
		EqData json.RawMessage `json:"eq_data"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusOK, gin.H{
			"code": 400,
			"msg":  "参数校验失败",
		})
		return
	}

	mac := strings.TrimSpace(req.Mac)
	deviceModel := strings.TrimSpace(req.Model)
	eqDataRaw := strings.TrimSpace(string(req.EqData))
	clientIP := encode.ClientPublicIP(c)

	if mac == "" || deviceModel == "" || eqDataRaw == "" {
		c.JSON(http.StatusOK, gin.H{
			"code": 400,
			"msg":  "参数校验失败",
		})
		return
	}

	if !model.IsValidShareDeviceModel(deviceModel) {
		c.JSON(http.StatusOK, gin.H{
			"code": 400,
			"msg":  "model 参数无效",
		})
		return
	}

	if !json.Valid([]byte(eqDataRaw)) {
		c.JSON(http.StatusOK, gin.H{
			"code": 400,
			"msg":  "eq_data 格式错误",
		})
		return
	}

	ctx := c.Request.Context()

	// 限制同一 MAC 在有效期内的分享码数量
	existing, err := h.cache.ListByMac(ctx, mac)
	if err != nil {
		h.log.Error("check existing share codes by mac failed", zap.String("mac", mac), zap.Error(err))
		c.JSON(http.StatusOK, gin.H{
			"code": 500,
			"msg":  "系统错误",
		})
		return
	}
	if len(existing) >= h.maxPerMac {
		c.JSON(http.StatusOK, gin.H{
			"code": 0,
			"msg":  "已有未过期的分享码，请稍后再试",
		})
		return
	}

	data, err := h.cache.Create(ctx, mac, clientIP, deviceModel, []byte(eqDataRaw))
	if err != nil {
		h.log.Error("create share code failed", zap.Error(err))
		c.JSON(http.StatusOK, gin.H{
			"code": 500,
			"msg":  "系统错误",
		})
		return
	}

	var eqData any
	if err := json.Unmarshal([]byte(data.EqData), &eqData); err != nil {
		eqData = data.EqData
	}

	c.JSON(http.StatusOK, gin.H{
		"code":       200,
		"msg":        "操作成功",
		"share_code": data.ShareCode,
		"expire_at":  data.ExpireAt.Format("2006-01-02 15:04:05"),
		"eq_data":    eqData,
	})
}

// ListShareCodesByMac 查询某 MAC 尚未过期的分享码
//
//	@Summary		查询未过期分享码
//	@Description	根据设备 MAC 地址查询该设备尚未过期的所有分享码（仅查询 Redis，依赖 TTL 自动过期）
//	@Tags			ShareCode
//	@Produce		json
//	@Param			mac	query		string			true	"设备 MAC 地址"
//	@Success		200	{object}	map[string]any	"成功返回 share_codes 列表"
//	@Failure		400	{object}	map[string]any	"参数校验失败"
//	@Failure		500	{object}	map[string]any	"系统错误"
//	@Router			/audio/shareList [get]
func (h *ShareCodeHandler) ListShareCodesByMac(c *gin.Context) {
	mac := strings.TrimSpace(c.Query("mac"))
	if mac == "" {
		c.JSON(http.StatusOK, gin.H{"code": 400, "msg": "参数校验失败"})
		return
	}

	ctx := c.Request.Context()

	items, err := h.cache.ListByMac(ctx, mac)
	if err != nil {
		h.log.Error("list share codes by mac failed", zap.String("mac", mac), zap.Error(err))
		c.JSON(http.StatusOK, gin.H{"code": 500, "msg": "系统错误"})
		return
	}

	type shareItem struct {
		ShareCode string `json:"share_code"`
		ExpireAt  string `json:"expire_at"`
		EqData    any    `json:"eq_data"`
	}
	list := make([]shareItem, 0, len(items))
	for _, item := range items {
		var eqData any
		if err := json.Unmarshal([]byte(item.EqData), &eqData); err != nil {
			eqData = item.EqData
		}
		list = append(list, shareItem{
			ShareCode: item.ShareCode,
			ExpireAt:  item.ExpireAt.Format("2006-01-02 15:04:05"),
			EqData:    eqData,
		})
	}

	c.JSON(http.StatusOK, gin.H{
		"code":        200,
		"msg":         "操作成功",
		"share_codes": list,
	})
}

// QueryShareCode 查询分享码（预览，不记录导入）
//
//	@Summary		查询 EQ 分享码
//	@Description	根据分享码预览 EQ 数据，不写入导入流水
//	@Tags			ShareCode
//	@Produce		json
//	@Param			shareCode	query		string			true	"5 位分享码"
//	@Success		200			{object}	map[string]any	"成功返回 eq_data、expire_at、model"
//	@Failure		400			{object}	map[string]any	"参数校验失败"
//	@Failure		500			{object}	map[string]any	"系统错误"
//	@Router			/audio/shareQuery [get]
//
// GET /audio/shareQuery?shareCode=ABC12
func (h *ShareCodeHandler) QueryShareCode(c *gin.Context) {
	shareCode := strings.TrimSpace(c.Query("shareCode"))
	data, ok := h.lookupShareCode(c, shareCode)
	if !ok {
		return
	}

	var eqData any
	if err := json.Unmarshal([]byte(data.EqData), &eqData); err != nil {
		eqData = data.EqData
	}

	c.JSON(http.StatusOK, gin.H{
		"code":      200,
		"msg":       "操作成功",
		"eq_data":   eqData,
		"expire_at": data.ExpireAt.Format("2006-01-02 15:04:05"),
		"model":     data.Model,
	})
}

// ImportShareCode 导入分享码
//
//	@Summary		导入 EQ 分享码
//	@Description	根据分享码获取他人分享的 EQ 数据
//	@Tags			ShareCode
//	@Produce		json
//	@Param			mac			query		string			true	"设备 MAC 地址"
//	@Param			model		query		string			true	"操作设备型号，取值 Luxsin-X9 或 Luxsin-X8"
//	@Param			shareCode	query		string			true	"5 位分享码"
//	@Success		200			{object}	map[string]any	"成功返回 eq_data、model"
//	@Failure		400			{object}	map[string]any	"参数校验失败"
//	@Failure		500			{object}	map[string]any	"系统错误"
//	@Router			/audio/shareAccept [get]
//
// GET /audio/shareAccept?mac=xx&model=Luxsin-X9&shareCode=ABC12
func (h *ShareCodeHandler) ImportShareCode(c *gin.Context) {
	mac := strings.TrimSpace(c.Query("mac"))
	deviceModel := strings.TrimSpace(c.Query("model"))
	shareCode := strings.TrimSpace(c.Query("shareCode"))
	clientIP := encode.ClientPublicIP(c)

	if mac == "" || deviceModel == "" || shareCode == "" {
		c.JSON(http.StatusOK, gin.H{
			"code": 400,
			"msg":  "参数校验失败",
		})
		return
	}

	if !model.IsValidShareDeviceModel(deviceModel) {
		c.JSON(http.StatusOK, gin.H{
			"code": 400,
			"msg":  "model 参数无效",
		})
		return
	}

	data, ok := h.lookupShareCode(c, shareCode)
	if !ok {
		return
	}

	ctx := c.Request.Context()
	if err := h.cache.EnqueueImportLog(ctx, mac, shareCode, deviceModel, clientIP, data.EqData, data.ExpireAt); err != nil {
		h.log.Error("enqueue share import log failed",
			zap.String("share_code", shareCode),
			zap.Error(err),
		)
		c.JSON(http.StatusOK, gin.H{
			"code": 500,
			"msg":  "系统错误",
		})
		return
	}

	var eqData any
	if err := json.Unmarshal([]byte(data.EqData), &eqData); err != nil {
		eqData = data.EqData
	}

	c.JSON(http.StatusOK, gin.H{
		"code":    200,
		"msg":     "操作成功",
		"eq_data": eqData,
		"model":   data.Model,
	})
}

func (h *ShareCodeHandler) lookupShareCode(c *gin.Context, shareCode string) (*cache.ShareCodeData, bool) {
	if shareCode == "" {
		c.JSON(http.StatusOK, gin.H{
			"code": 400,
			"msg":  "参数校验失败",
		})
		return nil, false
	}
	if len(shareCode) != 5 {
		c.JSON(http.StatusOK, gin.H{
			"code": 0,
			"msg":  "分享码无效或已过期",
		})
		return nil, false
	}

	ctx := c.Request.Context()
	data, err := h.cache.Get(ctx, shareCode)
	if err != nil {
		h.log.Error("get share code failed", zap.String("share_code", shareCode), zap.Error(err))
		c.JSON(http.StatusOK, gin.H{
			"code": 500,
			"msg":  "系统错误",
		})
		return nil, false
	}
	if data == nil {
		c.JSON(http.StatusOK, gin.H{
			"code": 0,
			"msg":  "分享码无效或已过期",
		})
		return nil, false
	}
	return data, true
}

// DeleteShareCode 删除分享码
//
//	@Summary		删除 EQ 分享码
//	@Description	根据 MAC 与分享码删除 Redis 中的分享码数据（仅创建者可删除）
//	@Tags			ShareCode
//	@Produce		json
//	@Param			mac			query		string			true	"设备 MAC 地址"
//	@Param			shareCode	query		string			true	"5 位分享码"
//	@Success		200			{object}	map[string]any	"删除成功"
//	@Failure		400			{object}	map[string]any	"参数校验失败"
//	@Failure		500			{object}	map[string]any	"系统错误"
//	@Router			/audio/shareDelete [get]
//
// GET /audio/shareDelete?mac=xx&shareCode=ABC12
func (h *ShareCodeHandler) DeleteShareCode(c *gin.Context) {
	mac := strings.TrimSpace(c.Query("mac"))
	shareCode := strings.TrimSpace(c.Query("shareCode"))

	if mac == "" || shareCode == "" {
		c.JSON(http.StatusOK, gin.H{
			"code": 400,
			"msg":  "参数校验失败",
		})
		return
	}
	if len(shareCode) != 5 {
		c.JSON(http.StatusOK, gin.H{
			"code": 0,
			"msg":  "分享码无效或已过期",
		})
		return
	}

	ctx := c.Request.Context()
	result, err := h.cache.Delete(ctx, mac, shareCode)
	if err != nil {
		h.log.Error("delete share code failed",
			zap.String("mac", mac),
			zap.String("share_code", shareCode),
			zap.Error(err),
		)
		c.JSON(http.StatusOK, gin.H{
			"code": 500,
			"msg":  "系统错误",
		})
		return
	}

	switch result {
	case cache.ShareDeleteOK:
		c.JSON(http.StatusOK, gin.H{
			"code": 200,
			"msg":  "操作成功",
		})
	case cache.ShareDeleteForbidden:
		c.JSON(http.StatusOK, gin.H{
			"code": 0,
			"msg":  "无权删除该分享码",
		})
	default:
		c.JSON(http.StatusOK, gin.H{
			"code": 0,
			"msg":  "分享码无效或已过期",
		})
	}
}