package test

import (
	"github.com/gin-gonic/gin"
	"github.com/spf13/cast"
	"go.uber.org/zap"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"srm/global"
	"srm/model/common/request"
	"srm/model/common/response"
	"srm/model/test"
	testReq "srm/model/test/request"
	"srm/proto/product"
	"srm/service"
)

type ProductApi struct {
}

var pService = service.ServiceGroupApp.TestServiceGroup.ProductService

// CreateProduct 创建Product
// @Tags Product
// @Summary 创建Product
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data body request.ProductCreate true "创建Product"
// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
// @Router /p/createProduct [post]
func (pApi *ProductApi) CreateProduct(c *gin.Context) {
	var p testReq.ProductCreate
	err := c.ShouldBindJSON(&p)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	if err := pService.CreateProduct(p.List); err != nil {
		global.GVA_LOG.Error("创建失败!", zap.Error(err))
		response.FailWithMessage("创建失败", c)
	} else {
		response.OkWithMessage("创建成功", c)
	}
}

// DeleteProduct 删除Product
// @Tags Product
// @Summary 删除Product
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data body test.Product true "删除Product"
// @Success 200 {string} string "{"success":true,"data":{},"msg":"删除成功"}"
// @Router /p/deleteProduct [delete]
func (pApi *ProductApi) DeleteProduct(c *gin.Context) {
	var p test.Product
	err := c.ShouldBindJSON(&p)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	if err := pService.DeleteProduct(p); err != nil {
		global.GVA_LOG.Error("删除失败!", zap.Error(err))
		response.FailWithMessage("删除失败", c)
	} else {
		response.OkWithMessage("删除成功", c)
	}
}

// DeleteProductByIds 批量删除Product
// @Tags Product
// @Summary 批量删除Product
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data body request.IdsReq true "批量删除Product"
// @Success 200 {string} string "{"success":true,"data":{},"msg":"批量删除成功"}"
// @Router /p/deleteProductByIds [delete]
func (pApi *ProductApi) DeleteProductByIds(c *gin.Context) {
	var IDS request.IdsReq
	err := c.ShouldBindJSON(&IDS)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	if err := pService.DeleteProductByIds(IDS); err != nil {
		global.GVA_LOG.Error("批量删除失败!", zap.Error(err))
		response.FailWithMessage("批量删除失败", c)
	} else {
		response.OkWithMessage("批量删除成功", c)
	}
}

// UpdateProduct 更新Product
// @Tags Product
// @Summary 更新Product
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data body test.Product true "更新Product"
// @Success 200 {string} string "{"success":true,"data":{},"msg":"更新成功"}"
// @Router /p/updateProduct [put]
func (pApi *ProductApi) UpdateProduct(c *gin.Context) {
	var p test.Product
	err := c.ShouldBindJSON(&p)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	if err := pService.UpdateProduct(p); err != nil {
		global.GVA_LOG.Error("更新失败!", zap.Error(err))
		response.FailWithMessage("更新失败", c)
	} else {
		response.OkWithMessage("更新成功", c)
	}
}

// FindProduct 用id查询Product
// @Tags Product
// @Summary 用id查询Product
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data query test.Product true "用id查询Product"
// @Success 200 {string} string "{"success":true,"data":{},"msg":"查询成功"}"
// @Router /p/findProduct [get]
func (pApi *ProductApi) FindProduct(c *gin.Context) {
	var p test.Product
	err := c.ShouldBindQuery(&p)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	if rep, err := pService.GetProduct(p.ID); err != nil {
		global.GVA_LOG.Error("查询失败!", zap.Error(err))
		response.FailWithMessage("查询失败", c)
	} else {
		response.OkWithData(gin.H{"rep": rep}, c)
	}
}

// GetProductList 分页获取Product列表
// @Tags Product
// @Summary 分页获取Product列表
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data query testReq.ProductSearch true "分页获取Product列表"
// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
// @Router /p/getProductList [get]
func (pApi *ProductApi) GetProductList(c *gin.Context) {
	var pageInfo testReq.ProductSearch
	err := c.ShouldBindQuery(&pageInfo)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	if list, total, err := pService.GetProductInfoList(pageInfo); err != nil {
		global.GVA_LOG.Error("获取失败!", zap.Error(err))
		response.FailWithMessage("获取失败", c)
	} else {
		response.OkWithDetailed(response.PageResult{
			List:     list,
			Total:    total,
			Page:     pageInfo.Page,
			PageSize: pageInfo.PageSize,
		}, "获取成功", c)
	}
}

var (
	productServiceConn *grpc.ClientConn
)

func InitProductServiceConn() {
	var err error
	productServiceConn, err = grpc.Dial(global.GVA_CONFIG.System.GrpcUrl, grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		//logx.Errorf("grpc dial product service error: %v", err.Error())
		return
	}
}

func CloseProductServiceConn() {
	if productServiceConn != nil {
		productServiceConn.Close()
	}
}

// GetProductListFromGrpc 分页获取Product列表
// @Tags Product
// @Summary 分页获取Product列表
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data query testReq.ProductSearch true "分页获取Product列表"
// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
// @Router /p/getProductListFromGrpc [get]
func (pApi *ProductApi) GetProductListFromGrpc(c *gin.Context) {
	var pageInfo testReq.ProductSearch
	err := c.ShouldBindQuery(&pageInfo)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}

	cli := product.NewProductServiceClient(productServiceConn)
	getProductListResponse, err := cli.GetProductList(c, &product.GetProductListRequest{
		Page:          cast.ToInt32(pageInfo.Page),
		PageSize:      cast.ToInt32(pageInfo.PageSize),
		ProductNumber: pageInfo.Number,
		ProductName:   pageInfo.Name,
	})
	rawProductList := getProductListResponse.List
	productList := make([]test.Product, len(rawProductList))

	for k, v := range rawProductList {
		productList[k].Number = v.Number
		productList[k].Name = v.Name
		productList[k].Unit = v.Unit
		productList[k].PurchasePrice = &v.SalePrice
		min := int(v.MinInventory)
		productList[k].MinimumStock = &min
		max := int(v.MaxInventory)
		productList[k].MaximumStock = &max
		productList[k].Remark = v.Node
		productList[k].ProductType = v.MaterialMode
	}

	if err != nil || getProductListResponse.Code != 0 {
		global.GVA_LOG.Error("获取失败!", zap.Error(err))
		response.FailWithMessage("获取失败", c)
	} else {
		response.OkWithDetailed(response.PageResult{
			List:     productList,
			Total:    int64(len(productList)),
			Page:     pageInfo.Page,
			PageSize: pageInfo.PageSize,
		}, "获取成功", c)
	}

}