package keyword

import (
	"fmt"
	"net/http"

	"mini-chat/internal/code"
	"mini-chat/internal/pkg/core"
	"mini-chat/internal/pkg/timeutil"
	"mini-chat/internal/pkg/validation"

	"gorm.io/gorm"
)

type keywordMaterialPageListRequest struct {
	KeywordID int32 `form:"keyword_id" binding:"required"` // 意图关键字ID
	Page      int   `form:"page"`                          // 当前页码，默认为第一页
	PageSize  int   `form:"page_size"`                     // 每页返回的数据量
}

type keywordMaterialListData struct {
	ID              int32  `json:"id"`               // 主键ID
	KeywordID       int32  `json:"keyword_id"`       // 意图关键字ID
	Type            int32  `json:"type"`             // 素材类型(1:文本 2:图片)
	Content         string `json:"content"`          // 素材内容
	IntervalSeconds int32  `json:"interval_seconds"` // 素材发送间隔时间(单位:秒)
	CreatedUser     string `json:"created_user"`     // 创建人
	CreatedAt       string `json:"created_at"`       // 创建时间
}

type keywordMaterialPageListResponse struct {
	Page     int                       `json:"page"`      // 当前页码
	PageSize int                       `json:"page_size"` // 每页返回的数据量
	Total    int64                     `json:"total"`     // 符合查询条件的总记录数
	List     []keywordMaterialListData `json:"list"`
}

// KeywordMaterialPageList 获取意图关键字素材列表
// @Summary 获取意图关键字素材列表
// @Description 获取意图关键字素材列表
// @Tags 管理端.意图关键字
// @Accept json
// @Produce json
// @Param keyword_id query int true "意图关键字ID"
// @Param page query int true "当前页码" default(1)
// @Param page_size query int true "每页返回的数据量，最多 100 条" default(20)
// @Success 200 {object} keywordMaterialPageListResponse
// @Failure 400 {object} code.Failure
// @Router /api/admin/app/keyword/materials [get]
// @Security LoginVerifyToken
func (h *handler) KeywordMaterialPageList() core.HandlerFunc {
	return func(ctx core.Context) {
		req := new(keywordMaterialPageListRequest)
		res := new(keywordMaterialPageListResponse)
		if err := ctx.ShouldBindForm(req); err != nil {
			ctx.AbortWithError(core.Error(
				http.StatusBadRequest,
				code.ParamBindError,
				validation.Error(err)),
			)
			return
		}

		if req.Page == 0 {
			req.Page = 1
		}

		if req.PageSize == 0 {
			req.PageSize = 20
		}

		if req.PageSize > 100 {
			ctx.AbortWithError(core.Error(
				http.StatusBadRequest,
				code.ListKeywordMaterialError,
				fmt.Sprintf("%s: 一次最多只能查询 100 条", code.Text(code.ListKeywordMaterialError)),
			))
			return
		}

		query := h.readDB.AppKeywordReply.WithContext(ctx.RequestContext())
		query = query.Where(h.readDB.AppKeywordReply.KeywordID.Eq(req.KeywordID))

		listQueryDB := query.Session(&gorm.Session{})
		countQueryDB := query.Session(&gorm.Session{})

		resultData, err := listQueryDB.
			Order(h.readDB.AppKeywordReply.ID.Asc()).
			Limit(req.PageSize).
			Offset((req.Page - 1) * req.PageSize).
			Find()
		if err != nil {
			ctx.AbortWithError(core.Error(
				http.StatusBadRequest,
				code.ListKeywordMaterialError,
				fmt.Sprintf("%s：%s", code.Text(code.ListKeywordMaterialError), err.Error())),
			)
			return
		}

		count, err := countQueryDB.Count()
		if err != nil {
			ctx.AbortWithError(core.Error(
				http.StatusBadRequest,
				code.ListKeywordMaterialError,
				fmt.Sprintf("%s：%s", code.Text(code.ListKeywordMaterialError), err.Error())),
			)
			return
		}

		res.Page = req.Page
		res.PageSize = req.PageSize
		res.Total = count
		res.List = make([]keywordMaterialListData, len(resultData))

		for k, v := range resultData {
			res.List[k] = keywordMaterialListData{
				ID:              v.ID,
				KeywordID:       v.KeywordID,
				Type:            v.Type,
				Content:         v.Content,
				IntervalSeconds: v.IntervalSeconds,
				CreatedUser:     v.CreatedUser,
				CreatedAt:       timeutil.FriendlyTime(v.CreatedAt),
			}
		}

		ctx.Payload(res)
	}
}
