package controllers

import (
	"github.com/gin-gonic/gin"
	"github.com/shopspring/decimal"
	"gorm.io/gorm"
	"outsourcing/constvar"
	"outsourcing/extend/code"
	"outsourcing/extend/util"
	"outsourcing/models"
	"outsourcing/pkg/logx"
	"outsourcing/pkg/structx"
	"outsourcing/request"
	"outsourcing/service"
	"outsourcing/service/outsourcing"
	"outsourcing/utils/jwt"
)

type OrderController struct{}

// OutsourcingOrderList
// @Tags      订单管理
// @Summary   委外订单列表
// @Produce   application/json
// @Param     object  query    request.OutsourcingOrderList true  "查询参数"
// @Success   200   {object}  util.ResponseList{data=[]models.OutsourcingOrder}  "成功"
// @Router    /api-outsourcing/v1/order/list [get]
func (slf *OrderController) OutsourcingOrderList(c *gin.Context) {
	var params request.OutsourcingOrderList
	if err := c.BindQuery(&params); err != nil {
		util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
		return
	}

	companyId := jwt.GetCompanyID(c)
	if companyId == 0 {
		util.ResponseFormat(c, code.InternalError, "内部错误")
		return
	}

	list, total, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(companyId).SetPage(params.Page, params.PageSize).SetKeyword(params.Keyword).SetOrder("id desc").Find()
	if err != nil {
		util.ResponseFormat(c, code.InternalError, "查询错误")
		return
	}
	util.ResponseFormatList(c, code.Success, list, int(total))
}

// OrderOverview
// @Tags      订单管理
// @Summary   订单统计
// @Produce   application/json
// @Success   200   {object}  util.ResponseList{data=request.OutsourcingOrderOverview}  "成功"
// @Router    /api-outsourcing/v1/order/overview [get]
func (slf *OrderController) OrderOverview(c *gin.Context) {
	result, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).CountGroupByStatus()
	if err != nil {
		util.ResponseFormat(c, code.InternalError, "查询错误")
		return
	}
	resp := &request.OutsourcingOrderOverview{}
	for _, v := range result {
		resp.Total += v.Total
		status := constvar.OutsourcingOrderStatus(v.Status)
		if status == constvar.OutsourcingOrderStatusCreate {
			resp.WaitAssigned += v.Total
		} else {
			resp.HasAssigned += v.Total
		}
	}
	util.ResponseFormat(c, code.Success, resp)
}

// OutsourcingOrderProductList
// @Tags      订单管理
// @Summary   委外订单产品列表
// @Produce   application/json
// @Param     object  query    request.OutsourcingOrderProductList true  "查询参数"
// @Success   200   {object}  util.ResponseList{data=[]models.OutsourcingOrderProduct}  "成功"
// @Router    /api-outsourcing/v1/order/productList [get]
func (slf *OrderController) OutsourcingOrderProductList(c *gin.Context) {
	var params request.OutsourcingOrderProductList
	if err := c.BindQuery(&params); err != nil {
		util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
		return
	}
	if params.OutsourcingOrderId == 0 {
		util.ResponseFormat(c, code.RequestParamError, "参数缺失")
		return
	}

	_, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).SetID(params.OutsourcingOrderId).First()
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "订单不存在")
		return
	}

	list, total, err := models.NewOutsourcingOrderProductSearch().SetPage(params.Page, params.PageSize).SetOutsourcingOrderID(params.OutsourcingOrderId).SetOrder("id desc").Find()
	if err != nil {
		util.ResponseFormat(c, code.InternalError, "查询错误")
		return
	}
	util.ResponseFormatList(c, code.Success, list, int(total))
}

// SaveMaterialApply
// @Tags      订单管理
// @Summary   保存物料申请单
// @Produce   application/json
// @Param     object  body    request.SaveMaterialApply true  "参数"
// @Success   200   {object}  util.Response{}  "成功"
// @Router    /api-outsourcing/v1/order/saveMaterialApply [post]
func (slf *OrderController) SaveMaterialApply(c *gin.Context) {
	var params request.SaveMaterialApply
	if err := c.BindJSON(&params); err != nil {
		util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
		return
	}
	if len(params.ApplyList) == 0 {
		util.ResponseFormat(c, code.RequestParamError, "物料申请不能为空")
		return
	}

	_, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).SetNumber(params.ApplyList[0].OutsourcingOrderNumber).First()
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "订单不存在")
		return
	}

	var apply []*models.OutsourcingMaterialApply
	err = structx.AssignTo(params.ApplyList, &apply)
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "数据转换失败")
		return
	}
	err = models.WithTransaction(func(db *gorm.DB) error {
		err = models.NewOutsourcingMaterialApplySearch().SetOrm(db).CreateBatch(apply)
		if err != nil {
			return err
		}
		err = models.NewOutsourcingOrderSearch().SetOrm(db).SetNumber(params.ApplyList[0].OutsourcingOrderNumber).
			UpdateByMap(map[string]interface{}{"status": constvar.OutsourcingOrderStatusMaterialApplying})
		return err
	})
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "保存失败")
		return
	}

	util.ResponseFormat(c, code.Success, "保存成功")
}

// GetMaterialApplyList
// @Tags      订单管理
// @Summary   获取物料申请单
// @Produce   application/json
// @Param     object  body    request.GetMaterialApplyList true  "参数"
// @Success   200   {object}  util.ResponseList{[]models.OutsourcingMaterialApply}  "成功"
// @Router    /api-outsourcing/v1/order/getMaterialApplyList [post]
func (slf *OrderController) GetMaterialApplyList(c *gin.Context) {
	var params request.GetMaterialApplyList
	if err := c.BindJSON(&params); err != nil {
		util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
		return
	}

	_, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).SetNumber(params.Number).First()
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "订单不存在")
		return
	}

	find, err := models.NewOutsourcingMaterialApplySearch().SetOutsourcingOrderNumber(params.Number).FindNotTotal()
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "查询失败")
		return
	}
	util.ResponseFormat(c, code.Success, find)
}

// ChangeStatus
// @Tags      订单管理
// @Summary   修改状态
// @Produce   application/json
// @Param     object  body    request.ChangeStatus true  "参数"
// @Success   200   {object}  util.Response  "成功"
// @Router    /api-outsourcing/v1/order/changeStatus [post]
func (slf *OrderController) ChangeStatus(c *gin.Context) {
	var params request.ChangeStatus
	if err := c.BindJSON(&params); err != nil {
		util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
		return
	}

	_, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).SetNumber(params.OutsourcingOrderNumber).First()
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "订单不存在")
		return
	}

	//限定状态参数
	if params.Status == constvar.OutsourcingOrderStatusCreate || //取消确认
		params.Status == constvar.OutsourcingOrderStatusWaitProduce || //确认接受
		params.Status == constvar.OutsourcingOrderStatusFinish || //生产完成
		params.Status == constvar.OutsourcingOrderStatusDeliveryFinish { //发货完成
		err = models.WithTransaction(func(db *gorm.DB) error {
			m := make(map[string]interface{})
			m["status"] = params.Status
			m["reason"] = params.Reason
			err := models.NewOutsourcingOrderSearch().SetNumber(params.OutsourcingOrderNumber).UpdateByMap(m)
			if err != nil {
				return err
			}
			if params.Status == constvar.OutsourcingOrderStatusCreate {
				return models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).SetNumber(params.OutsourcingOrderNumber).UpdateByMap(map[string]interface{}{
					"enterprise_id": 0,
				})
			}
			return nil
		})

		if err != nil {
			util.ResponseFormat(c, code.RequestParamError, "状态更新失败")
			return
		}
		util.ResponseFormat(c, code.Success, "状态更新成功")
		return
	}
	util.ResponseFormat(c, code.RequestParamError, "状态参数不正确")
}

// DeliveryPrepare
// @Tags      订单管理
// @Summary   发货准备
// @Produce   application/json
// @Param     object  query    request.DeliveryPrepare true  "参数"
// @Success   200   {object}  util.Response{}  "成功"
// @Router    /api-outsourcing/v1/order/deliveryPrepare [get]
func (slf *OrderController) DeliveryPrepare(c *gin.Context) {
	var params request.DeliveryPrepare
	if err := c.BindQuery(&params); err != nil {
		util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
		return
	}
	if params.OutsourcingOrderID == 0 {
		util.ResponseFormat(c, code.RequestParamError, "参数缺失")
		return
	}

	_, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).SetID(params.OutsourcingOrderID).First()
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "订单不存在")
		return
	}

	orderProducts, err := models.NewOutsourcingOrderProductSearch().SetOutsourcingOrderID(params.OutsourcingOrderID).FindNotTotal()
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "查询订单产品列表失败")
		return
	}
	deliveryDetails, err := models.NewOutsourcingOrderDeliveryDetailsSearch().SetOutsourcingOrderID(params.OutsourcingOrderID).FindNotTotal()
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "查询订单产品发货明细失败")
		return
	}
	deliveryMap := make(map[uint]decimal.Decimal)
	for _, item := range deliveryDetails {
		deliveryMap[item.OutsourcingOrderProductID] = deliveryMap[item.OutsourcingOrderProductID].Add(item.SendAmount)
	}
	for _, v := range orderProducts {
		v.SendAmount = deliveryMap[v.ID]
	}
	util.ResponseFormat(c, code.Success, orderProducts)
}

// SaveDelivery
// @Tags      订单管理
// @Summary   保存发货信息
// @Produce   application/json
// @Param     object  body    request.SaveDelivery true  "参数"
// @Success   200   {object}  util.Response{}  "成功"
// @Router    /api-outsourcing/v1/order/saveDelivery [post]
func (slf *OrderController) SaveDelivery(c *gin.Context) {
	var params request.SaveDelivery
	if err := c.BindJSON(&params); err != nil {
		util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
		return
	}
	if params.OutsourcingOrderID == 0 || params.Number == "" || params.Carrier == "" || params.WaybillNumber == "" {
		util.ResponseFormat(c, code.RequestParamError, "参数缺失")
		return
	}

	_, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).SetID(params.OutsourcingOrderID).First()
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "订单不存在")
		return
	}

	if len(params.DeliveryList) == 0 {
		util.ResponseFormat(c, code.RequestParamError, "发货列表不能为空")
		return
	}

	delivery := &models.OutsourcingOrderDelivery{
		OutsourcingOrderID: params.OutsourcingOrderID,
		Number:             params.Number,
		Carrier:            params.Carrier,
		WaybillNumber:      params.WaybillNumber,
	}

	err = models.WithTransaction(func(db *gorm.DB) error {
		err = models.NewOutsourcingOrderDeliverySearch().SetOrm(db).Create(delivery)
		if err != nil {
			return err
		}
		items := make([]*models.OutsourcingOrderDeliveryDetails, 0, len(params.DeliveryList))
		for _, v := range params.DeliveryList {
			items = append(items, &models.OutsourcingOrderDeliveryDetails{
				OutsourcingOrderID:         params.OutsourcingOrderID,
				OutsourcingOrderDeliveryID: delivery.ID,
				OutsourcingOrderProductID:  v.OutsourcingOrderProductID,
				SendAmount:                 v.SendAmount,
			})
		}
		return models.NewOutsourcingOrderDeliveryDetailsSearch().SetOrm(db).CreateBatch(items)
	})
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "保存失败")
		return
	}

	util.ResponseFormat(c, code.Success, "保存成功")
}

// GetDeliveryList
// @Tags      订单管理
// @Summary   获取发货列表
// @Produce   application/json
// @Param     object  body    request.GetDeliveryList true  "参数"
// @Success   200   {object}  util.ResponseList{[]models.OutsourcingOrderDeliveryDetails}  "成功"
// @Router    /api-outsourcing/v1/order/deliveryList [post]
func (slf *OrderController) GetDeliveryList(c *gin.Context) {
	var params request.GetDeliveryList
	if err := c.BindJSON(&params); err != nil {
		util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
		return
	}

	_, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).SetID(params.OutsourcingOrderID).First()
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "订单不存在")
		return
	}

	list, err := models.NewOutsourcingOrderDeliveryDetailsSearch().
		SetOutsourcingOrderID(params.OutsourcingOrderID).
		SetPreload(true).
		SetOrder("id desc").
		FindNotTotal()
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "查询失败")
		return
	}
	util.ResponseFormat(c, code.Success, list)
}

// MaterialSearch
// @Tags      订单管理
// @Summary   物料搜索
// @Produce   application/json
// @Param     object  body    request.MaterialSearch true  "参数"
// @Success   200   {object}  util.ResponseList{[]models.OutsourcingOrderDeliveryDetails}  "成功"
// @Router    /api-outsourcing/v1/order/materialSearch [post]
func (slf *OrderController) MaterialSearch(c *gin.Context) {
	var params request.MaterialSearch
	if err := c.BindJSON(&params); err != nil {
		util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
		return
	}
	client := outsourcing.NewOutsourcingServiceClient(service.ApsServiceConn)
	list, err := client.GetMaterialList(c, &outsourcing.GetMaterialListRequest{
		Page:     int32(params.Page),
		PageSize: int32(params.PageSize),
		Keyword:  params.Keyword,
	})
	if err != nil {
		logx.Errorf("grpc outsourcing GetProductList err:%v", err)
		util.ResponseFormat(c, code.RequestParamError, "查询失败")
		return
	}
	util.ResponseFormat(c, code.Success, list)
}