package controller

import (
	"centerBook/es"
	"centerBook/model/request"
	"centerBook/model/response"
	"centerBook/service"
	"fmt"
	"net/http"
	"strings"

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

// BookController 图书控制器
type BookController struct {
	bookService *service.BookService
}

// NewBookController 创建图书控制器实例
func NewBookController(bookService *service.BookService) *BookController {
	return &BookController{
		bookService: bookService,
	}
}

// SearchBookBaseInfoHandler 搜索图书基础信息 Handler
func (b *BookController) SearchBookBaseInfoHandler(c *gin.Context) {
	// 绑定请求参数
	var req request.BookSearchRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	// 设置默认值
	if req.Page <= 0 {
		req.Page = 1
	}
	if req.PageSize <= 0 {
		if req.PerPage > 0 {
			req.PageSize = req.PerPage
		} else {
			req.PageSize = 10
		}
	}

	// 调用服务层查询
	list, total, err := b.bookService.SearchBookBaseInfo(&req)
	if err != nil {
		fmt.Printf("[ERROR] SearchBookBaseInfo failed: %v\n", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	// 转换为响应格式
	responseList := make([]es.ESBookResponse, 0, len(list))
	for _, book := range list {
		responseList = append(responseList, book.ConvertToResponse())
	}

	// DEBUG: 打印响应数据摘要
	fmt.Printf("[DEBUG] Response Info => total=%d page=%d pageSize=%d returnCount=%d\n",
		total, req.Page, req.PageSize, len(responseList))

	// 返回标准响应格式
	resp := response.NewBookSearchResponse(req.Page, req.PageSize, total, responseList)
	c.JSON(http.StatusOK, resp)
}

// AddBookToESHandler 根据ISBN查询ES中是否存在，不存在则新增数据,存在则根据参数更新 Handler
func (b *BookController) AddBookToESHandler(c *gin.Context) {
	var req es.ESBook
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error":   "参数解析错误",
			"message": err.Error(),
		})
		return
	}

	if req.ISBN == "" {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": "ISBN不能为空",
		})
		return
	}
	// 调用服务层处理
	result, err := b.bookService.AddBookToESHandler(c.Request.Context(), &req)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"error":   "处理失败",
			"details": err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"data":   result.Book.ConvertToResponse(),
		"source": result.Source,
	})
}

// UpdateBookFieldsByISBNHandler 根据 ISBN 更新图书字段 Handler
func (b *BookController) UpdateBookFieldsByISBNHandler(c *gin.Context) {
	// 绑定请求参数
	var req request.BookUpdateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error":   "请求参数错误",
			"details": err.Error(),
		})
		return
	}
	isbn := strings.TrimSpace(req.ISBN)
	if isbn == "" {
		c.JSON(400, gin.H{
			"error": "ISBN不能为空",
		})
		return
	}

	if len(req.Data) == 0 {
		c.JSON(400, gin.H{
			"error": "至少提供一个要更新的字段",
		})
		return
	}
	// 调用服务层处理
	result, err := b.bookService.UpdateBookFieldsByISBN(&req)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"error":   "更新失败",
			"details": err.Error(),
		})
		return
	}

	// 返回标准响应
	resp := response.NewUpdateBookResponse(result.ISBN, result.Updated, result.Fields)
	c.JSON(http.StatusOK, resp)
}

// UpdateBookCatIdByISBNHandler 根据 ISBN 更新图书字段 Handler
func (b *BookController) UpdateBookCatIdByISBNHandler(c *gin.Context) {
	// 绑定请求参数
	var req request.BookUpdateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error":   "请求参数错误",
			"details": err.Error(),
		})
		return
	}
	isbn := strings.TrimSpace(req.ISBN)
	if isbn == "" {
		c.JSON(400, gin.H{
			"error": "ISBN不能为空",
		})
		return
	}
	if len(req.Data) == 0 {
		c.JSON(400, gin.H{
			"error": "至少提供一个要更新的字段",
		})
		return
	}

	// 调用服务层处理
	result, err := b.bookService.UpdateBookCatIdByISBNHandler(&req)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"error":   "更新失败",
			"details": err.Error(),
		})
		return
	}

	// 返回标准响应
	resp := response.NewUpdateBookResponse(result.ISBN, result.Updated, result.Fields)
	c.JSON(http.StatusOK, resp)
}

// DeleteBookHandler 删除图书
func (b *BookController) DeleteBookHandler(c *gin.Context) {
	// 绑定请求参数
	var req request.BookDelByIsbnRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error":   "请求参数错误",
			"details": err.Error(),
		})
		return
	}
	// 调用服务层处理
	err := b.bookService.DeleteBookByISBN(&req)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"error":   "删除失败",
			"details": err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "删除成功"})
}

// DeleteBookByIDHandler 根据ID删除图书的HTTP处理器
func (b *BookController) DeleteBookByIDHandler(c *gin.Context) {
	// 绑定请求参数
	var req request.BookDelByIdRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"error":   "请求参数错误",
			"details": err.Error(),
		})
		return
	}

	// 调用服务层处理
	err := b.bookService.DeleteBookByID(&req)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"error":   "删除失败",
			"details": err.Error(),
		})
		return
	}

	c.JSON(200, gin.H{
		"code":    200,
		"message": "删除成功",
		"data": gin.H{
			"id":      req.ID,
			"deleted": true,
		},
	})
}