package ebai

import (
	"time"

	"git.rosy.net.cn/baseapi/platformapi/autonavi"
	"git.rosy.net.cn/baseapi/platformapi/ebaiapi"
	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/jxutils"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/business/partner"
	"git.rosy.net.cn/jx-callback/globals"
	"git.rosy.net.cn/jx-callback/globals/api"
)

var (
	VendorStatus2StatusMap = map[string]int{
		ebaiapi.OrderStatusNew:             model.OrderStatusNew,
		ebaiapi.OrderStatusAccepted:        model.OrderStatusAccepted,
		ebaiapi.OrderStatusCourierAccepted: model.OrderStatusDelivering,
		ebaiapi.OrderStatusCourierPickedup: model.OrderStatusDelivering,
		ebaiapi.OrderStatusFinished:        model.OrderStatusFinished,
		ebaiapi.OrderStatusCanceled:        model.OrderStatusCanceled,
	}
)

func (p *PurchaseHandler) GetStatusFromVendorStatus(vendorStatus string) int {
	if status, ok := VendorStatus2StatusMap[vendorStatus]; ok {
		return status
	}
	return model.OrderStatusUnknown
}

func (p *PurchaseHandler) GetOrder(vendorOrderID string) (order *model.GoodsOrder, err error) {
	result, err := api.EbaiAPI.OrderGet(vendorOrderID)
	// globals.SugarLogger.Info(result)
	if err == nil {
		shopMap := result["shop"].(map[string]interface{})
		orderMap := result["order"].(map[string]interface{})
		userMap := result["user"].(map[string]interface{})
		order = &model.GoodsOrder{
			VendorOrderID:         vendorOrderID,
			VendorID:              model.VendorIDEBAI,
			VendorStoreID:         shopMap["baidu_shop_id"].(string),
			StoreID:               int(utils.Str2Int64WithDefault(utils.Interface2String(shopMap["id"]), 0)),
			StoreName:             shopMap["name"].(string),
			ConsigneeName:         userMap["name"].(string),
			ConsigneeMobile:       userMap["phone"].(string),
			ConsigneeAddress:      userMap["address"].(string),
			CoordinateType:        model.CoordinateTypeBaiDu,
			BuyerComment:          utils.TrimBlankChar(utils.Interface2String(orderMap["remark"])),
			ExpectedDeliveredTime: getTimeFromTimestampStr(utils.Interface2String(orderMap["send_time"])),
			VendorStatus:          utils.Int64ToStr(utils.MustInterface2Int64(orderMap["status"])),
			OrderSeq:              int(utils.Str2Int64(utils.Interface2String(orderMap["order_index"]))),
			StatusTime:            getTimeFromTimestampStr(utils.Interface2String(orderMap["create_time"])),
			OriginalData:          string(utils.MustMarshal(result)),
			ActualPayPrice:        utils.MustInterface2Int64(orderMap["user_fee"]),
			Skus:                  []*model.OrderSku{},
		}
		order.Status = p.GetStatusFromVendorStatus(order.VendorStatus)
		if utils.MustInterface2Int64(orderMap["send_immediately"]) == 1 {
			order.BusinessType = model.BusinessTypeImmediate
		} else {
			order.BusinessType = model.BusinessTypeDingshida
		}

		deliveryGeo := userMap["coord"].(map[string]interface{})
		originalLng := utils.MustInterface2Float64(deliveryGeo["longitude"])
		originalLat := utils.MustInterface2Float64(deliveryGeo["latitude"])
		lng, lat, err2 := api.AutonaviAPI.CoordinateConvert(originalLng, originalLat, autonavi.CoordSysBaidu)
		if err2 == nil {
			originalLng = lng
			originalLat = lat
			order.CoordinateType = model.CoordinateTypeMars
		}
		order.ConsigneeLng = jxutils.StandardCoordinate2Int(originalLng)
		order.ConsigneeLat = jxutils.StandardCoordinate2Int(originalLat)

		products := result["products"].([]interface{})[0].([]interface{})
		// discounts := result["discount"].(map[string]interface{})
		for _, product2 := range products {
			product := product2.(map[string]interface{})
			sku := &model.OrderSku{
				VendorOrderID: order.VendorOrderID,
				VendorID:      model.VendorIDEBAI,
				Count:         int(utils.MustInterface2Int64(product["product_amount"])),
				SkuID:         int(utils.Str2Int64WithDefault(utils.Interface2String(product["custom_sku_id"]), 0)),
				VendorSkuID:   utils.Interface2String(product["baidu_product_id"]),
				SkuName:       product["product_name"].(string),
				Weight:        0, // todo
				SalePrice:     utils.MustInterface2Int64(product["product_price"]),
				// PromotionType: int(utils.MustInterface2Int64(product["promotionType"])),
			}
			// if product["isGift"].(bool) {
			// 	sku.SkuType = 1
			// }
			order.Skus = append(order.Skus, sku)
			order.SkuCount++
			order.GoodsCount += sku.Count
			order.SalePrice += sku.SalePrice * int64(sku.Count)
			order.Weight += sku.Weight * sku.Count
		}
		// setOrederDetailFee(result, order)
	}
	return order, err
}

func (p *PurchaseHandler) AcceptOrRefuseOrder(order *model.GoodsOrder, isAcceptIt bool, userName string) (err error) {
	if globals.EnableStoreWrite && globals.EnableEbaiStoreWrite {
		if isAcceptIt {
			err = api.EbaiAPI.OrderConfirm(order.VendorOrderID)
		} else {
			err = api.EbaiAPI.OrderCancel(order.VendorOrderID, ebaiapi.CancelTypeCustom, "bu")
		}
	}
	return err
}

func (p *PurchaseHandler) PickupGoods(order *model.GoodsOrder, userName string) (err error) {
	if globals.EnableStoreWrite && globals.EnableEbaiStoreWrite {
		err = api.EbaiAPI.OrderCallDelivery(order.VendorOrderID)
	}
	return err
}

// 将订单从购物平台配送转为自送
func (p *PurchaseHandler) Swtich2SelfDeliver(order *model.GoodsOrder, userName string) (err error) {
	if globals.EnableStoreWrite && globals.EnableEbaiStoreWrite {
		err = api.EbaiAPI.OrderSwitchselfdelivery(order.VendorOrderID)
	}
	return err
}

// 将订单从购物平台配送转为自送后又送达
func (p *PurchaseHandler) Swtich2SelfDelivered(order *model.GoodsOrder, userName string) (err error) {
	// todo 饿百转商家自送后，没有确认送达的概念，空操作
	return err
}

// 完全自送的门店表示开始配送
func (p *PurchaseHandler) SelfDeliverDelivering(order *model.GoodsOrder, userName string) (err error) {
	if globals.EnableStoreWrite && globals.EnableEbaiStoreWrite {
		err = api.EbaiAPI.OrderSendOut(order.VendorOrderID, userName)
	}
	return err
}

// 完全自送的门店表示配送完成
func (p *PurchaseHandler) SelfDeliverDelievered(order *model.GoodsOrder, userName string) (err error) {
	if globals.EnableStoreWrite && globals.EnableEbaiStoreWrite {
		err = api.EbaiAPI.OrderComplete(order.VendorOrderID, userName)
	}
	return err
}

//
func (c *PurchaseHandler) onOrderMsg(msg *ebaiapi.CallbackMsg) (retVal *ebaiapi.CallbackResponse) {
	if ebaiapi.CmdOrderCreate == msg.Cmd {
		retVal = c.onOrderNew(msg)
	} else {
		status := c.callbackMsg2Status(msg)
		err := partner.CurOrderManager.OnOrderStatusChanged(status)
		retVal = api.EbaiAPI.Err2CallbackResponse(msg.Cmd, err, nil)
	}
	return retVal
}

func (c *PurchaseHandler) onOrderNew(msg *ebaiapi.CallbackMsg) (response *ebaiapi.CallbackResponse) {
	vendorOrderID := msg.Body["order_id"].(string)
	order, err := c.GetOrder(vendorOrderID)
	if err == nil {
		err = partner.CurOrderManager.OnOrderNew(order, order.VendorStatus)
	}
	return api.EbaiAPI.Err2CallbackResponse(msg.Cmd, err, map[string]interface{}{
		"source_order_id": vendorOrderID,
	})
}

func (c *PurchaseHandler) callbackMsg2Status(msg *ebaiapi.CallbackMsg) *model.OrderStatus {
	body := msg.Body
	vendorStatus := utils.Int64ToStr(utils.MustInterface2Int64(body["status"]))
	orderID := utils.Int64ToStr(utils.MustInterface2Int64(msg.Body["order_id"]))
	orderStatus := &model.OrderStatus{
		VendorOrderID:    orderID,
		VendorID:         model.VendorIDEBAI,
		OrderType:        model.OrderTypeOrder,
		RefVendorOrderID: orderID,
		RefVendorID:      model.VendorIDEBAI,
		VendorStatus:     vendorStatus,
		Status:           c.GetStatusFromVendorStatus(vendorStatus),
		StatusTime:       utils.Timestamp2Time(msg.Timestamp),
		Remark:           utils.Interface2String(body["reason"]),
	}
	return orderStatus
}

func getTimeFromTimestampStr(sendTime string) time.Time {
	timeStamp := utils.Str2Int64WithDefault(sendTime, 0)
	if timeStamp < 1538103149 { // 立即达订单给的是1（而不是空，0），1538103149不是特殊值，只是一个任意之前的时间，这样写可以处理
		return utils.DefaultTimeValue
	}
	return utils.Timestamp2Time(timeStamp)
}