package ebai

import (
	"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/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/partner"
	"git.rosy.net.cn/jx-callback/globals"
	"git.rosy.net.cn/jx-callback/globals/api"
)

func actType2Ebai(actType int) int {
	if actType < model.ActOrderBegin {
		return ebaiapi.ActivityTypeDirectDown
	}
	return ebaiapi.ActivityTypeFullDiscount
}

func actOrderRules2Ebai(actOrderRules []*model.ActOrderRule) (ebaiRules []*ebaiapi.ActivityRule) {
	for _, v := range actOrderRules {
		ebaiRules = append(ebaiRules, &ebaiapi.ActivityRule{
			Accords: int(jxutils.IntPrice2Standard(v.SalePrice)),
			Sale:    int(jxutils.IntPrice2Standard(v.DeductPrice)),
		})
	}
	return ebaiRules
}

func actStoreSu2Ebai4Add(oneStoreActSku []*model.ActStoreSku2) (skus []*ebaiapi.ActivitySkuInfo4Add) {
	for _, v := range oneStoreActSku {
		if model.IsSyncStatusNeedCreate(v.SyncStatus) {
			skus = append(skus, &ebaiapi.ActivitySkuInfo4Add{
				SkuID:        v.VendorSkuID,
				SpecialPrice: v.ActPrice,
			})
		}
	}
	return skus
}

func actStoreSu2Ebai4Update(oneStoreActSku []*model.ActStoreSku2) (skus []*ebaiapi.ActivitySkuInfo4Update) {
	for _, v := range oneStoreActSku {
		if model.IsSyncStatusNeedUpdate(v.SyncStatus) {
			skus = append(skus, &ebaiapi.ActivitySkuInfo4Update{
				ShopID:       utils.Int2Str(v.StoreID),
				SkuID:        v.VendorSkuID,
				SpecialPrice: v.ActPrice,
			})
		}
	}
	return skus
}

func actStoreSu2Ebai4Delete(oneStoreActSku []*model.ActStoreSku2) (skus []string) {
	for _, v := range oneStoreActSku {
		if model.IsSyncStatusNeedDelete(v.SyncStatus) {
			skus = append(skus, v.VendorSkuID)
		}
	}
	return skus
}

func act2EbaiActivity(act *model.Act2, actOrderRules []*model.ActOrderRule) (activity *ebaiapi.ActivityInfo) {
	activity = &ebaiapi.ActivityInfo{
		ActivityName:     act.Name,
		ActivityType:     actType2Ebai(act.Type),
		StartTime:        act.BeginAt.Unix(),
		EndTime:          act.EndAt.Unix(),
		ActivityDesc:     act.Advertising,
		ShowCategory:     act.Name,
		PromotionSkuDesc: act.Name,
		Rule:             actOrderRules2Ebai(actOrderRules),
	}
	return activity
}

func createOneShopAct(shopID string, activity *ebaiapi.ActivityInfo, oneStoreActSku []*model.ActStoreSku2) (ebaiActIDStr string, err error) {
	if globals.EnableEbaiStoreWrite {
		ebaiActID, err := api.EbaiAPI.ActivityCreate(shopID, 0, 0, activity)
		if err == nil {
			ebaiActIDStr = utils.Int64ToStr(ebaiActID)
			_, err = ActivitySkuAddBatch(ebaiActID, shopID, 0, activity.ActivityType, actStoreSu2Ebai4Add(oneStoreActSku), false)
		}
	} else {
		ebaiActIDStr = utils.Int64ToStr(jxutils.GenFakeID())
	}
	return ebaiActIDStr, err
}

func ActivitySkuAddBatch(activityID int64, shopID string, baiduShopID int64, activityType int, skuList []*ebaiapi.ActivitySkuInfo4Add, isSkuIDCustom bool) (successIDs []string, err error) {
	return api.EbaiAPI.ActivitySkuAddBatch(activityID, shopID, baiduShopID, activityType, skuList, isSkuIDCustom)
}

func ActivitySkuDeleteBatch(activityID int64, shopID string, baiduShopID int64, skuIDs []string, isSkuIDCustom bool) (successIDs []string, err error) {
	return api.EbaiAPI.ActivitySkuDeleteBatch(activityID, shopID, baiduShopID, skuIDs, isSkuIDCustom)
}

func ActivitySkuUpdateBatch(activityID int64, actSkuInfoList []*ebaiapi.ActivitySkuInfo4Update) (faildInfoList []string, err error) {
	return api.EbaiAPI.ActivitySkuUpdateBatch(activityID, actSkuInfoList)
}

func (c *PurchaseHandler) CreateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSku []*model.ActStoreSku2) (err error) {
	activity := act2EbaiActivity(act, actOrderRules)
	if act.Type < model.ActOrderBegin {
		actStoreSkuListList := partner.SplitActStoreSku2List(actStoreSku)
		task := tasksch.NewParallelTask("ebai CreateAct", nil, ctx,
			func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
				list := batchItemList[0].([]*model.ActStoreSku2)
				var vendorActID string
				vendorActID, err = createOneShopAct(utils.Int2Str(list[0].StoreID), activity, list)
				for _, v := range list {
					v.VendorActID = vendorActID
				}
				return nil, err
			}, actStoreSkuListList)
		tasksch.HandleTask(task, parentTask, true).Run()
		_, err = task.GetResult(0)
	} else {

	}
	return err
}

func (c *PurchaseHandler) UpdateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSku []*model.ActStoreSku2) (err error) {
	// if act.Type < model.ActOrderBegin {
	// 	actStoreSkuMap := partner.SplitActStoreSku(actStoreSku)
	// 	task := tasksch.NewParallelTask("ebai UpdateAct", nil, ctx,
	// 		func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
	// 			v := batchItemList[0].(*model.ActStore2)
	// 			if storeSkus := actStoreSkuMap[v.StoreID]; storeSkus != nil {
	// 				if list := actStoreSu2Ebai4Delete(storeSkus); len(list) > 0 {
	// 					if _, err = ActivitySkuDeleteBatch(utils.Str2Int64(v.VendorActID), utils.Int2Str(v.StoreID), 0, list, false); err != nil {
	// 						return nil, err
	// 					}
	// 				}
	// 				if list := actStoreSu2Ebai4Add(storeSkus); len(list) > 0 {
	// 					if _, err = ActivitySkuAddBatch(utils.Str2Int64(v.VendorActID), utils.Int2Str(v.StoreID), 0, actType2Ebai(act.Type), list, false); err != nil {
	// 						return nil, err
	// 					}
	// 				}
	// 				if list := actStoreSu2Ebai4Update(storeSkus); len(list) > 0 {
	// 					if _, err = ActivitySkuUpdateBatch(utils.Str2Int64(v.VendorActID), list); err != nil {
	// 						return nil, err
	// 					}
	// 				}
	// 			}
	// 			return nil, err
	// 		}, actStoreMap2Update)
	// 	tasksch.HandleTask(task, parentTask, true).Run()
	// 	_, err = task.GetResult(0)
	// } else {

	// }
	return err
}

func (c *PurchaseHandler) CancelAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actStoreSku []*model.ActStoreSku2) (err error) {
	// if act.Type < model.ActOrderBegin {
	// 	task := tasksch.NewParallelTask("ebai DeleteAct", nil, ctx,
	// 		func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
	// 			v := batchItemList[0].(*model.ActStore2)
	// 			if globals.EnableEbaiStoreWrite {
	// 				err = api.EbaiAPI.ActivityDisable(utils.Str2Int64(v.VendorActID), utils.Int2Str(v.StoreID), 0, 0)
	// 			}
	// 			return nil, err
	// 		}, actStoreMap)
	// 	tasksch.HandleTask(task, parentTask, true).Run()
	// 	_, err = task.GetResult(0)
	// }
	return err
}

func (c *PurchaseHandler) SyncAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreSkuList []*model.ActStoreSku2) (err error) {
	return nil
}