wx_service/internal/smoke/handler/smoke_handler.go

package handler

import (
	"errors"
	"io"
	"net/http"
	"strconv"
	"strings"
	"time"

	"github.com/gin-gonic/gin"

	"wx_service/internal/achievement"
	"wx_service/internal/middleware"
	"wx_service/internal/model"
	quitcheckinservice "wx_service/internal/quitcheckin/service"
	smokeservice "wx_service/internal/smoke/service"
)

type SmokeHandler struct {
	smokeLogService      *smokeservice.SmokeLogService
	smokeAIAdviceService *smokeservice.SmokeAIAdviceService
	smokeProfileService  *smokeservice.SmokeProfileService
	smokeNextService     *smokeservice.SmokeNextService
	smokeAINextService   *smokeservice.SmokeAINextSmokeService
	smokeShareService    *smokeservice.SmokeShareService
	achievementService   *achievement.Service
	quitCheckinService   *quitcheckinservice.Service
}

func NewSmokeHandler(
	smokeLogService *smokeservice.SmokeLogService,
	smokeAIAdviceService *smokeservice.SmokeAIAdviceService,
	smokeProfileService *smokeservice.SmokeProfileService,
	smokeNextService *smokeservice.SmokeNextService,
	smokeAINextService *smokeservice.SmokeAINextSmokeService,
	smokeShareService *smokeservice.SmokeShareService,
	achievementService *achievement.Service,
	quitCheckinService *quitcheckinservice.Service,
) *SmokeHandler {
	return &SmokeHandler{
		smokeLogService:      smokeLogService,
		smokeAIAdviceService: smokeAIAdviceService,
		smokeProfileService:  smokeProfileService,
		smokeNextService:     smokeNextService,
		smokeAINextService:   smokeAINextService,
		smokeShareService:    smokeShareService,
		achievementService:   achievementService,
		quitCheckinService:   quitCheckinService,
	}
}

// dateLayout 用于解析前端传入的日期字符串（例如：2025-12-31）
const dateLayout = "2006-01-02"
const dateTimeLayout = "2006-01-02 15:04:05"

type createSmokeLogRequest struct {
	// 只记录“日期”即可；如果不传，后端会按当天处理
	SmokeTime string `json:"smoke_time"`
	// 真实抽烟时间（精确到时分秒，可补录）
	SmokeAt string `json:"smoke_at"`
	Remark  string `json:"remark"`
	Level   *int64 `json:"level"`
	Num     *int   `json:"num"`
}

func (h *SmokeHandler) Create(c *gin.Context) {
	user := middleware.MustCurrentUser(c)

	var req createSmokeLogRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "请求参数错误"))
		return
	}

	level := int64(1)
	if req.Level != nil {
		if *req.Level < 0 {
			c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "level 不能为负数"))
			return
		}
		level = *req.Level
	}
	num := 1
	if req.Num != nil {
		if *req.Num < 0 {
			c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "num 不能为负数"))
			return
		}
		num = *req.Num
	}
	if num == 0 {
		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "num=0 请使用 /api/v1/smoke/logs/resisted"))
		return
	}

	if level < 0 || num < 0 {
		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "level/num 不能为负数"))
		return
	}

	var smokeTime *time.Time
	if req.SmokeTime != "" {
		parsed, err := time.ParseInLocation(dateLayout, req.SmokeTime, time.Local)
		if err != nil {
			c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "smoke_time 格式错误，应为 YYYY-MM-DD"))
			return
		}
		smokeTime = &parsed
	}

	var smokeAt *time.Time
	if req.SmokeAt != "" {
		parsed, err := time.ParseInLocation(dateTimeLayout, req.SmokeAt, time.Local)
		if err != nil {
			c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "smoke_at 格式错误，应为 YYYY-MM-DD HH:MM:SS"))
			return
		}
		smokeAt = &parsed
	}

	record, err := h.smokeLogService.Create(c.Request.Context(), int(user.ID), smokeservice.CreateSmokeLogRequest{
		SmokeTime: smokeTime,
		SmokeAt:   smokeAt,
		Remark:    req.Remark,
		Level:     level,
		Num:       num,
	})
	if err != nil {
		c.JSON(http.StatusInternalServerError, model.Error(http.StatusInternalServerError, "创建记录失败，请稍后重试"))
		return
	}

	c.JSON(http.StatusOK, model.Success(record))
}

type resistedSmokeLogRequest struct {
	SmokeTime string `json:"smoke_time"`
	SmokeAt   string `json:"smoke_at"`
	Remark    string `json:"remark"`
}

// Resist 表示“想抽但忍住了”：在 fa_smoke_log 中写入 level=0,num=0。
func (h *SmokeHandler) Resist(c *gin.Context) {
	user := middleware.MustCurrentUser(c)

	var req resistedSmokeLogRequest
	if err := c.ShouldBindJSON(&req); err != nil && !errors.Is(err, io.EOF) {
		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "请求参数错误"))
		return
	}

	var smokeTime *time.Time
	if req.SmokeTime != "" {
		parsed, err := time.ParseInLocation(dateLayout, req.SmokeTime, time.Local)
		if err != nil {
			c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "smoke_time 格式错误，应为 YYYY-MM-DD"))
			return
		}
		smokeTime = &parsed
	}

	var smokeAt *time.Time
	if req.SmokeAt != "" {
		parsed, err := time.ParseInLocation(dateTimeLayout, req.SmokeAt, time.Local)
		if err != nil {
			c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "smoke_at 格式错误，应为 YYYY-MM-DD HH:MM:SS"))
			return
		}
		smokeAt = &parsed
	}

	record, err := h.smokeLogService.Create(c.Request.Context(), int(user.ID), smokeservice.CreateSmokeLogRequest{
		SmokeTime: smokeTime,
		SmokeAt:   smokeAt,
		Remark:    req.Remark,
		Level:     0,
		Num:       0,
	})
	if err != nil {
		c.JSON(http.StatusInternalServerError, model.Error(http.StatusInternalServerError, "创建记录失败，请稍后重试"))
		return
	}

	c.JSON(http.StatusOK, model.Success(record))
}

func (h *SmokeHandler) Get(c *gin.Context) {
	user := middleware.MustCurrentUser(c)

	id, err := strconv.Atoi(c.Param("id"))
	if err != nil || id <= 0 {
		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "id 参数错误"))
		return
	}

	record, err := h.smokeLogService.GetByID(c.Request.Context(), int(user.ID), id)
	if err != nil {
		if errors.Is(err, smokeservice.ErrSmokeLogNotFound) {
			c.JSON(http.StatusNotFound, model.Error(http.StatusNotFound, "记录不存在"))
			return
		}
		c.JSON(http.StatusInternalServerError, model.Error(http.StatusInternalServerError, "查询失败，请稍后重试"))
		return
	}

	c.JSON(http.StatusOK, model.Success(record))
}

func (h *SmokeHandler) List(c *gin.Context) {
	user := middleware.MustCurrentUser(c)

	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "20"))
	listType := strings.ToLower(strings.TrimSpace(c.DefaultQuery("type", "all")))
	if listType != "all" && listType != "smoke" && listType != "resisted" {
		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "type 应为 all|smoke|resisted"))
		return
	}

	var start *time.Time
	if v := c.Query("start"); v != "" {
		parsed, err := time.ParseInLocation(dateLayout, v, time.Local)
		if err != nil {
			c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "start 格式错误，应为 YYYY-MM-DD"))
			return
		}
		start = &parsed
	}
	var end *time.Time
	if v := c.Query("end"); v != "" {
		parsed, err := time.ParseInLocation(dateLayout, v, time.Local)
		if err != nil {
			c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "end 格式错误，应为 YYYY-MM-DD"))
			return
		}
		end = &parsed
	}

	result, err := h.smokeLogService.List(c.Request.Context(), int(user.ID), smokeservice.ListSmokeLogsRequest{
		Page:     page,
		PageSize: pageSize,
		Start:    start,
		End:      end,
		Type:     listType,
	})
	if err != nil {
		c.JSON(http.StatusInternalServerError, model.Error(http.StatusInternalServerError, "查询列表失败，请稍后重试"))
		return
	}

	c.JSON(http.StatusOK, model.Success(gin.H{
		"items":     result.Items,
		"total":     result.Total,
		"page":      result.Page,
		"page_size": result.PageSize,
	}))
}

func (h *SmokeHandler) Dashboard(c *gin.Context) {
	user := middleware.MustCurrentUser(c)

	now := time.Now()
	defaultStart, defaultEnd := defaultDashboardRange(now)

	startDate := defaultStart
	startProvided := false
	if v := c.Query("start"); v != "" {
		parsed, err := time.ParseInLocation(dateLayout, v, time.Local)
		if err != nil {
			c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "start 格式错误，应为 YYYY-MM-DD"))
			return
		}
		startDate = parsed
		startProvided = true
	}

	endDate := defaultEnd
	if v := c.Query("end"); v != "" {
		parsed, err := time.ParseInLocation(dateLayout, v, time.Local)
		if err != nil {
			c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "end 格式错误，应为 YYYY-MM-DD"))
			return
		}
		endDate = parsed
	} else if startProvided {
		endDate = startDate.AddDate(0, 0, 6)
	}

	if endDate.Before(startDate) {
		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "end 不能早于 start"))
		return
	}

	result, err := h.smokeLogService.Dashboard(c.Request.Context(), int(user.ID), smokeservice.SmokeDashboardRequest{
		Start: startDate,
		End:   endDate,
	})
	if err != nil {
		c.JSON(http.StatusInternalServerError, model.Error(http.StatusInternalServerError, "获取看板概览失败，请稍后重试"))
		return
	}

	c.JSON(http.StatusOK, model.Success(result))
}

func (h *SmokeHandler) LatestLogs(c *gin.Context) {
	user := middleware.MustCurrentUser(c)

	limit, err := strconv.Atoi(c.DefaultQuery("limit", "20"))
	if err != nil {
		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "limit 应为数字"))
		return
	}
	if limit <= 0 {
		limit = 20
	}
	if limit > 100 {
		limit = 100
	}

	items, err := h.smokeLogService.ListLatest(c.Request.Context(), int(user.ID), limit)
	if err != nil {
		c.JSON(http.StatusInternalServerError, model.Error(http.StatusInternalServerError, "获取最近记录失败，请稍后重试"))
		return
	}

	c.JSON(http.StatusOK, model.Success(gin.H{
		"items": items,
	}))
}

type updateSmokeLogRequest struct {
	SmokeTime *string `json:"smoke_time"`
	SmokeAt   *string `json:"smoke_at"`
	Remark    *string `json:"remark"`
	Level     *int64  `json:"level"`
	Num       *int    `json:"num"`
}

func (h *SmokeHandler) Update(c *gin.Context) {
	user := middleware.MustCurrentUser(c)

	id, err := strconv.Atoi(c.Param("id"))
	if err != nil || id <= 0 {
		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "id 参数错误"))
		return
	}

	var req updateSmokeLogRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "请求参数错误"))
		return
	}

	if req.Level != nil && *req.Level < 0 {
		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "level 不能为负数"))
		return
	}
	if req.Num != nil && *req.Num < 0 {
		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "num 不能为负数"))
		return
	}

	smokeTimeProvided := req.SmokeTime != nil
	var smokeTime *time.Time
	if req.SmokeTime != nil {
		if *req.SmokeTime == "" {
			smokeTime = nil
		} else {
			parsed, err := time.ParseInLocation(dateLayout, *req.SmokeTime, time.Local)
			if err != nil {
				c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "smoke_time 格式错误，应为 YYYY-MM-DD"))
				return
			}
			smokeTime = &parsed
		}
	}

	smokeAtProvided := req.SmokeAt != nil
	var smokeAt *time.Time
	if req.SmokeAt != nil {
		if *req.SmokeAt == "" {
			smokeAt = nil
		} else {
			parsed, err := time.ParseInLocation(dateTimeLayout, *req.SmokeAt, time.Local)
			if err != nil {
				parsedRFC, errRFC := time.Parse(time.RFC3339, *req.SmokeAt)
				if errRFC != nil {
					c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "smoke_at 格式错误，应为 YYYY-MM-DD HH:MM:SS 或 RFC3339"))
					return
				}
				parsed = parsedRFC.In(time.Local)
			}
			smokeAt = &parsed
		}
	}

	record, err := h.smokeLogService.Update(c.Request.Context(), int(user.ID), id, smokeservice.UpdateSmokeLogRequest{
		SmokeTimeProvided: smokeTimeProvided,
		SmokeTime:         smokeTime,
		SmokeAtProvided:   smokeAtProvided,
		SmokeAt:           smokeAt,
		Remark:            req.Remark,
		Level:             req.Level,
		Num:               req.Num,
	})
	if err != nil {
		if errors.Is(err, smokeservice.ErrSmokeLogNotFound) {
			c.JSON(http.StatusNotFound, model.Error(http.StatusNotFound, "记录不存在"))
			return
		}
		c.JSON(http.StatusInternalServerError, model.Error(http.StatusInternalServerError, "更新失败，请稍后重试"))
		return
	}

	c.JSON(http.StatusOK, model.Success(record))
}

func (h *SmokeHandler) Delete(c *gin.Context) {
	user := middleware.MustCurrentUser(c)

	id, err := strconv.Atoi(c.Param("id"))
	if err != nil || id <= 0 {
		c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "id 参数错误"))
		return
	}

	if err := h.smokeLogService.Delete(c.Request.Context(), int(user.ID), id); err != nil {
		if errors.Is(err, smokeservice.ErrSmokeLogNotFound) {
			c.JSON(http.StatusNotFound, model.Error(http.StatusNotFound, "记录不存在"))
			return
		}
		c.JSON(http.StatusInternalServerError, model.Error(http.StatusInternalServerError, "删除失败，请稍后重试"))
		return
	}

	c.JSON(http.StatusOK, model.Success(gin.H{
		"deleted": true,
	}))
}

// defaultDashboardRange 返回“本周一到本周日”的日期范围，供看板默认使用。
func defaultDashboardRange(now time.Time) (time.Time, time.Time) {
	local := now.In(time.Local)
	weekday := local.Weekday()
	// 转为以周一为 0
	daysSinceMonday := int(weekday) - int(time.Monday)
	if daysSinceMonday < 0 {
		daysSinceMonday += 7
	}
	start := time.Date(local.Year(), local.Month(), local.Day(), 0, 0, 0, 0, time.Local).AddDate(0, 0, -daysSinceMonday)
	end := start.AddDate(0, 0, 6)
	return start, end
}