package basesch

import (
	"fmt"
	"time"

	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/baseapi/utils/errlist"
	"git.rosy.net.cn/jx-callback/business/jxutils"
	"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
	"git.rosy.net.cn/jx-callback/business/jxutils/tasksch"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/business/model/dao"
	"git.rosy.net.cn/jx-callback/business/partner"
	"git.rosy.net.cn/jx-callback/business/partner/purchase/jd"
	"git.rosy.net.cn/jx-callback/globals"
)

const (
	autoSelfTakeCode = "135246"
)

func (c *BaseScheduler) CreateWaybillOnProviders(ctx *jxcontext.Context, order *model.GoodsOrder, courierVendorIDs, excludeCourierVendorIDs []int, maxDeliveryFee int64, createOnlyOne bool) (bills []*model.Waybill, err error) {
	userName := ctx.GetUserName()
	globals.SugarLogger.Infof("CreateWaybillOnProviders orderID:%s userName:%s, courierVendorIDs:%v, excludeCourierVendorIDs:%v", order.VendorOrderID, userName, courierVendorIDs, excludeCourierVendorIDs)
	storeCourierList, err := dao.GetStoreCourierList(dao.GetDB(), []int{jxutils.GetSaleStoreIDFromOrder(order)}, model.StoreStatusOpened, model.StoreAuditStatusOnline)
	if err != nil {
		return nil, err
	}
	courierVendorIDMap := jxutils.IntList2Map(courierVendorIDs)
	excludeCourierVendorIDMap := jxutils.IntList2Map(excludeCourierVendorIDs)
	errList := errlist.New()
	for _, storeCourier := range storeCourierList {
		if (courierVendorIDs == nil || courierVendorIDMap[storeCourier.VendorID] == 1) &&
			(excludeCourierVendorIDs == nil || excludeCourierVendorIDMap[storeCourier.VendorID] == 0) {
			if handler := partner.GetDeliveryPlatformFromVendorID(storeCourier.VendorID); handler != nil && handler.Use4CreateWaybill {
				courierVendorID := storeCourier.VendorID
				bill, err2 := c.CreateWaybill(courierVendorID, order, maxDeliveryFee)
				if err = err2; err == nil {
					globals.SugarLogger.Debugf("CreateWaybillOnProviders orderID:%s userName:%s vendorID:%d bill:%v", order.VendorOrderID, userName, courierVendorID, bill)
					bills = append(bills, bill)
					if createOnlyOne {
						break
					}
				} else {
					globals.SugarLogger.Debugf("CreateWaybillOnProviders orderID:%s userName:%s vendorID:%d failed with error:%v", order.VendorOrderID, userName, courierVendorID, err)
					errList.AddErr(fmt.Errorf("平台:%s,%s", jxutils.GetVendorName(courierVendorID), err.Error()))
				}
			}
		}
	}
	if len(bills) > 0 {
		err = errList.GetErrListAsOne()
		if err != nil {
			partner.CurOrderManager.OnOrderMsg(order, "创建三方运单部分失败", err.Error())
		}
		err = nil
	} else if errList.GetErrListAsOne() == nil {
		err = fmt.Errorf("orderID:%s没有绑定有效的三方配送门店或没有剩下可用的三方配送", order.VendorOrderID)
	} else {
		err = fmt.Errorf("orderID:%s所有运单失败：%s", order.VendorOrderID, errList.GetErrListAsOne().Error())
	}
	globals.SugarLogger.Infof("CreateWaybillOnProviders orderID:%s userName:%s error:%v", order.VendorOrderID, userName, err)
	return bills, err
}

func (c *BaseScheduler) SelfDeliveredAndUpdateStatus(ctx *jxcontext.Context, vendorOrderID string, vendorID int, userName string) (err error) {
	jxutils.CallMsgHandler(func() {
		err = func() (err error) {
			globals.SugarLogger.Infof("SelfDeliveredAndUpdateStatus orderID:%s userName:%s", vendorOrderID, userName)
			order, err := partner.CurOrderManager.LoadOrder(vendorOrderID, vendorID)
			if err == nil {
				if model.IsOrderDeliveryByStore(order) {
					err = c.SelfDeliverDelivered(order, userName)
				} else if model.IsOrderDeliveryByPlatform(order) {
					err = c.Swtich2SelfDelivered(order, userName)
				}
				if err == nil {
					// order.Status = model.OrderStatusFinished // todo 是否需要强制设置完成状态？
					if err = dao.SetOrderFlag(dao.GetDB(), ctx.GetUserName(), order.VendorOrderID, order.VendorID, model.OrderFlagMaskSetDelivered); err == nil {
						globals.SugarLogger.Infof("SelfDeliveredAndUpdateStatus orderID:%s userName:%s successfully", vendorOrderID, userName)
						return err
					}
				}
			}
			globals.SugarLogger.Infof("SelfDeliveredAndUpdateStatus orderID:%s userName:%s error:%v", vendorOrderID, userName, err)
			return err
		}()
	}, jxutils.ComposeUniversalOrderID(vendorOrderID, vendorID))
	return err
}

func (c *BaseScheduler) PickupGoodsAndUpdateStatus(ctx *jxcontext.Context, vendorOrderID string, vendorID int, userName string) (err error) {
	jxutils.CallMsgHandler(func() {
		err = func() (err error) {
			globals.SugarLogger.Infof("PickupGoodsAndUpdateStatus orderID:%s userName:%s", vendorOrderID, userName)
			order, err := partner.CurOrderManager.LoadOrder(vendorOrderID, vendorID)
			if err == nil {
				err = c.PickupGoods(order, model.IsOrderDeliveryByStore(order), userName)
				if err == nil {
					order.Status = model.OrderStatusFinishedPickup
					if err = partner.CurOrderManager.UpdateOrderStatusAndDeliveryFlag(order); err == nil {
						globals.SugarLogger.Infof("PickupGoodsAndUpdateStatus orderID:%s userName:%s successfully", vendorOrderID, userName)
						return err
					}
				}
			}
			globals.SugarLogger.Infof("PickupGoodsAndUpdateStatus orderID:%s userName:%s error:%v", vendorOrderID, userName, err)
			return err
		}()
	}, jxutils.ComposeUniversalOrderID(vendorOrderID, vendorID))
	return err
}

func (c *BaseScheduler) AdjustOrder(ctx *jxcontext.Context, order *model.GoodsOrder, removedSkuList []*model.OrderSku, reason string) (err error) {
	if c.IsReallyCallPlatformAPI {
		err = partner.GetPurchaseOrderHandlerFromVendorID(order.VendorID).AdjustOrder(ctx, order, removedSkuList, reason)
	}
	return err
}

func (c *BaseScheduler) CancelOrder(ctx *jxcontext.Context, order *model.GoodsOrder, reason string) (err error) {
	if c.IsReallyCallPlatformAPI {
		err = partner.GetPurchaseOrderHandlerFromVendorID(order.VendorID).CancelOrder(ctx, order, reason)
	}
	return err
}

func (c *BaseScheduler) AcceptOrRefuseFailedGetOrder(ctx *jxcontext.Context, order *model.GoodsOrder, isAcceptIt bool, reason string) (err error) {
	if c.IsReallyCallPlatformAPI {
		err = partner.GetPurchaseOrderHandlerFromVendorID(order.VendorID).AcceptOrRefuseFailedGetOrder(ctx, order, isAcceptIt)
	}
	if err == nil {
		flag := model.OrderFlagAgreeFailedGetGoods
		if !isAcceptIt {
			flag = model.OrderFlagRefuseFailedGetGoods
		}
		dao.SetOrderFlag(dao.GetDB(), ctx.GetUserName(), order.VendorOrderID, order.VendorID, flag)
	}
	return err
}

func (c *BaseScheduler) CallPMCourier(ctx *jxcontext.Context, order *model.GoodsOrder) (err error) {
	if c.IsReallyCallPlatformAPI {
		err = partner.GetPurchaseOrderHandlerFromVendorID(order.VendorID).CallCourier(ctx, order)
	}
	if err == nil {
		dao.SetOrderFlag(dao.GetDB(), ctx.GetUserName(), order.VendorOrderID, order.VendorID, model.OrderFlagMaskCallPMCourier)
	}
	return err
}

func (c *BaseScheduler) ConfirmReceiveGoods(ctx *jxcontext.Context, order *model.GoodsOrder) (err error) {
	if c.IsReallyCallPlatformAPI {
		err = partner.GetPurchaseOrderHandlerFromVendorID(order.VendorID).ConfirmReceiveGoods(ctx, order)
	}
	if err == nil {
		dao.SetOrderFlag(dao.GetDB(), ctx.GetUserName(), order.VendorOrderID, order.VendorID, model.OrderFlagMaskFailedDeliver)
	}
	return err
}

func (c *BaseScheduler) AgreeOrRefuseCancel(ctx *jxcontext.Context, order *model.GoodsOrder, isAcceptIt bool, reason string) (err error) {
	if c.IsReallyCallPlatformAPI {
		err = partner.GetPurchaseOrderHandlerFromVendorID(order.VendorID).AgreeOrRefuseCancel(ctx, order, isAcceptIt, reason)
	}
	if err == nil {
		flag := model.OrderFlagAgreeUserApplyCancel
		if !isAcceptIt {
			flag = model.OrderFlagRefuseUserApplyCancel
		}
		dao.SetOrderFlag(dao.GetDB(), ctx.GetUserName(), order.VendorOrderID, order.VendorID, flag)
	}
	return err
}

func (c *BaseScheduler) CancelWaybillByID(ctx *jxcontext.Context, vendorWaybillID string, waybillVendorID int, cancelReasonID int, cancelReason string) (err error) {
	bill, err := partner.CurOrderManager.LoadWaybill(vendorWaybillID, waybillVendorID)
	if err == nil {
		err = c.CancelWaybill(bill, cancelReasonID, cancelReason)
	}
	return err
}

func (c *BaseScheduler) AgreeOrRefuseRefund(ctx *jxcontext.Context, afsOrderID string, vendorID, approveType int, reason string) (err error) {
	afsOrder, err := partner.CurOrderManager.LoadAfsOrder(afsOrderID, vendorID)
	if err == nil {
		if c.IsReallyCallPlatformAPI {
			err = partner.GetPurchaseOrderHandlerFromVendorID(vendorID).AgreeOrRefuseRefund(ctx, afsOrder, approveType, reason)
		}
		if err == nil {
			flag := model.AfsOrderFlagAgreeUserRefund
			if approveType == partner.AfsApproveTypeRefused {
				flag = model.AfsOrderFlagRefuseUserRefund
				afsOrder.RefuseReason = reason
				partner.CurOrderManager.UpdateAfsOrderFields(afsOrder, []string{"RefuseReason"})
			}
			dao.SetAfsOrderFlag(dao.GetDB(), ctx.GetUserName(), afsOrderID, vendorID, flag)
		}
	}
	return err
}

func (c *BaseScheduler) ConfirmReceivedReturnGoods(ctx *jxcontext.Context, afsOrderID string, vendorID int) (err error) {
	afsOrder, err := partner.CurOrderManager.LoadAfsOrder(afsOrderID, vendorID)
	if err == nil {
		if c.IsReallyCallPlatformAPI {
			err = partner.GetPurchaseOrderHandlerFromVendorID(vendorID).ConfirmReceivedReturnGoods(ctx, afsOrder)
		}
		if err == nil {
			dao.SetAfsOrderFlag(dao.GetDB(), ctx.GetUserName(), afsOrderID, vendorID, model.AfsOrderFlagMaskReturnGoods)
		}
	}
	return err
}

func (c *BaseScheduler) PartRefundOrder(ctx *jxcontext.Context, order *model.GoodsOrder, refundSkuList []*model.OrderSku, reason string) (err error) {
	if c.IsReallyCallPlatformAPI {
		err = partner.GetPurchaseOrderHandlerFromVendorID(order.VendorID).PartRefundOrder(ctx, order, refundSkuList, reason)
	}
	return err
}

func (c *BaseScheduler) RefundOrder(ctx *jxcontext.Context, order *model.GoodsOrder, reason string) (err error) {
	if c.IsReallyCallPlatformAPI {
		err = partner.GetPurchaseOrderHandlerFromVendorID(order.VendorID).RefundOrder(ctx, order, reason)
	}
	return err
}

func (c *BaseScheduler) ConfirmSelfTake(ctx *jxcontext.Context, vendorOrderID string, vendorID int, selfTakeCode string) (err error) {
	order, err2 := partner.CurOrderManager.LoadOrder(vendorOrderID, vendorID)
	if err = err2; err == nil {
		err = c.confirmSelfTake(ctx, order, selfTakeCode)
	}
	return err
}

func (c *BaseScheduler) confirmSelfTake(ctx *jxcontext.Context, order *model.GoodsOrder, selfTakeCode string) (err error) {
	if order.VendorID == model.VendorIDJD {
		if selfTakeCode == autoSelfTakeCode {
			if selfTakeCode, err = jd.CurPurchaseHandler.GetSelfTakeCode(ctx, order); err != nil {
				return fmt.Errorf("获取订单:%s自提货码失败，原始错误:%s", order.VendorOrderID, err.Error())
			}
			if selfTakeCode == "" {
				return fmt.Errorf("订单:%s看起来不是一个自提订单，如果确认是自提订单，请联系开发", order.VendorOrderID)
			}
		}
		err = jd.CurPurchaseHandler.ConfirmSelfTake(ctx, order, selfTakeCode)
	} else {
		err = fmt.Errorf("自提核销不支持%s平台订单", model.VendorChineseNames[order.VendorID])
	}
	return err
}

func (c *BaseScheduler) ConfirmSelfTakeOrders(ctx *jxcontext.Context, vendorIDs []int, orderCreatedAfter, orderCreatedBefore time.Time, isAsync, isContinueWhenError bool) (hint string, err error) {
	orderList, err := dao.GetPendingFakeOrders(dao.GetDB(), vendorIDs, orderCreatedAfter, orderCreatedBefore)
	if err == nil {
		if len(orderList) > 0 {
			task := tasksch.NewParallelTask(fmt.Sprintf("自动完成内部自提单%v,%s", vendorIDs, utils.Time2Str(orderCreatedAfter)), tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx,
				func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
					order := batchItemList[0].(*model.GoodsOrder)
					if order.Status == model.OrderStatusAccepted {
						if handler := partner.GetPurchaseOrderHandlerFromVendorID(order.VendorID); handler != nil {
							err = handler.AcceptOrRefuseOrder(order, true, ctx.GetUserName())
							time.Sleep(2 * time.Second)
						}
						if err == nil {
							if err = c.confirmSelfTake(ctx, order, autoSelfTakeCode); err == nil {
								retVal = []int{1}
							}
						}
					}
					return retVal, err
				}, orderList)
			tasksch.HandleTask(task, nil, true).Run()
			if isAsync {
				hint = task.GetID()
			} else {
				resultList, err2 := task.GetResult(0)
				if err = err2; err == nil {
					hint = utils.Int2Str(len(resultList))
				}
			}
		}
	}
	return hint, err
}