package jd

import (
	"git.rosy.net.cn/baseapi/platformapi/jdapi"
	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/controller"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/globals"
	"git.rosy.net.cn/jx-callback/globals/api"
)

type OrderController struct {
}

func init() {
	controller.OrderManager.RegisterPurchasePlatform(controller.VendorIDELM, new(OrderController))
}

func (c *OrderController) OnOrderMsg(msg *jdapi.CallbackOrderMsg) (retVal *jdapi.CallbackResponse) {
	controller.CallMsgHandler(func() {
		retVal = c.onOrderMsg(msg)
	}, msg.BillID)
	return retVal
}

func (c *OrderController) onOrderMsg(msg *jdapi.CallbackOrderMsg) (retVal *jdapi.CallbackResponse) {
	if jdapi.OrderStatusNew == msg.StatusID || jdapi.OrderStatusAdjust == msg.StatusID {
		retVal = c.onOrderNew(msg)
	} else {
		status := c.callbackMsg2Status(msg)
		switch msg.StatusID {
		case jdapi.OrderStatusWaitOutStore:
			status.Status = controller.OrderStatusAccepted
		case jdapi.OrderStatusFinishedPickup:
			status.Status = controller.OrderStatusFinishedPickup
		case jdapi.OrderStatusDelivering:
			status.Status = controller.OrderStatusDelivering
		case jdapi.OrderStatusDelivered:
			status.Status = controller.OrderStatusDelivered
		case jdapi.OrderStatusCanceled:
			status.Status = controller.OrderStatusCanceled
		case jdapi.OrderStatusUserApplyCancel:
			status.Status = controller.OrderStatusApplyCancel
		default:
			status.Status = controller.OrderStatusUnknown
		}
		retVal = jdapi.Err2CallbackResponse(controller.OrderManager.OnOrderStatusChanged(status), status.VendorStatus)
	}
	return retVal
}

func (c *OrderController) getOrderInfo(msg *jdapi.CallbackOrderMsg) (order *model.GoodsOrder, orderSkus []*model.OrderSku, err error) {
	result, err := api.JdAPI.QuerySingleOrder(msg.BillID)
	// globals.SugarLogger.Info(result)
	if err == nil {
		order = &model.GoodsOrder{
			VendorOrderID:    msg.BillID,
			VendorID:         controller.VendorIDJD,
			VendorStoreID:    result["produceStationNo"].(string),
			StoreID:          int(utils.Str2Int64WithDefault(utils.Interface2String(result["produceStationNoIsv"]), 0)),
			StoreName:        result["produceStationName"].(string),
			ConsigneeName:    result["buyerFullName"].(string),
			ConsigneeMobile:  result["buyerMobile"].(string),
			ConsigneeAddress: result["buyerFullAddress"].(string),
			ConsigneeLat:     controller.StandardCoordinate2Int(utils.MustInterface2Float64(result["buyerLat"])),
			ConsigneeLng:     controller.StandardCoordinate2Int(utils.MustInterface2Float64(result["buyerLng"])),
			CoordinateType:   controller.CoordinateTypeMars,
			VendorStatus:     msg.StatusID,
			OrderCreatedAt:   utils.Str2Time(result["orderPurchaseTime"].(string)),
			OriginalData:     string(utils.MustMarshal(result)),
		}
		// discounts := result["discount"].(map[string]interface{})
		orderSkus = []*model.OrderSku{}
		for _, product2 := range result["product"].([]interface{}) {
			product := product2.(map[string]interface{})
			sku := &model.OrderSku{
				VendorOrderID:  msg.BillID,
				VendorID:       controller.VendorIDJD,
				Count:          int(utils.MustInterface2Int64(product["skuCount"])),
				SkuID:          int(utils.Str2Int64WithDefault(utils.Interface2String(product["skuIdIsv"]), 0)),
				VendorSkuID:    utils.Int64ToStr(utils.MustInterface2Int64(product["skuId"])),
				SkuName:        product["skuName"].(string),
				Weight:         int(utils.MustInterface2Float64(product["skuWeight"]) * 1000),
				SalePrice:      utils.MustInterface2Int64(product["skuJdPrice"]),
				OrderCreatedAt: order.OrderCreatedAt,
			}
			orderSkus = append(orderSkus, sku)
			order.SkuCount++
			order.GoodsCount += sku.Count
			order.SalePrice += sku.SalePrice
			order.Weight += sku.Weight
		}
	}
	return order, orderSkus, err
}

//
func (c *OrderController) onOrderNew(msg *jdapi.CallbackOrderMsg) (response *jdapi.CallbackResponse) {
	order, orderSkus, err := c.getOrderInfo(msg)
	if err == nil {
		err = controller.OrderManager.OnOrderNew(order, orderSkus)
	} else {
		globals.SugarLogger.Debugf("get order error:%v", err)
	}
	return jdapi.Err2CallbackResponse(err, "jd onOrderNew")
}

func (c *OrderController) onOrderAdjust(msg *jdapi.CallbackOrderMsg) *jdapi.CallbackResponse {
	order, orderSkus, err := c.getOrderInfo(msg)
	if err == nil {
		err = controller.OrderManager.OnOrderAdjust(order, orderSkus)
	}
	return jdapi.Err2CallbackResponse(err, "jd onOrderAdjust")
}

// PurchasePlatformHandler
func (c *OrderController) AcceptOrRefuseOrder(order *model.GoodsOrder, isAcceptIt bool) {
	api.JdAPI.OrderAcceptOperate(order.VendorOrderID, isAcceptIt)
}

func (c *OrderController) callbackMsg2Status(msg *jdapi.CallbackOrderMsg) *model.OrderStatus {
	orderStatus := &model.OrderStatus{
		VendorOrderID: msg.BillID,
		VendorID:      controller.VendorIDJD,
		OrderType:     controller.OrderTypeOrder,
		VendorStatus:  msg.StatusID,
		StatusTime:    utils.Str2Time(msg.Timestamp),
	}
	return orderStatus
}