package ebaiapi

import (
	"time"

	"git.rosy.net.cn/baseapi/utils"
)

const (
	CancelTypeNotInServiceArea    = "1"
	CancelTypeShopClosed          = "2"
	CancelTypeSoldOut             = "3"
	CancelTypePriceChanged        = "4"
	CancelTypeClientCanceled      = "5"
	CancelTypeDuplicatedOrder     = "6"
	CancelTypeTooBusy             = "7"
	CancelTypeCanNotContactClient = "8"
	CancelTypeFakeOrder           = "9"
	CancelTypePushOrderFailed     = "53"
	CancelTypeCustom              = "-1"
)

const (
	OrderStatusNew             = "1"
	OrderStatusAccepted        = "5"
	OrderStatusCourierAccepted = "7"
	OrderStatusCourierPickedup = "8"
	OrderStatusFinished        = "9"
	OrderStatusCanceled        = "10"
)

const (
	WaybillStatusNew              = "2"
	WaybillStatusRequestDelivery  = "3"
	WaybillStatusWait4Courier     = "4"
	WaybillStatusCourierAccepted  = "7"
	WaybillStatusCourierPickedup  = "8"
	WaybillStatusDeliveryCancled  = "15"
	WaybillStatusFinished         = "16"
	WaybillStatusExceptional      = "17"
	WaybillStatusSelfDelivery     = "18"
	WaybillStatusNotInDelivering  = "19"
	WaybillStatusDeliveryRejected = "20"
)

const (
	// 订单下行 - order.partrefund.push-部分退款订单信息推送
	OrderPartRefuncTypeMerchant = 1 // 表示商户发起的部分退款
	OrderPartRefuncTypeCustomer = 2 // 表示用户发起的部分退款
	OrderPartRefuncTypeCS       = 3 // 表示客服直接发起的部分退款

	OrderPartRefundApply                = 10 // 表示商家/用户发起部分退款申请
	OrderPartRefundSuccess              = 20 // 表示部分退款成功
	OrderPartRefundUserApplyArbitration = 30 // 用户申请仲裁,客服介入
	OrderPartRefundFailed               = 40 // 表示部分退款失败
	OrderPartRefundMerchantRefused      = 50 // 表示商家拒绝用户发起的部分退款申请

	// 订单下行 - order.user.cancel-用户申请订单取消/退款
	OrderUserCancelApply           = 10 // 发起申请
	OrderUserCancelCSIntervene     = 20 // 客服介入
	OrderUserCancelCSRefused       = 30 // 客服拒绝
	OrderUserCancelCSAgreed        = 40 // 客服同意
	OrderUserCancelMerchantRefused = 50 // 商户拒绝
	OrderUserCancelMerchantAgreed  = 60 // 商家同意
	OrderUserCancelInvalid         = 70 // 申请失效

	OrderUserCancelTypeBeforeSale = 1 // 表示订单完成前用户全单取消申请流程
	OrderUserCancelTypeAfterSale  = 2 // 表示订单完成后用户全单退款申请流程

	SendImmediatelySelf = 6 // 饿百商家自送的配送状态
)

const (
	OrderFromBaidu = "1"
	OrderFromElm   = "2"
)

const (
	UserApplyCancelWaitMinute = 15 // 用户申请取消订单后待处理的最大等待时间（分钟），超时自动同意
)

type ExpressInfo struct {
	OrderID        string `json:"order_id"`
	ExpressID      string `json:"express_id"`
	ExpressCompany string `json:"express_company"`
}

type PrivateMobileInfo struct {
	ShortNumber string     `json:"short_number"`
	ExpireDate  *time.Time `json:"expire_date"`
}

type RefundSku struct {
	SkuID        string `json:"sku_id,omitempty"`
	Upc          string `json:"upc,omitempty"`
	CustomeSkuID string `json:"custom_sku_id,omitempty"`
	Number       string `json:"number"`
}

type OrderDetailInfo struct {
	CustomSkuID     string        `json:"custom_sku_id"`
	Name            string        `json:"name"`
	Number          int           `json:"number"`
	ProductFeatures []interface{} `json:"product_features"`
	ProductFee      int           `json:"product_fee"`
	ProductPrice    int           `json:"product_price"`
	ProductSubsidy  struct {
		AgentRate      int `json:"agent_rate"`
		BaiduRate      int `json:"baidu_rate"`
		Discount       int `json:"discount"`
		DiscountDetail []*struct {
			ActivityID string `json:"activity_id"`
			BaiduRate  int    `json:"baidu_rate"`
			ShopRate   int    `json:"shop_rate"`
			Type       string `json:"type"`
		} `json:"discount_detail"`
		LogisticsRate int `json:"logistics_rate"`
		ShopRate      int `json:"shop_rate"`
		UserRate      int `json:"user_rate"`
	} `json:"product_subsidy"`
	SkuID       string `json:"sku_id"`
	TotalWeight int    `json:"total_weight"`
	Upc         string `json:"upc"`
}

type RefundDetailInfo struct {
	ApplyTime     string `json:"apply_time"`
	CustomSkuID   string `json:"custom_sku_id"`
	Desc          string `json:"desc"`
	Name          string `json:"name"`
	Number        int    `json:"number"`
	RefundID      string `json:"refund_id"`
	ShopEleRefund int    `json:"shop_ele_refund"`
	SkuID         string `json:"sku_id"`
	Status        int    `json:"status"`
	TotalRefund   int    `json:"total_refund"`
	Type          int    `json:"type"`
	Upc           string `json:"upc"`
}

type PartRefundInfo struct {
	Commission   int                 `json:"commission"`
	Fee          int                 `json:"fee"`
	OrderDetail  []*OrderDetailInfo  `json:"order_detail"`
	OrderID      string              `json:"order_id"`
	PackageFee   int                 `json:"package_fee"`
	RefundDetail []*RefundDetailInfo `json:"refund_detail"`
	RefundPrice  int                 `json:"refund_price"`
	SendFee      int                 `json:"send_fee"`
	ShopFee      int                 `json:"shop_fee"`
	TotalPrice   int                 `json:"total_price"`
	Type         int                 `json:"type"`
	UserFee      int                 `json:"user_fee"`
}

// 提供给合作方确认订单所用。 注：1、10分钟内未确认的订单系统自动取消。2、确认失败的订单请不要做餐。 2016年7月4号起，将由百度外卖负责完成订单。届时，对接方无需调用完成订单接口，继续调用可能导致订单结算有问题。
func (a *API) OrderConfirm(orderID string) (err error) {
	_, err = a.AccessAPI("order.confirm", map[string]interface{}{
		"order_id": orderID,
	})
	return err
}

// 提供给合作方取消订单所用。 注：1、百度物流配送且已经确认的订单无法取消。
func (a *API) OrderCancel(orderID, cancelType, cancelReason string) (err error) {
	_, err = a.AccessAPI("order.cancel", map[string]interface{}{
		"order_id": orderID,
		"type":     cancelType,
		"reason":   cancelReason,
	})
	return err
}

// 蜂鸟众包订单呼叫骑士配送，仅限蜂鸟众包商户调用
func (a *API) OrderCallDelivery(orderID string) (err error) {
	_, err = a.AccessAPI("order.callDelivery", map[string]interface{}{
		"order_id": orderID,
	})
	return err
}

// 蜂鸟众包订单取消呼叫骑士配送，仅限蜂鸟众包商户调用。
func (a *API) OrderCancelDelivery(orderID string) (err error) {
	_, err = a.AccessAPI("order.cancelDelivery", map[string]interface{}{
		"order_id": orderID,
	})
	return err
}

// 饿了么自配送订单回传订单已送出状态
// 此接口目前只支持饿了么侧订单调用
func (a *API) OrderSendOut(orderID, phone string) (err error) {
	_, err = a.AccessAPI("order.sendout", map[string]interface{}{
		"order_id": orderID,
		"phone":    phone,
	})
	return err
}

// 饿了么自配送订单回传订单送达状态，调用成功后订单状态变为已完成。需先调用订单送出接口，且接单5分钟后可调用
func (a *API) OrderComplete(orderID, phone string) (err error) {
	_, err = a.AccessAPI("order.complete", map[string]interface{}{
		"order_id": orderID,
		"phone":    phone,
	})
	return err
}

// 提供给合作方在配送异常或物流拒单后选择自行配送
func (a *API) OrderSwitchselfdelivery(orderID string) (err error) {
	_, err = a.AccessAPI("order.switchselfdelivery", map[string]interface{}{
		"order_id": orderID,
	})
	return err
}

// 查看订单详情
func (a *API) OrderGet(orderID string) (orderMap map[string]interface{}, err error) {
	result, err := a.AccessAPI("order.get", map[string]interface{}{
		"order_id": orderID,
	})
	if err == nil {
		return result.Data.(map[string]interface{}), nil
	}
	return nil, err
}

// 设置订单快递单号
func (a *API) OrderExpressCreate(shopID string, expressList []*ExpressInfo) (status int, err error) {
	result, err := a.AccessAPI("order.express.create", map[string]interface{}{
		KeyShopID:      shopID,
		"express_list": expressList,
	})
	if err == nil {
		return int(utils.MustInterface2Int64(result.Data.(map[string]interface{})["status"])), nil
	}
	return 0, err
}

func (a *API) OrderPrivateInfo(orderID string) (mobileInfo *PrivateMobileInfo, err error) {
	result, err := a.AccessAPI("order.privateinfo", map[string]interface{}{
		"order_id": orderID,
	})
	if err == nil {
		mapData := result.Data.(map[string]interface{})
		mobileInfo = &PrivateMobileInfo{
			ShortNumber: mapData["short_number"].(string),
		}
		expireDate := utils.Interface2String(mapData["expire_date"])
		if expireDate != "" {
			tmpTime := utils.Str2Time(expireDate)
			mobileInfo.ExpireDate = &tmpTime
		}
		return mobileInfo, nil
	}
	return nil, err
}

func (a *API) OrderDeliveryGet(orderID string) (deliveryInfo map[string]interface{}, err error) {
	result, err := a.AccessAPI("order.delivery.get", map[string]interface{}{
		"order_id": orderID,
	})
	if err == nil {
		return result.Data.(map[string]interface{}), nil
	}
	return nil, err
}

func (a *API) OrderIdConvert(orderID string, isElemeOrder bool) (convertedOrderID string, err error) {
	key := "order_id"
	resultKey := "eleme_order_id"
	if isElemeOrder {
		key = "eleme_order_id"
		resultKey = "order_id"
	}
	result, err := a.AccessAPI("order.id.convert", map[string]interface{}{
		key: orderID,
	})
	if err == nil {
		return utils.Interface2String(result.Data.(map[string]interface{})[resultKey]), nil
	}
	return "", err
}

// 查看部分退款订单详情
func (a *API) OrderPartRefundGet(orderID string) (orderMap map[string]interface{}, err error) {
	result, err := a.AccessAPI("order.partrefund.get", map[string]interface{}{
		"order_id": orderID,
	})
	if err == nil {
		return result.Data.(map[string]interface{}), nil
	}
	return nil, err
}

func (a *API) OrderPartRefundGet2(orderID string) (partRefundInfo *CBPartRefundInfo, err error) {
	result, err := a.OrderPartRefundGet(orderID)
	if err == nil {
		err = utils.Map2StructByJson(result, &partRefundInfo, false)
	}
	return partRefundInfo, err
}

func (a *API) SmartOrderIdConvert(orderID string) (convertedOrderID string, err error) {
	return a.OrderIdConvert(orderID, isOrderIDEleme(orderID))
}

func isOrderIDEleme(orderID string) bool {
	return len(orderID) == len("3026328756122155111")
}

func (a *API) OrderAgreeRefund(orderID string) (err error) {
	_, err = a.AccessAPI("order.agreerefund", map[string]interface{}{
		"order_id": orderID,
	})
	return err
}

func (a *API) OrderDisagreeRefund(orderID, refuseReason string) (err error) {
	_, err = a.AccessAPI("order.disagreerefund", map[string]interface{}{
		"order_id":      orderID,
		"refuse_reason": refuseReason,
	})
	return err
}

func (a *API) OrderPartRefund(orderID string, removeSkuList []*RefundSku) (err error) {
	_, err = a.AccessAPI("order.partrefund", map[string]interface{}{
		"order_id": orderID,
		"products": removeSkuList,
	})
	return err
}