package jd

import (
	"git.rosy.net.cn/baseapi/platformapi/jdapi"
	"git.rosy.net.cn/baseapi/utils"
	"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/putils"
	"git.rosy.net.cn/jx-callback/globals"
	"git.rosy.net.cn/jx-callback/globals/api"
)

func (p *PurchaseHandler) GetStoreSkusBatchSize(funcID int) (batchSize int) {
	switch funcID {
	case partner.FuncUpdateStoreSkusStock, partner.FuncUpdateStoreSkusStatus, partner.FuncUpdateStoreSkusPrice:
		batchSize = jdapi.MaxStoreSkuBatchSize
	}
	return batchSize
}

func (p *PurchaseHandler) getStoreSkusBareInfoLimitSize(ctx *jxcontext.Context, parentTask tasksch.ITask, storeID int, vendorStoreID string, inStoreSkuList []*partner.StoreSkuInfo) (outStoreSkuList []*partner.StoreSkuInfo, err error) {
	var batchSkuInfoList []*jdapi.BaseStockCenterRequest
	batchSkuList := partner.BareStoreSkuInfoList(inStoreSkuList).GetVendorSkuIDIntList()
	for _, v := range inStoreSkuList {
		if !dao.IsVendorThingIDEmpty(v.VendorSkuID) {
			batchSkuInfoList = append(batchSkuInfoList, &jdapi.BaseStockCenterRequest{
				StationNo: vendorStoreID,
				SkuId:     utils.Str2Int64(v.VendorSkuID),
			})
		}
	}
	if len(batchSkuInfoList) > 0 {
		var stockInfo []*jdapi.QueryStockResponse
		var priceInfo []*jdapi.StorePriceInfo
		task := tasksch.NewParallelTask("获取京东到家平台门店商品信息", tasksch.NewParallelConfig().SetParallelCount(2), ctx,
			func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
				subTaskID := batchItemList[0].(int)
				if subTaskID == 0 {
					stockInfo, err = api.JdAPI.QueryOpenUseable(batchSkuInfoList)
				} else {
					priceInfo, err = api.JdAPI.GetStationInfoList(vendorStoreID, batchSkuList)
				}
				return nil, err
			}, []int{0, 1})
		tasksch.HandleTask(task, parentTask, false).Run()
		_, err = task.GetResult(0)
		if err == nil {
			storeSkuMap := putils.StoreSkuList2MapByVendorSkuID(inStoreSkuList)
			for _, v := range stockInfo {
				sku := storeSkuMap[utils.Int64ToStr(v.SkuID)]
				sku.Status = jdStoreSkuStatus2Jx(v.Vendibility)
				sku.Stock = v.UsableQty
				outStoreSkuList = append(outStoreSkuList, sku)
			}
			for _, v := range priceInfo {
				sku := storeSkuMap[utils.Int64ToStr(v.SkuID)]
				sku.VendorPrice = v.Price
			}
		}
	}
	return outStoreSkuList, err
}

func (p *PurchaseHandler) GetStoreSkusBareInfo(ctx *jxcontext.Context, parentTask tasksch.ITask, storeID int, vendorStoreID string, inStoreSkuList []*partner.StoreSkuInfo) (outStoreSkuList []*partner.StoreSkuInfo, err error) {
	result, err := putils.FreeBatchStoreSkuInfo("获取门店商品信息", func(task tasksch.ITask, batchedStoreSkuList []*partner.StoreSkuInfo) (result interface{}, successCount int, err error) {
		list, err := p.getStoreSkusBareInfoLimitSize(ctx, task, storeID, vendorStoreID, batchedStoreSkuList)
		if err == nil {
			result = list
		}
		return result, len(list), err
	}, ctx, parentTask, inStoreSkuList, jdapi.MaxStoreSkuBatchSize, true)
	for _, v := range result {
		outStoreSkuList = append(outStoreSkuList, v.(*partner.StoreSkuInfo))
	}
	return outStoreSkuList, err
}

func jdStoreSkuStatus2Jx(jdStoreSkuStatus int) (jxSkuStatus int) {
	if jdStoreSkuStatus == 0 {
		jxSkuStatus = model.SkuStatusNormal
	} else {
		jxSkuStatus = model.SkuStatusDontSale
	}
	return jxSkuStatus
}

func jxStoreSkuStatus2Jd(jxStoreSkuStatus int) (isSale bool) {
	return jxStoreSkuStatus == model.SkuStatusNormal
}

func isErrPartialFailed(err error) bool {
	if errExt, ok := err.(*utils.ErrorWithCode); ok && errExt.Code() == jdapi.ResponseInnerCodePartialFailed {
		return true
	}
	return false
}

func getStrOutSkuIDs(l []*jdapi.StoreSkuBatchUpdateResponse, isSuccess bool) (outSkuIDs []string) {
	for _, v := range l {
		if isSuccess && v.Code == 0 {
			outSkuIDs = append(outSkuIDs, v.OutSkuID)
		} else if !isSuccess && v.Code != 0 {
			outSkuIDs = append(outSkuIDs, v.OutSkuID)
		}
	}
	return outSkuIDs
}

func (p *PurchaseHandler) UpdateStoreSkusStatus(ctx *jxcontext.Context, storeID int, vendorStoreID string, storeSkuList []*partner.StoreSkuInfo, status int) (successList []*partner.StoreSkuInfo, err error) {
	var skuVendibilityList []*jdapi.StockVendibility
	jdStatus := jxStoreSkuStatus2Jd(status)
	for _, v := range storeSkuList {
		skuVendibilityList = append(skuVendibilityList, &jdapi.StockVendibility{
			OutSkuId: utils.Int2Str(v.SkuID),
			DoSale:   jdStatus,
		})
	}
	if globals.EnableJdStoreWrite {
		responseList, err2 := api.JdAPI.BatchUpdateVendibility(ctx.GetTrackInfo(), "", vendorStoreID, skuVendibilityList, ctx.GetUserName())
		if err = err2; isErrPartialFailed(err) {
			successList = putils.UnselectStoreSkuListBySkuIDs(storeSkuList, utils.StringSlice2Int(getStrOutSkuIDs(responseList, false)))
		}
	}
	return successList, err
}

func (p *PurchaseHandler) UpdateStoreSkusPrice(ctx *jxcontext.Context, storeID int, vendorStoreID string, storeSkuList []*partner.StoreSkuInfo) (successList []*partner.StoreSkuInfo, err error) {
	if len(storeSkuList) == 1 {
		if globals.EnableJdStoreWrite {
			_, err = api.JdAPI.UpdateStationPrice(ctx.GetTrackInfo(), utils.Str2Int64WithDefault(storeSkuList[0].VendorSkuID, 0), vendorStoreID, int(storeSkuList[0].VendorPrice))
		}
	} else {
		var skuPriceInfoList []*jdapi.SkuPriceInfo
		for _, v := range storeSkuList {
			skuPriceInfoList = append(skuPriceInfoList, &jdapi.SkuPriceInfo{
				OutSkuId: utils.Int2Str(v.SkuID),
				Price:    int(v.VendorPrice),
			})
		}
		if globals.EnableJdStoreWrite {
			responseList, err2 := api.JdAPI.UpdateVendorStationPrice(ctx.GetTrackInfo(), "", vendorStoreID, skuPriceInfoList)
			if err = err2; isErrPartialFailed(err) {
				successList = putils.UnselectStoreSkuListBySkuIDs(storeSkuList, utils.StringSlice2Int(getStrOutSkuIDs(responseList, false)))
			}
		}
	}
	return successList, err
}

func (p *PurchaseHandler) UpdateStoreSkusStock(ctx *jxcontext.Context, storeID int, vendorStoreID string, storeSkuList []*partner.StoreSkuInfo) (successList []*partner.StoreSkuInfo, err error) {
	if len(storeSkuList) == 1 {
		if globals.EnableJdStoreWrite {
			err = api.JdAPI.UpdateCurrentQty(ctx.GetTrackInfo(), vendorStoreID, utils.Str2Int64WithDefault(storeSkuList[0].VendorSkuID, 0), storeSkuList[0].Stock)
		}
	} else {
		var skuStockList []*jdapi.SkuStock
		for _, v := range storeSkuList {
			skuStockList = append(skuStockList, &jdapi.SkuStock{
				OutSkuId: utils.Int2Str(v.SkuID),
				StockQty: v.Stock,
			})
		}
		if globals.EnableJdStoreWrite {
			responseList, err2 := api.JdAPI.BatchUpdateCurrentQtys(ctx.GetTrackInfo(), "", vendorStoreID, skuStockList, ctx.GetUserName())
			if err = err2; isErrPartialFailed(err) {
				successList = putils.UnselectStoreSkuListBySkuIDs(storeSkuList, utils.StringSlice2Int(getStrOutSkuIDs(responseList, false)))
			}
		}
	}
	return successList, err
}

func (p *PurchaseHandler) SyncStoreProducts(ctx *jxcontext.Context, parentTask tasksch.ITask, storeID int, skuIDs []int, isAsync, isContinueWhenError bool) (hint string, err error) {
	globals.SugarLogger.Debugf("jd SyncStoreProducts, storeID:%d", storeID)
	db := dao.GetDB()
	storeDetail, err := dao.GetStoreDetail(db, storeID, model.VendorIDJD)
	if err != nil {
		return "", err
	}
	storeSkuList, err := dao.GetStoreSkus2(db, model.VendorIDJD, storeID, skuIDs, false)
	if err != nil {
		return "", err
	}
	task := tasksch.NewParallelTask("SyncStoreProducts京东", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx,
		func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
			storeSku := batchItemList[0].(*dao.StoreSkuSyncInfo)
			if storeSku.VendorSkuID != "" && storeSku.StoreSkuStatus == model.SkuStatusNormal {
				if globals.EnableJdStoreWrite {
					synchronized, err2 := api.JdAPI.SyncProduct(storeDetail.VendorStoreID, storeSku.VendorSkuID)
					if err = err2; err == nil && synchronized {
						retVal = []int{1}
					}
				} else {
					retVal = []int{1}
				}
			}
			return retVal, err
		}, storeSkuList)
	tasksch.HandleTask(task, parentTask, true).Run()
	if !isAsync {
		result, err2 := task.GetResult(0)
		if err = err2; err == nil {
			hint = utils.Int2Str(len(result))
		}
	} else {
		hint = task.GetID()
	}
	return hint, err
}