package elm

import (
	"fmt"
	"math"

	"git.rosy.net.cn/jx-callback/globals"
	"git.rosy.net.cn/jx-callback/globals/api"

	"git.rosy.net.cn/baseapi/platformapi/elmapi"
	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/controller"
	"git.rosy.net.cn/jx-callback/business/model"
)

type OrderController struct {
	controller.OrderController
}

func (c *OrderController) OnOrderStatusMsg(msg *elmapi.CallbackOrderStatusMsg) (retVal *elmapi.CallbackResponse) {
	controller.RoutinePool.CallFun(func() {
		retVal = c.onOrderStatusMsg(msg)
	}, msg.OrderID)
	return retVal
}

func (c *OrderController) OnOrderNewMsg(msg map[string]interface{}) (retVal *elmapi.CallbackResponse) {
	controller.RoutinePool.CallFun(func() {
		retVal = c.onOrderNew(msg)
	}, msg["orderId"].(string))
	return retVal
}

func (c *OrderController) OnOrderCancelRefundMsg(msg *elmapi.CallbackOrderCancelRefundMsg) (retVal *elmapi.CallbackResponse) {
	controller.RoutinePool.CallFun(func() {
		retVal = c.onOrderCancelRefundMsg(msg)
	}, msg.OrderID)
	return retVal
}

func (c *OrderController) orderStatusMsg2Status(msg *elmapi.CallbackOrderStatusMsg) *model.OrderStatus {
	orderStatus := &model.OrderStatus{
		VendorOrderID: msg.OrderID,
		VendorID:      controller.VendorIDELM,
		OrderType:     controller.OrderTypeOrder,
		VendorStatus:  fmt.Sprintf("%s-%d", msg.State, msg.MsgType),
		StatusTime:    utils.Timestamp2Time(msg.UpdateTime),
	}
	return orderStatus
}

func (c *OrderController) cancelRefundMsg2Status(msg *elmapi.CallbackOrderCancelRefundMsg) *model.OrderStatus {
	orderStatus := &model.OrderStatus{
		VendorOrderID: msg.OrderID,
		VendorID:      controller.VendorIDELM,
		OrderType:     controller.OrderTypeOrder,
		Status:        controller.OrderStatusEvent,
		VendorStatus:  utils.Int2Str(msg.MsgType),
		StatusTime:    utils.Timestamp2Time(msg.UpdateTime),
	}
	return orderStatus
}

func (c *OrderController) onOrderStatusMsg(msg *elmapi.CallbackOrderStatusMsg) (retVal *elmapi.CallbackResponse) {
	switch msg.MsgType {
	case elmapi.MsgTypeOrderAccepted:
		retVal = c.onOrderAccepted(msg)
	case elmapi.MsgTypeOrderCanceled:
		retVal = c.onOrderCanceled(msg)
	case elmapi.MsgTypeOrderInvalid:
		retVal = c.onOrderInvalid(msg)
	case elmapi.MsgTypeOrderForceInvalid:
		retVal = c.onOrderForceInvalid(msg)
	case elmapi.MsgTypeOrderFinished:
		retVal = c.onOrderFinished(msg)
	default:
		globals.SugarLogger.Warnf("elm msg:%d not handled", msg.MsgType)
		retVal = elmapi.SuccessResponse
	}
	return retVal
}

func (c *OrderController) onOrderCancelRefundMsg(msg *elmapi.CallbackOrderCancelRefundMsg) (retVal *elmapi.CallbackResponse) {
	switch msg.MsgType {
	case elmapi.MsgTypeUserApplyCancel:
		retVal = c.onOrderUserApplyCancel(msg)
	case elmapi.MsgTypeUserApplyRefund:
		retVal = c.onOrderUserApplyRefund(msg)
	default:
		retVal = c.onOrderOtherCancelRefundStatus(msg)
	}
	return retVal
}

func (c *OrderController) getOrderInfo(msg *elmapi.CallbackOrderStatusMsg) (order *model.GoodsOrder, orderSkus []*model.OrderSku, err error) {
	result, err := api.ElmAPI.GetOrder(msg.OrderID)
	if err == nil {
		phoneList := result["phoneList"].([]interface{})
		consigneeMobile := ""
		if len(phoneList) > 0 {
			consigneeMobile = phoneList[0].(string)
		}
		// globals.SugarLogger.Debug(result)
		order = &model.GoodsOrder{
			VendorOrderID:   msg.OrderID,
			VendorID:        controller.VendorIDELM,
			VendorStoreID:   utils.Int64ToStr(utils.MustInterface2Int64(result["shopId"])),
			StoreID:         int(utils.Str2Int64WithDefault(utils.Interface2String(result["openId"]), 0)),
			StoreName:       result["shopName"].(string),
			ConsigneeName:   result["consignee"].(string),
			ConsigneeMobile: consigneeMobile,
			VendorStatus:    msg.State,
			OrderCreatedAt:  utils.Str2Time(result["createdAt"].(string)),
			OriginalData:    string(utils.MustMarshal(result)),
		}

		orderSkus = []*model.OrderSku{}
		for _, group2 := range result["groups"].([]interface{}) {
			group := group2.(map[string]interface{})
			for _, product2 := range group["items"].([]interface{}) {
				product := product2.(map[string]interface{})
				sku := &model.OrderSku{
					VendorOrderID:  msg.OrderID,
					VendorID:       controller.VendorIDJD,
					Count:          int(utils.MustInterface2Int64(product["quantity"])),
					SkuID:          int(utils.Str2Int64WithDefault(utils.Interface2String(product["extendCode"]), 0)),
					VendorSkuID:    utils.Int64ToStr(utils.MustInterface2Int64(product["skuId"])),
					SkuName:        product["name"].(string),
					SalePrice:      int64(math.Round(utils.MustInterface2Float64(product["userPrice"]) * 100)),
					OrderCreatedAt: order.OrderCreatedAt,
				}
				orderSkus = append(orderSkus, sku)
				order.SkuCount++
				order.SalePrice += sku.SalePrice
			}
		}
	}

	return order, orderSkus, err
}

//
func (c *OrderController) onOrderNew(msg map[string]interface{}) (response *elmapi.CallbackResponse) {
	// todo 这里应该可以直接用msg里的内容，而不用再次去查
	fakeOrderMsg := &elmapi.CallbackOrderStatusMsg{
		OrderID: msg["orderId"].(string),
		State:   elmapi.OrderStatusFake,
	}
	order, orderSkus, err := c.getOrderInfo(fakeOrderMsg)
	if err == nil {
		err = c.OnOrderNew(c, order, orderSkus)
	}
	return elmapi.Err2CallbackResponse(err, "elm onOrderNew")
}

func (c *OrderController) onOrderAccepted(msg *elmapi.CallbackOrderStatusMsg) *elmapi.CallbackResponse {
	status := c.orderStatusMsg2Status(msg)
	err := c.OnOrderAccepted(c, status)
	if err == nil {
		status.VendorStatus = "fakeautopickup"
		err = c.OnOrderFinishedPickup(c, c.orderStatusMsg2Status(msg))
	}
	return elmapi.Err2CallbackResponse(err, "elm onOrderAccepted")
}

func (c *OrderController) onOrderCanceled(msg *elmapi.CallbackOrderStatusMsg) *elmapi.CallbackResponse {
	return elmapi.Err2CallbackResponse(c.OnOrderCanceled(c, c.orderStatusMsg2Status(msg)), "elm onOrderCanceled")
}

func (c *OrderController) onOrderInvalid(msg *elmapi.CallbackOrderStatusMsg) *elmapi.CallbackResponse {
	return c.onOrderCanceled(msg)
}

func (c *OrderController) onOrderForceInvalid(msg *elmapi.CallbackOrderStatusMsg) *elmapi.CallbackResponse {
	return c.onOrderCanceled(msg)
}

func (c *OrderController) onOrderFinished(msg *elmapi.CallbackOrderStatusMsg) *elmapi.CallbackResponse {
	return elmapi.Err2CallbackResponse(c.OnOrderDelivered(c, c.orderStatusMsg2Status(msg)), "elm onOrderFinished")
}

func (c *OrderController) onOrderUserUrgeOrder(msg *elmapi.CallbackOrderUrgeMsg) *elmapi.CallbackResponse {
	orderStatus := &model.OrderStatus{
		VendorOrderID: msg.OrderID,
		VendorID:      controller.VendorIDELM,
		OrderType:     controller.OrderTypeOrder,
		Status:        controller.OrderStatusEvent,
		VendorStatus:  utils.Int2Str(msg.MsgType),
		StatusTime:    utils.Timestamp2Time(msg.UpdateTime),
	}
	return elmapi.Err2CallbackResponse(c.OnOrderUserUrgeOrder(c, orderStatus), "elm onOrderUserUrgeOrder")
}

func (c *OrderController) onOrderUserApplyCancel(msg *elmapi.CallbackOrderCancelRefundMsg) *elmapi.CallbackResponse {
	return elmapi.Err2CallbackResponse(c.OnOrderUserApplyCancel(c, c.cancelRefundMsg2Status(msg)), "elm onOrderUserApplyCancel")
}

func (c *OrderController) onOrderUserApplyRefund(msg *elmapi.CallbackOrderCancelRefundMsg) *elmapi.CallbackResponse {
	return elmapi.Err2CallbackResponse(c.OnOrderUserApplyRefund(c, c.cancelRefundMsg2Status(msg)), "elm onOrderUserApplyRefund")
}

func (c *OrderController) onOrderOtherCancelRefundStatus(msg *elmapi.CallbackOrderCancelRefundMsg) *elmapi.CallbackResponse {
	return elmapi.Err2CallbackResponse(c.OnOrderOtherStatus(c, c.cancelRefundMsg2Status(msg)), "elm onOrderOtherCancelRefundStatus")
}

// PurchasePlatformHandler
func (c *OrderController) AcceptOrRefuseOrder(order *model.GoodsOrder, isAcceptIt bool) {
	if isAcceptIt {
		api.ElmAPI.ConfirmOrder(order.VendorOrderID)
	} else {
		api.ElmAPI.CancelOrder(order.VendorOrderID, elmapi.CancelOrderTypeOthers, "")
	}
}