package test

import (
	"github.com/gin-gonic/gin"
	"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"
	testResp "srm/model/test/response"
	"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
	}
	for _, t := range p.List {
		var num int64
		db := global.GVA_DB.Model(&test.SupplierMaterial{})
		err := db.Where("number = ?", t.Number).Where("supplier_id = ?", t.SupplierId).Count(&num).Error
		if err != nil {
			response.FailWithMessage(err.Error(), c)
			return
		}
		if num > 0 {
			response.FailWithMessage("当前供应商已经提供此产品", 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 request.GetById true "删除Product"
// @Success 200 {string} string "{"success":true,"data":{},"msg":"删除成功"}"
// @Router /p/deleteProduct [delete]
func (pApi *ProductApi) DeleteProduct(c *gin.Context) {
	var p request.GetById
	err := c.ShouldBindJSON(&p)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	if err := pService.DeleteProduct(p.ID); 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.SupplierMaterial true "更新Product"
// @Success 200 {string} string "{"success":true,"data":{},"msg":"更新成功"}"
// @Router /p/updateProduct [put]
func (pApi *ProductApi) UpdateProduct(c *gin.Context) {
	var p test.SupplierMaterial
	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 request.GetById true "用id查询Product"
// @Success 200 {string} string "{"success":true,"data":{},"msg":"查询成功"}"
// @Router /p/findProduct [get]
func (pApi *ProductApi) FindProduct(c *gin.Context) {
	var p request.GetById
	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列表"
// @Param Authorization	header string true "token"
// @Success 200 {string} string "{"success":true,"data":{},"msg":"获取成功"}"
// @Router /p/getProductList [get]
func (pApi *ProductApi) GetProductList(c *gin.Context) {
	var params testReq.ProductSearch
	err := c.ShouldBindQuery(&params)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	list, total, err := pService.GetProductInfoList(params)
	if err != nil {
		global.GVA_LOG.Error("获取失败!", zap.Error(err))
		response.FailWithMessage("获取失败", c)
		return
	}

	response.OkWithDetailed(response.PageResult{
		List:     list,
		Total:    total,
		Page:     params.Page,
		PageSize: params.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
	}

	list, total, err := pService.GetMaterials(pageInfo)
	if err != nil {
		global.GVA_LOG.Error("获取失败!", zap.Error(err))
		response.FailWithMessage("获取失败", c)
		return
	}

	productList := make([]testResp.Material, 0)

	for _, item := range list {
		productList = append(productList, testResp.Material{
			Name:           item.Name,
			Number:         item.ID,
			Unit:           item.Unit,
			Specifications: item.Specs,
			ModelNumber:    item.Type,
			MinimumStock:   item.MinInventory.IntPart(),
			MaximumStock:   item.MaxInventory.IntPart(),
			Remark:         "",
			CategoryName:   item.CategoryName,
		})
	}

	if err != nil {
		global.GVA_LOG.Error("获取失败!", zap.Error(err))
		response.FailWithMessage("获取失败", c)
	}

	response.OkWithDetailed(response.PageResult{
		List:     productList,
		Total:    total,
		Page:     pageInfo.Page,
		PageSize: pageInfo.PageSize,
	}, "获取成功", c)

}