package controller

import (
	"encoding/json"
	"github.com/codinl/go-logger"
	"github.com/gin-gonic/gin"
	"mh-server/lib/auth"
	"mh-server/lib/status"
	"time"

	"mh-server/model"
)

func ErpOrderList(c *gin.Context) {
	req := &model.ErpOrderListReq{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}

	resp, err := req.List()
	if err != nil {
		logger.Error("erp commodity list err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(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("para err:", err)
		RespJson(c, status.BadRequest, nil)
		return
	}

	if len(req.Cashiers) == 0 {
		logger.Error("cashiers is nil")
		RespJson(c, status.BadRequest, nil)
		return
	}
	if len(req.ErpOrderCommodities) == 0 {
		logger.Error("commodities is nil")
		RespJson(c, status.BadRequest, nil)
		return
	}
	jCashier, err := json.Marshal(req.Cashiers)
	if err != nil {
		logger.Error("cashiers marshal err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	uc := auth.GetCurrentUser(c)
	if uc == nil {
		logger.Error("uc is nil")
		RespJson(c, status.Unauthorized, nil)
		return
	}

	//uc := &auth.UserClaims{Uid: 8588420}
	assistant := model.GetUserByUid(uc.Uid)
	if assistant.UserType != 2 {
		logger.Error("not assistant")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	store, err := model.GetStore(uint32(assistant.StoreId))
	if err != nil {
		logger.Error("assistant store err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	erpOrder := &model.ErpOrder{
		BillSn:      model.NewErpBillSn(),
		RetailType:  req.RetailType,
		Tel:         req.Tel,
		StoreId:     uint32(assistant.StoreId),
		StoreName:   store.Name,
		MakerId:     assistant.Uid,
		MakerName:   assistant.ShopAssistantName,
		AuditTime:   time.Now(),
		AuditorId:   assistant.Uid,
		AuditorName: assistant.ShopAssistantName,
		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 = model.DB.Table("erp_commodity").Where("id IN (?)", commodityIds).Find(&commodities).Error
		if err != nil {
			logger.Error("commodities err:", err)
			RespJson(c, status.InternalServerError, nil)
			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 := model.DB.Begin()
	err = begin.Create(erpOrder).Error
	if err != nil {
		begin.Rollback()
		logger.Error("create erp order err:", err)
		RespJson(c, status.InternalServerError, nil)
		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 {
				begin.Rollback()
				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 {
				begin.Rollback()
				logger.Error("rejected price gt retail price ")
				RespJson(c, status.InternalServerError, nil)
				return
			}
			if req.ErpOrderCommodities[i].RejectedCount > req.ErpOrderCommodities[i].Count {
				begin.Rollback()
				logger.Error("rejected count gt retail count ")
				RespJson(c, status.InternalServerError, nil)
				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
	}

	for _, commodity := range req.ErpOrderCommodities {
		err = begin.Create(&commodity).Error
		if err != nil {
			begin.Rollback()
			logger.Error("create err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
	}
	//err = begin.Create(orderCommodities).Error
	//if err != nil {
	//	begin.Rollback()
	//	logger.Error("Create")
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	err = begin.Commit().Error
	if err != nil {
		begin.Rollback()
		logger.Error("commit err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	erpOrder.Commodities = req.ErpOrderCommodities
	erpOrder.Cashiers = req.Cashiers

	RespOK(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("para err:", err)
		RespJson(c, status.BadRequest, nil)
		return
	}

	if len(req.Cashiers) == 0 {
		logger.Error("cashiers is nil")
		RespJson(c, status.BadRequest, nil)
		return
	}
	if len(req.ErpOrderCommodities) == 0 {
		logger.Error("commodities is nil")
		RespJson(c, status.BadRequest, nil)
		return
	}
	jCashier, err := json.Marshal(req.Cashiers)
	if err != nil {
		logger.Error("cashiers marshal err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	uc := auth.GetCurrentUser(c)
	if uc == nil {
		logger.Error("uc is nil")
		RespJson(c, status.Unauthorized, nil)
		return
	}

	//uc := &auth.UserClaims{Uid: 8588420}
	assistant := model.GetUserByUid(uc.Uid)
	if assistant.UserType != 2 {
		logger.Error("not assistant")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	store, err := model.GetStore(uint32(assistant.StoreId))
	if err != nil {
		logger.Error("assistant store err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	var originErpOrder model.ErpOrder
	err = model.DB.Table("erp_order").Where("id=?", req.Id).Find(&originErpOrder).Error
	if err != nil {
		logger.Error("origin erp order err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	erpOrder := &model.ErpOrder{
		BillSn:      originErpOrder.BillSn,
		RetailType:  req.RetailType,
		Tel:         req.Tel,
		StoreId:     uint32(assistant.StoreId),
		StoreName:   store.Name,
		MakerId:     uint32(originErpOrder.MakerId),
		MakerName:   originErpOrder.MakerName,
		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 = model.DB.Table("erp_commodity").Where("id IN (?)", commodityIds).Find(&commodities).Error
		if err != nil {
			logger.Error("commodities err:", err)
			RespJson(c, status.InternalServerError, nil)
			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 := model.DB.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)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	err = begin.Save(erpOrder).Error
	if err != nil {
		begin.Rollback()
		logger.Error("create erp order err:", err)
		RespJson(c, status.InternalServerError, nil)
		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 ")
				RespJson(c, status.InternalServerError, nil)
				return
			}
			if req.ErpOrderCommodities[i].RejectedCount > req.ErpOrderCommodities[i].Count {
				logger.Error("rejected count gt retail count ")
				RespJson(c, status.InternalServerError, nil)
				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
	}

	for _, commodity := range req.ErpOrderCommodities {
		err = begin.Create(&commodity).Error
		if err != nil {
			begin.Rollback()
			logger.Error("create erp order commodities err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
	}
	err = begin.Commit().Error
	if err != nil {
		begin.Rollback()
		logger.Error("commit err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	erpOrder.Commodities = req.ErpOrderCommodities
	erpOrder.Cashiers = req.Cashiers

	RespOK(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)
		RespJson(c, status.BadRequest, nil)
		return
	}
	var order model.ErpOrder
	err := model.DB.Table("erp_order").Where("id = ?", req.ErpOrderId).Find(&order).Error
	if err != nil {
		logger.Error("order err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	var orderCommodities []model.ErpOrderCommodity
	err = model.DB.Table("erp_order_commodity").Where("erp_order_id=?", req.ErpOrderId).Find(&orderCommodities).Error
	if err != nil {
		logger.Error("order commodities err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	order.Commodities = orderCommodities
	order.SetErpCashier()

	RespOK(c, order)
	return
}

func ErpOrderCommodityList(c *gin.Context) {
	req := &struct {
		Tel              string `json:"tel"`
		IMEI             string `json:"imei"`
		ErpCategoryId    uint32 `json:"erp_category_id"`
		ErpCommodityName string `json:"erp_commodity_name"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}

	var commodities []model.ErpOrderCommodity
	qs := model.DB.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)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(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)
		RespJson(c, status.BadRequest, nil)
		return
	}

	uc := auth.GetCurrentUser(c)
	if uc == nil {
		logger.Error("uc is nil")
		RespJson(c, status.Unauthorized, nil)
		return
	}

	//uc = &auth.UserClaims{Uid: 8588420}
	assistant := model.GetUserByUid(uc.Uid)
	if assistant.UserType != 2 {
		logger.Error("not assistant")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	req.StoreId = uint32(assistant.StoreId)
	var users []model.User
	qs := model.DB.Table("user").Where("user_type=2")
	if req.StoreId != 0 {
		qs = qs.Where("store_id=?", req.StoreId)
	}

	err := qs.Order("id DESC").Find(&users).Error
	if err != nil {
		logger.Error("erp commodity list err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(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)
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		logger.Error("uc is nil")
		RespJson(c, status.Unauthorized, nil)
		return
	}

	//uc = &auth.UserClaims{Uid: 8588420}
	assistant := model.GetUserByUid(uc.Uid)
	if assistant.UserType != 2 {
		logger.Error("not assistant")
		RespJson(c, status.InternalServerError, nil)
		return
	}

	err := model.DB.Table("erp_order").Where("id = ?", req.ErpOrderId).Updates(map[string]interface{}{
		"state":        model.ErpOrderStateAudited,
		"audit_time":   time.Now(),
		"auditor_id":   uc.Uid,
		"auditor_name": assistant.ShopAssistantName,
	}).Error
	if err != nil {
		logger.Error("order err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, nil)
	return
}

func ErpCashierStoreList(c *gin.Context) {
	req := struct {
		StoreId  uint32 `json:"store_id"`
		PageNum  int    `json:"page_num"`
		PageSize int    `json:"page_size"`
		//IsExport uint32 `json:"is_export"` // 1-导出
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}
	//uc := auth.GetCurrentUser(c)
	//if uc == nil {
	//	logger.Error("uc is nil")
	//	RespJson(c, status.Unauthorized, nil)
	//	return
	//}

	////uc = &auth.UserClaims{Uid: 8588420}
	//assistant := model.GetUserByUid(uc.Uid)
	//if assistant.UserType != 2 {
	//	logger.Error("not assistant")
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	//req.StoreId = uint32(assistant.StoreId)

	resp := &model.ErpCashierStoreListResp{
		PageNum:  req.PageNum,
		PageSize: req.PageSize,
	}
	page := req.PageNum - 1
	if page < 0 {
		page = 0
	}
	if req.PageSize == 0 {
		req.PageSize = 10
	}

	qs := model.DB.Table("erp_store_cashier")
	if req.StoreId != 0 {
		qs = qs.Where("store_id=?", req.StoreId)
	}
	var count int64
	err := qs.Count(&count).Error
	if err != nil {
		logger.Error("count err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	resp.Total = int(count)/req.PageSize + 1
	var categories []model.ErpStoreCashier
	//if req.IsExport == 1 {
	//	//err = qs.Order("id DESC").Find(&categories).Error
	//	//if err != nil && err != model.RecordNotFound {
	//	//	logger.Error("dailys err:", err)
	//	//	RespJson(c, status.InternalServerError, nil)
	//	//	return
	//	//}
	//	//
	//	//listExport, err := model.ErpStoreCashierListExport(categories)
	//	//if err != nil {
	//	//	logger.Error("list export err:", err)
	//	//	RespJson(c, status.InternalServerError, nil)
	//	//	return
	//	//}
	//	//resp.ExportUrl = listExport
	//} else {
	//}
	err = qs.Order("id DESC").Offset(page * req.PageSize).Limit(req.PageSize).Find(&categories).Error
	if err != nil && err != model.RecordNotFound {
		logger.Error("erp commodity list err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	resp.List = categories

	RespOK(c, resp)
	return
}

// 串码查询商品详情
func ErpOrderDel(c *gin.Context) {
	req := &struct {
		ErpOrderId uint32 `json:"erp_order_id"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}

	err := model.DB.Table("erp_order").Where("id = ?", req.ErpOrderId).Delete(&model.ErpOrder{}).Error
	if err != nil {
		logger.Error("order del err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, nil)
	return
}

func UserInfoList(c *gin.Context) {
	req := &struct {
		Tel string `json:"tel"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}

	var users []model.User
	err := model.DB.Table("user").Where("tel LIKE '%" + req.Tel + "%'").Find(&users).Error
	//err := model.NewUserQuerySet(model.DB).TelLike(req.Tel).All(&users)
	if err != nil {
		logger.Error("erp commodity list err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, users)
	return
}

func ErpCommodityList(c *gin.Context) {
	req := &model.ErpCommodityListReq{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}

	resp, err := req.List()
	if err != nil {
		logger.Error("erp commodity list err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, resp)
	return
}