package ordermanage

import (
	"encoding/json"
	"errors"
	"github.com/gin-gonic/gin"
	model "go-admin/app/admin/models"
	orm "go-admin/common/global"
	"go-admin/logger"
	"go-admin/tools/app"
	"net/http"
	"time"
)

func ErpOrderList(c *gin.Context) {
	req := &model.ErpOrderListReq{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	resp, err := req.List()
	if err != nil {
		logger.Error("erp commodity list err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}

	app.OK(c, resp, "")
	return
}

func ErpOrderCreate(c *gin.Context) {
	req := struct {
		//StoreId             uint32                    `json:"store_id"`
		Cashiers            []model.ErpCashier        `json:"cashiers"  binding:"required"`
		Salesman1           uint32                    `json:"salesman_1" binding:"required"`
		Salesman2           uint32                    `json:"salesman_2"`
		RetailType          string                    `json:"retail_type" binding:"required"`
		Tel                 string                    `json:"tel" binding:"required"`
		MemberType          string                    `json:"member_type"` // 会员类型:
		ErpOrderCommodities []model.ErpOrderCommodity `json:"erp_order_commodities"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	if len(req.Cashiers) == 0 {
		logger.Error("cashiers is nil")
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	if len(req.ErpOrderCommodities) == 0 {
		logger.Error("commodities is nil")
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	jCashier, err := json.Marshal(req.Cashiers)
	if err != nil {
		logger.Error("cashiers marshal err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}
	sysUser, err := model.GetSysUserByCtx(c)
	if err != nil {
		logger.Error("sys user err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}
	if sysUser.StoreId == 0 {
		logger.Error("sys user store id null")
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	erpOrder := &model.ErpOrder{
		BillSn:     model.NewErpBillSn(),
		RetailType: req.RetailType,
		Tel:        req.Tel,
		StoreId:    sysUser.StoreId,
		StoreName:  sysUser.StoreName,
		MakerId:    uint32(sysUser.UserId),
		MakerName:  sysUser.NickName,
		MakerTime:  time.Now(),
		//AuditTime:   time.Now(),
		//AuditorId:   uint32(sysUser.UserId),
		//AuditorName: sysUser.NickName,
		CashierList: string(jCashier),
		Salesman1:   req.Salesman1,
		Salesman2:   req.Salesman2,
		MemberType:  req.MemberType,
		State:       model.ErpOrderStateUnAudit,
	}

	commodityMap := make(map[uint32]model.ErpCommodity)
	if req.RetailType == model.RetailTypeSale {
		commodityIds := make([]uint32, 0, len(req.ErpOrderCommodities))
		for i, _ := range req.ErpOrderCommodities {
			commodityIds = append(commodityIds, req.ErpOrderCommodities[i].ErpCommodityId)
		}
		var commodities []model.ErpCommodity
		err = orm.Eloquent.Table("erp_commodity").Where("id IN (?)", commodityIds).Find(&commodities).Error
		if err != nil {
			logger.Error("commodities err:", err)
			app.Error(c, http.StatusInternalServerError, err, "操作失败")
			return
		}

		for i, _ := range commodities {
			commodityMap[commodities[i].ID] = commodities[i]
		}

		model.SetUserInfo(req.Tel)
	}

	var orderCommodityMap map[uint32]model.ErpOrderCommodity
	if req.RetailType == model.RetailTypeRejected {
		ids := make([]uint32, 0, len(req.ErpOrderCommodities))
		for i, _ := range req.ErpOrderCommodities {
			ids = append(ids, req.ErpOrderCommodities[i].RejectedOrderCommodityId)
		}
		orderCommodityMap, err = model.GetErpOrderCommodityMap(ids)
		if err != nil {
			logger.Error("order commodity map err:", err)
			return
		}
	}

	begin := orm.Eloquent.Begin()
	err = begin.Create(erpOrder).Error
	if err != nil {
		begin.Rollback()
		logger.Error("create erp order err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}

	for i, _ := range req.ErpOrderCommodities {
		req.ErpOrderCommodities[i].ErpOrderId = erpOrder.ID

		if req.RetailType == model.RetailTypeRejected {
			v, ok := orderCommodityMap[req.ErpOrderCommodities[i].RejectedOrderCommodityId]
			if ok {
				v.RejectedPrice = req.ErpOrderCommodities[i].RejectedPrice
				v.RejectedCount = req.ErpOrderCommodities[i].RejectedCount
				v.RejectedAmount = v.RejectedCount * v.RejectedPrice
			} else {
				logger.Error("rejected order commodity id is null")
				return
			}
			v.ID = 0
			req.ErpOrderCommodities[i] = v
			// 添加库存 TODO
			if req.ErpOrderCommodities[i].RejectedPrice > req.ErpOrderCommodities[i].RetailPrice {
				logger.Error("rejected price gt retail price ")
				app.Error(c, http.StatusInternalServerError, err, "操作失败")
				return
			}
			if req.ErpOrderCommodities[i].RejectedCount > req.ErpOrderCommodities[i].Count {
				logger.Error("rejected count gt retail count ")
				app.Error(c, http.StatusInternalServerError, err, "操作失败")
				return
			}

		} else if req.RetailType == model.RetailTypeSale {

			v, ok := commodityMap[req.ErpOrderCommodities[i].ErpCommodityId]
			if ok {
				req.ErpOrderCommodities[i].ErpCommodityName = v.Name
				req.ErpOrderCommodities[i].ErpCategoryId = v.ErpCategoryId
				req.ErpOrderCommodities[i].ErpCategoryName = v.ErpCategoryName
				req.ErpOrderCommodities[i].RetailPrice = v.RetailPrice
				//req.ErpOrderCommodities[i].MemberPrice = v.MemberPrice
			}
			if req.ErpOrderCommodities[i].PresentType == 2 {
				req.ErpOrderCommodities[i].RetailPrice = 0
			}

			// 减库存 TODO
			if erpOrder.MemberType == model.ErpOrderMemberTypeMember {
				req.ErpOrderCommodities[i].Amount = req.ErpOrderCommodities[i].Count * req.ErpOrderCommodities[i].MemberPrice
			} else {
				req.ErpOrderCommodities[i].Amount = req.ErpOrderCommodities[i].Count * req.ErpOrderCommodities[i].RetailPrice
			}
		}

		erpOrder.TotalAmount += req.ErpOrderCommodities[i].Amount
		erpOrder.TotalCount += req.ErpOrderCommodities[i].Count
	}

	err = begin.Create(&req.ErpOrderCommodities).Error
	if err != nil {
		begin.Rollback()
		logger.Error("Create")
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}
	err = begin.Commit().Error
	if err != nil {
		begin.Rollback()
		logger.Error("commit err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}
	erpOrder.Commodities = req.ErpOrderCommodities
	erpOrder.Cashiers = req.Cashiers

	app.OK(c, erpOrder, "")
	return
}

func ErpOrderModify(c *gin.Context) {
	req := struct {
		//StoreId             uint32                    `json:"store_id"`
		Id                  uint32                    `json:"id" binding:"required"`
		Cashiers            []model.ErpCashier        `json:"cashiers"  binding:"required"`
		Salesman1           uint32                    `json:"salesman_1" binding:"required"`
		Salesman2           uint32                    `json:"salesman_2"`
		RetailType          string                    `json:"retail_type" binding:"required"`
		Tel                 string                    `json:"tel" binding:"required"`
		MemberType          string                    `json:"member_type"` // 会员类型:
		ErpOrderCommodities []model.ErpOrderCommodity `json:"erp_order_commodities"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	if len(req.Cashiers) == 0 {
		logger.Error("cashiers is nil")
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	if len(req.ErpOrderCommodities) == 0 {
		logger.Error("commodities is nil")
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	jCashier, err := json.Marshal(req.Cashiers)
	if err != nil {
		logger.Error("cashiers marshal err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}
	sysUser, err := model.GetSysUserByCtx(c)
	if err != nil {
		logger.Error("sys user err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}
	if sysUser.StoreId == 0 {
		logger.Error("sys user store id null")
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	var originErpOrder model.ErpOrder
	err = orm.Eloquent.Table("erp_order").Where("id=?", req.Id).Find(&originErpOrder).Error
	if err != nil {
		logger.Error("origin erp order err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}

	erpOrder := &model.ErpOrder{
		BillSn:     originErpOrder.BillSn,
		RetailType: req.RetailType,
		Tel:        req.Tel,
		StoreId:    sysUser.StoreId,
		StoreName:  sysUser.StoreName,
		MakerId:    uint32(originErpOrder.MakerId),
		MakerName:  originErpOrder.MakerName,
		//AuditTime:   time.Now(),
		//AuditorId:   uint32(sysUser.UserId),
		//AuditorName: sysUser.NickName,
		CashierList: string(jCashier),
		Salesman1:   req.Salesman1,
		Salesman2:   req.Salesman2,
		MemberType:  req.MemberType,
		State:       model.ErpOrderStateUnAudit,
	}
	erpOrder.ID = req.Id
	commodityMap := make(map[uint32]model.ErpCommodity)
	if req.RetailType == model.RetailTypeSale {
		commodityIds := make([]uint32, 0, len(req.ErpOrderCommodities))
		for i, _ := range req.ErpOrderCommodities {
			commodityIds = append(commodityIds, req.ErpOrderCommodities[i].ErpCommodityId)
		}
		var commodities []model.ErpCommodity
		err = orm.Eloquent.Table("erp_commodity").Where("id IN (?)", commodityIds).Find(&commodities).Error
		if err != nil {
			logger.Error("commodities err:", err)
			app.Error(c, http.StatusInternalServerError, err, "操作失败")
			return
		}

		for i, _ := range commodities {
			commodityMap[commodities[i].ID] = commodities[i]
		}

		model.SetUserInfo(req.Tel)
	}

	var orderCommodityMap map[uint32]model.ErpOrderCommodity
	if req.RetailType == model.RetailTypeRejected {
		ids := make([]uint32, 0, len(req.ErpOrderCommodities))
		for i, _ := range req.ErpOrderCommodities {
			ids = append(ids, req.ErpOrderCommodities[i].RejectedOrderCommodityId)
		}
		orderCommodityMap, err = model.GetErpOrderCommodityMap(ids)
		if err != nil {
			logger.Error("order commodity map err:", err)
			return
		}
	}

	begin := orm.Eloquent.Begin()
	err = begin.Table("erp_order_commodity").Where("erp_order_id=?", req.Id).Delete(&model.ErpOrderCommodity{}).Error
	if err != nil {
		begin.Rollback()
		logger.Error("commodities err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}

	err = begin.Save(erpOrder).Error
	if err != nil {
		begin.Rollback()
		logger.Error("create erp order err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}

	for i, _ := range req.ErpOrderCommodities {
		req.ErpOrderCommodities[i].ErpOrderId = erpOrder.ID

		if req.RetailType == model.RetailTypeRejected {
			v, ok := orderCommodityMap[req.ErpOrderCommodities[i].RejectedOrderCommodityId]
			if ok {
				v.RejectedPrice = req.ErpOrderCommodities[i].RejectedPrice
				v.RejectedCount = req.ErpOrderCommodities[i].RejectedCount
				v.RejectedAmount = v.RejectedCount * v.RejectedPrice
			} else {
				logger.Error("rejected order commodity id is null")
				return
			}
			v.ID = 0
			req.ErpOrderCommodities[i] = v
			// 添加库存 TODO
			if req.ErpOrderCommodities[i].RejectedPrice > req.ErpOrderCommodities[i].RetailPrice {
				logger.Error("rejected price gt retail price ")
				app.Error(c, http.StatusInternalServerError, err, "操作失败")
				return
			}
			if req.ErpOrderCommodities[i].RejectedCount > req.ErpOrderCommodities[i].Count {
				logger.Error("rejected count gt retail count ")
				app.Error(c, http.StatusInternalServerError, err, "操作失败")
				return
			}

		} else if req.RetailType == model.RetailTypeSale {

			v, ok := commodityMap[req.ErpOrderCommodities[i].ErpCommodityId]
			if ok {
				req.ErpOrderCommodities[i].ErpCommodityName = v.Name
				req.ErpOrderCommodities[i].ErpCategoryId = v.ErpCategoryId
				req.ErpOrderCommodities[i].ErpCategoryName = v.ErpCategoryName
				req.ErpOrderCommodities[i].RetailPrice = v.RetailPrice
				//req.ErpOrderCommodities[i].MemberPrice = v.MemberPrice
			}
			if req.ErpOrderCommodities[i].PresentType == 2 {
				req.ErpOrderCommodities[i].RetailPrice = 0
			}

			// 减库存 TODO
			if erpOrder.MemberType == model.ErpOrderMemberTypeMember {
				req.ErpOrderCommodities[i].Amount = req.ErpOrderCommodities[i].Count * req.ErpOrderCommodities[i].MemberPrice
			} else {
				req.ErpOrderCommodities[i].Amount = req.ErpOrderCommodities[i].Count * req.ErpOrderCommodities[i].RetailPrice
			}
		}

		erpOrder.TotalAmount += req.ErpOrderCommodities[i].Amount
		erpOrder.TotalCount += req.ErpOrderCommodities[i].Count
	}

	err = begin.Create(&req.ErpOrderCommodities).Error
	if err != nil {
		begin.Rollback()
		logger.Error("Create")
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}
	err = begin.Commit().Error
	if err != nil {
		begin.Rollback()
		logger.Error("commit err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}
	erpOrder.Commodities = req.ErpOrderCommodities
	erpOrder.Cashiers = req.Cashiers

	app.OK(c, erpOrder, "")
	return
}

// 串码查询商品详情
func ErpOrderDetail(c *gin.Context) {
	req := &struct {
		ErpOrderId uint32 `json:"erp_order_id"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	var order model.ErpOrder
	err := orm.Eloquent.Table("erp_order").Where("id = ?", req.ErpOrderId).Find(&order).Error
	if err != nil {
		logger.Error("order err:", err)
		app.Error(c, http.StatusInternalServerError, err, "查询失败")
		return
	}
	var orderCommodities []model.ErpOrderCommodity
	err = orm.Eloquent.Table("erp_order_commodity").Where("erp_order_id=?", req.ErpOrderId).Find(&orderCommodities).Error
	if err != nil {
		logger.Error("order commodities err:", err)
		app.Error(c, http.StatusInternalServerError, err, "查询失败")
		return
	}
	order.Commodities = orderCommodities
	order.SetErpCashier()

	app.OK(c, order, "")
	return
}

// 串码查询商品详情
func ErpOrderDel(c *gin.Context) {
	req := &struct {
		ErpOrderId uint32 `json:"erp_order_id"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	err := orm.Eloquent.Table("erp_order").Where("id = ?", req.ErpOrderId).Delete(&model.ErpOrder{}).Error
	if err != nil {
		logger.Error("order err:", err)
		app.Error(c, http.StatusInternalServerError, err, "查询失败")
		return
	}

	app.OK(c, nil, "")
	return
}

func ErpOrderCommodityList(c *gin.Context) {
	req := &struct {
		Tel              string `json:"tel"`
		IMEI             string `json:"imei"`
		ErpCommodityName string `json:"erp_commodity_name"`
		ErpCategoryId    uint32 `json:"erp_category_id"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	var commodities []model.ErpOrderCommodity
	qs := orm.Eloquent.Table("erp_order_commodity")
	if req.Tel != "" {
		qs = qs.Where("tel=?", req.Tel)
	}
	if req.IMEI != "" {
		qs = qs.Where("imei=?", req.IMEI)
	}
	if req.ErpCommodityName != "" {
		qs = qs.Where("erp_commodity_name=?", req.ErpCommodityName)
	}
	if req.ErpCategoryId != 0 {
		qs = qs.Where("erp_category_id=?", req.ErpCategoryId)
	}
	err := qs.Order("id DESC").Find(&commodities).Error
	if err != nil {
		logger.Error("erp commodity list err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}

	app.OK(c, commodities, "")
	return
}

func ShopAssistantList(c *gin.Context) {
	req := &struct {
		StoreId uint32 `json:"store_id"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	//sysUser, err := model.GetSysUserByCtx(c)
	//if err != nil {
	//	logger.Error("sys user err:", err)
	//	app.Error(c, http.StatusUnauthorized, errors.New("para err"), "参数错误")
	//	return
	//}
	//req.StoreId = sysUser.StoreId
	var users []model.UserInfo
	qs := orm.Eloquent.Table("user").Where("user_type=2")
	if req.StoreId != 0 {
		qs = qs.Where("store_id=?", req.StoreId)
	} else {
		//sysUser, err := model.GetSysUserByCtx(c)
		//if err != nil {
		//	logger.Error("sys user err:", err)
		//	app.Error(c, http.StatusUnauthorized, errors.New("para err"), "参数错误")
		//	return
		//}
		//qs = qs.Where("cooperative_business_id=?", sysUser.CooperativeBusinessId)
	}

	err := qs.Order("id DESC").Find(&users).Error
	if err != nil {
		logger.Error("erp commodity list err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}

	app.OK(c, users, "")
	return
}

func ErpOrderAudit(c *gin.Context) {
	req := &struct {
		ErpOrderId uint32 `json:"erp_order_id"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	err := orm.Eloquent.Table("erp_order").Where("id = ?", req.ErpOrderId).Update("state", model.ErpOrderStateAudited).Error
	if err != nil {
		logger.Error("order err:", err)
		app.Error(c, http.StatusInternalServerError, err, "审核失败")
		return
	}

	app.OK(c, nil, "")
	return
}