package controller

import (
	"errors"
	"net/http"
	"woord-core-service/model"

	"github.com/gin-gonic/gin"
)

type ListDictsResponse struct {
	Total uint               `json:"total"`
	List  []model.DictResult `json:"list"`
}

// 列出所有词库
func ListDicts(c *gin.Context) {
	dicts, err := model.ListDicts(c.MustGet(AuthUserKey).(uint))
	if err != nil {
		respondUnknownError(c, err)
		return
	}

	respondOK(c, &ListDictsResponse{
		Total: uint(len(dicts)),
		List:  dicts,
	})
}

type GetDictRequest struct {
	DictID uint `form:"id" binding:"required"`
}

type ListWordsResponse struct {
	Total uint               `json:"total"`
	List  []model.WordResult `json:"list"`
}

type GetDictResponse struct {
	*model.DictResult `json:"dict"`
	Words             ListWordsResponse `json:"words"`
}

// 获取词库
func GetDict(c *gin.Context) {
	var request GetDictRequest
	if err := c.ShouldBind(&request); err != nil {
		respondError(c, http.StatusBadRequest, err)
		return
	}

	dict, err := model.GetDict(request.DictID, c.MustGet(AuthUserKey).(uint))
	if err != nil {
		if errors.Is(err, model.ErrDictNotFound) {
			respondError(c, http.StatusNotFound, err)
		} else {
			respondUnknownError(c, err)
		}
		return
	}

	words, err := model.ListWords(request.DictID)
	if err != nil {
		respondUnknownError(c, err)
		return
	}

	respondOK(c, &GetDictResponse{
		DictResult: dict,
		Words: ListWordsResponse{
			Total: uint(len(words)),
			List:  words,
		},
	})
}

type CreateDictRequest struct {
	DictName     string `form:"name" binding:"required"`
	ValueTitle   string `form:"valueTitle" binding:"required"`
	MeaningTitle string `form:"meaningTitle" binding:"required"`
	ExtraTitle   string `form:"extraTitle"`
}

// 创建词库
func CreateDict(c *gin.Context) {
	var request CreateDictRequest
	if err := c.ShouldBind(&request); err != nil {
		respondError(c, http.StatusBadRequest, err)
		return
	}

	dict, err := model.CreateDict(request.DictName, request.ValueTitle, request.MeaningTitle, request.ExtraTitle, c.MustGet(AuthUserKey).(uint))
	if err != nil {
		respondUnknownError(c, err)
		return
	}

	respondOK(c, dict)
}

type UpdateDictRequest struct {
	DictID       uint   `form:"id" binding:"required"`
	DictName     string `form:"name" binding:"required"`
	ValueTitle   string `form:"valueTitle" binding:"required"`
	MeaningTitle string `form:"meaningTitle" binding:"required"`
	ExtraTitle   string `form:"extraTitle"`
}

// 更新词库
func UpdateDict(c *gin.Context) {
	var request UpdateDictRequest
	if err := c.ShouldBind(&request); err != nil {
		respondError(c, http.StatusBadRequest, err)
		return
	}

	_, err := model.GetDict(request.DictID, c.MustGet(AuthUserKey).(uint))
	if err != nil {
		if errors.Is(err, model.ErrDictNotFound) {
			respondError(c, http.StatusNotFound, err)
		} else {
			respondUnknownError(c, err)
		}
		return
	}

	dict, err := model.UpdateDict(request.DictID, request.DictName, request.ValueTitle, request.MeaningTitle, request.ExtraTitle)
	if err != nil {
		respondUnknownError(c, err)
		return
	}

	respondOK(c, dict)
}

type DeleteDictRequest struct {
	DictID uint `form:"id" binding:"required"`
}

// 删除词库
func DeleteDict(c *gin.Context) {
	var request DeleteDictRequest
	if err := c.ShouldBind(&request); err != nil {
		respondError(c, http.StatusBadRequest, err)
		return
	}

	_, err := model.GetDict(request.DictID, c.MustGet(AuthUserKey).(uint))
	if err != nil {
		if errors.Is(err, model.ErrDictNotFound) {
			respondError(c, http.StatusNotFound, err)
		} else {
			respondUnknownError(c, err)
		}
		return
	}

	err = model.DeleteDict(request.DictID)
	if err != nil {
		respondUnknownError(c, err)
		return
	}

	respondOK(c, nil)
}