package dadaapi

import (
	"git.rosy.net.cn/baseapi/utils"
	"github.com/fatih/structs"
)

const (
	ReasonIDNobodyAccept            = 1
	ReasonIDNobodyPickup            = 2
	ReasonIDCourierIsPig            = 3
	ReasonIDClientCanceled          = 4
	ReasonIDOrderIsWrong            = 5
	ReasonIDCourierWantMeCancel     = 34
	ReasonIDCourierDontWantToPickup = 35
	ReasonIDClientDontWantItAnymore = 36
	ReasonIDCourierShirk            = 37
	ReasonIDOther                   = 10000
)

const (
	OrderStatusWaitingForAccept  = 1
	OrderStatusPickingup         = 2
	OrderStatusDeliverying       = 3
	OrderStatusFinished          = 4
	OrderStatusCanceled          = 5
	OrderStatusExpired           = 7
	OrderStatusAssignment        = 8
	OrderStatusReturning         = 9
	OrderStatusReturningFinished = 10
	OrderStatusAddOrderFailed    = 1000
)

type OperateOrderRequiredParams struct {
	ShopNo          string  `json:"shop_no"`
	OriginID        string  `json:"origin_id"`
	CityCode        string  `json:"city_code"`
	CargoPrice      float64 `json:"cargo_price"`
	IsPrepay        int     `json:"is_prepay"`
	ReceiverName    string  `json:"receiver_name"`
	ReceiverAddress string  `json:"receiver_address"`
	ReceiverLat     float64 `json:"receiver_lat"`
	ReceiverLng     float64 `json:"receiver_lng"`
	ReceiverPhone   string  `json:"receiver_phone"`
	ReceiverTel     string  `json:"receiver_tel"`
}

type CreateOrderResponse struct {
	Distance     float64
	Fee          float64
	DeliverFee   float64
	CouponFee    float64
	Tips         float64
	InsuranceFee float64
}

type CancelOrderResponse struct {
	DeductFee float64 `json:"deduct_fee"`
}

func (a *API) QueryOrderInfo(orderId string) (retVal map[string]interface{}, err error) {
	params := make(map[string]interface{})
	params["order_id"] = orderId
	result, err := a.AccessAPI("api/order/status/query", params)
	if err != nil {
		return nil, err
	}
	return result.Result.(map[string]interface{}), nil
}

func map2CreateOrderResponse(mapData map[string]interface{}) *CreateOrderResponse {
	retVal := new(CreateOrderResponse)
	retVal.Distance = utils.MustInterface2Float64(mapData["distance"])
	retVal.Fee = utils.MustInterface2Float64(mapData["fee"])
	retVal.DeliverFee = utils.MustInterface2Float64(mapData["deliverFee"])

	if value, ok := mapData["couponFee"]; ok {
		retVal.CouponFee = utils.MustInterface2Float64(value)
	}
	if value, ok := mapData["tips"]; ok {
		retVal.CouponFee = utils.MustInterface2Float64(value)
	}
	if value, ok := mapData["insuranceFee"]; ok {
		retVal.CouponFee = utils.MustInterface2Float64(value)
	}

	return retVal
}

func (a *API) operateOrder(action string, orderInfo *OperateOrderRequiredParams, addParams map[string]interface{}) (retVal *CreateOrderResponse, err error) {
	params := structs.Map(orderInfo)
	params["callback"] = a.callbackURL
	allParams := utils.MergeMaps(params, addParams)

	result, err := a.AccessAPI(action, allParams)
	if err != nil {
		return nil, err
	}

	return map2CreateOrderResponse(result.Result.(map[string]interface{})), nil
}

func (a *API) AddOrder(orderInfo *OperateOrderRequiredParams, addParams map[string]interface{}) (retVal *CreateOrderResponse, err error) {
	return a.operateOrder("api/order/addOrder", orderInfo, addParams)
}

func (a *API) ReaddOrder(orderInfo *OperateOrderRequiredParams, addParams map[string]interface{}) (retVal *CreateOrderResponse, err error) {
	return a.operateOrder("api/order/reAddOrder", orderInfo, addParams)
}

func (a *API) QueryDeliverFee(orderInfo *OperateOrderRequiredParams, addParams map[string]interface{}) (retVal *CreateOrderResponse, err error) {
	return a.operateOrder("api/order/queryDeliverFee", orderInfo, addParams)
}

func (a *API) AddOrderAfterQuery(orderInfo *OperateOrderRequiredParams, addParams map[string]interface{}) (retVal *CreateOrderResponse, err error) {
	return a.operateOrder("api/order/addAfterQuery", orderInfo, addParams)
}

func (a *API) CancelOrder(orderId string, cancelOrderReasonId int, cancelOrderReason string) (retVal *CancelOrderResponse, err error) {
	mapData := utils.Params2Map("order_id", orderId, "cancel_reason_id", cancelOrderReasonId, "cancel_reason", cancelOrderReason)
	result, err := a.AccessAPI("api/order/formalCancel", mapData)
	if err != nil {
		return nil, err
	}

	mapResult := result.Result.(map[string]interface{})
	retVal = new(CancelOrderResponse)
	retVal.DeductFee = utils.MustInterface2Float64(mapResult["deduct_fee"])

	return retVal, nil
}