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, actStoreMap []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
	activity := act2EbaiActivity(act, actOrderRules)
	if act.Type < model.ActOrderBegin {
		actStoreSkuMap := partner.ActStoreSku2Map(actStoreSku)
		task := tasksch.NewParallelTask("ebai CreateAct", nil, ctx,
			func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
				store := batchItemList[0].(*model.ActStore2)
				store.VendorActID, err = createOneShopAct(utils.Int2Str(store.StoreID), activity, actStoreSkuMap[store.StoreID])
				return nil, err
			}, actStoreMap)
		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, actStoreMap2Remove, actStoreMap2Add, actStoreMap2Update []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
	if act.Type < model.ActOrderBegin {
		actStoreSkuMap := partner.ActStoreSku2Map(actStoreSku)
		if len(actStoreMap2Remove) > 0 {
			if err = c.CancelAct(ctx, parentTask, act, actStoreMap2Remove, nil); err != nil {
				return err
			}
			for _, v := range actStoreMap2Remove {
				delete(actStoreSkuMap, v.StoreID)
			}
		}
		if len(actStoreMap2Add) > 0 {
			if err = c.CreateAct(ctx, parentTask, act, actOrderRules, actStoreMap2Add, actStoreSku); err != nil {
				return err
			}
			for _, v := range actStoreMap2Add {
				delete(actStoreSkuMap, v.StoreID)
			}
		}
		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, actStoreMap []*model.ActStore2, 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
}