package controller

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

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

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

type CreateWordRequest struct {
	Value   string `form:"value" binding:"required"`
	Meaning string `form:"meaning" binding:"required"`
	Extra   string `form:"extra"`
	DictID  uint   `form:"dictID" binding:"required"`
}

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

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

	word, err := model.CreateWord(&model.Word{
		Value:   request.Value,
		Meaning: request.Meaning,
		Extra:   request.Extra,
		DictID:  request.DictID,
	})
	if err != nil {
		if errors.Is(err, model.ErrWordAlreadyExists) {
			respondError(c, http.StatusConflict, err)
		} else {
			respondUnknownError(c, err)
		}
		return
	}

	respondOK(c, word)
}

type UpdateWordRequest struct {
	WordID  uint   `form:"id" binding:"required"`
	Value   string `form:"value" binding:"required"`
	Meaning string `form:"meaning" binding:"required"`
	Extra   string `form:"extra"`
	Star    bool   `form:"star"`
}

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

	word, err := model.UpdateWord(&model.Word{
		Model: &gorm.Model{
			ID: request.WordID,
		},
		Value:   request.Value,
		Meaning: request.Meaning,
		Extra:   request.Extra,
		Star:    request.Star,
	})
	if err != nil {
		if errors.Is(err, model.ErrWordNotFound) {
			respondError(c, http.StatusNotFound, err)
		} else if errors.Is(err, model.ErrWordAlreadyExists) {
			respondError(c, http.StatusConflict, err)
		} else {
			respondUnknownError(c, err)
		}
		return
	}

	respondOK(c, word)
}

type DeleteWordRequest struct {
	WordID uint `form:"id" binding:"required"`
}

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

	err := model.DeleteWord(&model.Word{
		Model: &gorm.Model{
			ID: request.WordID,
		},
	})
	if err != nil {
		if errors.Is(err, model.ErrWordNotFound) {
			respondError(c, http.StatusNotFound, err)
		} else {
			respondUnknownError(c, err)
		}
		return
	}

	respondOK(c, nil)
}