package handler

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

	"github.com/gin-gonic/gin"

	"wx_service/internal/middleware"
	"wx_service/internal/model"
	smokeservice "wx_service/internal/smoke/service"
)

type SmokeHandler struct {
	smokeLogService      *smokeservice.SmokeLogService
	smokeAIAdviceService *smokeservice.SmokeAIAdviceService
}

func NewSmokeHandler(smokeLogService *smokeservice.SmokeLogService, smokeAIAdviceService *smokeservice.SmokeAIAdviceService) *SmokeHandler {
	return &SmokeHandler{
		smokeLogService:      smokeLogService,
		smokeAIAdviceService: smokeAIAdviceService,
	}
}

// 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, ok := middleware.CurrentUser(c)
	if !ok {
		c.JSON(http.StatusUnauthorized, model.Error(http.StatusUnauthorized, "未登录或登录已过期"))
		return
	}

	var req createSmokeLogRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		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:     req.Level,
		Num:       req.Num,
	})
	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, ok := middleware.CurrentUser(c)
	if !ok {
		c.JSON(http.StatusUnauthorized, model.Error(http.StatusUnauthorized, "未登录或登录已过期"))
		return
	}

	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, ok := middleware.CurrentUser(c)
	if !ok {
		c.JSON(http.StatusUnauthorized, model.Error(http.StatusUnauthorized, "未登录或登录已过期"))
		return
	}

	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "20"))

	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,
	})
	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,
	}))
}

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, ok := middleware.CurrentUser(c)
	if !ok {
		c.JSON(http.StatusUnauthorized, model.Error(http.StatusUnauthorized, "未登录或登录已过期"))
		return
	}

	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
	}

	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 {
				c.JSON(http.StatusBadRequest, model.Error(http.StatusBadRequest, "smoke_at 格式错误，应为 YYYY-MM-DD HH:MM:SS"))
				return
			}
			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, ok := middleware.CurrentUser(c)
	if !ok {
		c.JSON(http.StatusUnauthorized, model.Error(http.StatusUnauthorized, "未登录或登录已过期"))
		return
	}

	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,
	}))
}