package misc

import (
	"time"
	"strings"
	"git.rosy.net.cn/baseapi"
	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/jxstore/cms"
	"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/business/partner/putils"
	"git.rosy.net.cn/jx-callback/globals"
)

const (
	taskParallelCount			= 4
	specialSkuNameKeyWord       = "温馨提示"
	startOpStoreStockNumber     = 0
	endOpStoreStockNumber       = model.MaxStoreSkuStockQty
)

var (
	vendorList = map[int]bool {
		model.VendorIDMTWM: true,
		model.VendorIDEBAI: true,
	}

	vendorStoreRefreshTimeList = map[int][]string {
		model.VendorIDMTWM: []string {
			//start and end time for JXGY
			"22:00:00",
			"00:00:00",
			//start and end time for JXCS
			"22:10:00",
			"00:10:00",
		},
		model.VendorIDEBAI: []string {
			"22:20:00",
			"06:00:00",

			"22:30:00",
			"06:10:00",
		},
	}

	vendorStartEndStoreTime = map[int][]int16 {
		model.VendorIDMTWM: []int16 {
			int16(2200),//start time
			int16(2355),//end time
		},
		model.VendorIDEBAI: []int16 {
			int16(5),
			int16(2355),
		},
	}
)

func AddOrDelExtraStoreOptime(ctx *jxcontext.Context, vendorID, storeID int, vendorStoreID string, storeInfo *model.Store, startOpStoreTime, endOpStoreTime int16, needAddTime bool) bool {
	opTimeList := storeInfo.GetOpTimeList()
	if needAddTime {
		opTimeList = []int16{startOpStoreTime, endOpStoreTime}
	}
	handler := partner.GetPurchasePlatformFromVendorID(vendorID).(partner.IStoreHandler)
	return handler.UpdateStoreOpTime(ctx, storeID, vendorStoreID, opTimeList) == nil
}

func GetStockValue(isStart bool) int {
	if isStart {
		return startOpStoreStockNumber
	} else {
		return endOpStoreStockNumber
	}
}

func GetOpStoreTime(vendorID int) (startTime, endTime int16) {
	startTime = vendorStartEndStoreTime[vendorID][0]
	endTime = vendorStartEndStoreTime[vendorID][1]
	return startTime, endTime
}

func IsSpecialSku(name string) bool {
	return strings.Contains(name, specialSkuNameKeyWord)
}

func SetSkuStock(isStart bool, storeSkuNameList []*partner.SkuNameInfo) {
	for _, skuNameInfo := range storeSkuNameList {
		for _, skuInfo := range skuNameInfo.SkuList {
			if IsSpecialSku(skuNameInfo.Name) || IsSpecialSku(skuInfo.SkuName) {
				skuInfo.Stock = endOpStoreStockNumber
			} else {
				skuInfo.Stock = GetStockValue(isStart)
			}
		}
	}
}

func SetSpecialSkuStatus(ctx *jxcontext.Context, storeID, vendorID int, vendorStoreID string, storeSkuNameList []*partner.SkuNameInfo) {
	singleStoreHandler := partner.GetPurchasePlatformFromVendorID(vendorID).(partner.ISingleStoreStoreSkuHandler)
	for _, skuNameInfo := range storeSkuNameList {
		for _, skuInfo := range skuNameInfo.SkuList {
			if IsSpecialSku(skuNameInfo.Name) || IsSpecialSku(skuInfo.SkuName)  {
				storeSkuList := []*partner.StoreSkuInfo{&skuInfo.StoreSkuInfo}
				singleStoreHandler.UpdateStoreSkusStatus(ctx, storeID, vendorStoreID, storeSkuList, model.SkuStatusNormal)
			}
		}
	}
}

func GetFilterStoreSkuList(storeSkuList []*partner.StoreSkuInfo) (storeSkuListOut []*partner.StoreSkuInfo) {
	for _, value := range storeSkuList {
		if value.SkuID != 0 {
			storeSkuListOut = append(storeSkuListOut, value)
		}
	}

	return storeSkuListOut
}

func StartOrEndOpStore(ctx *jxcontext.Context, isStart bool, vendorIDList []int, storeIDList []int, startTime, endTime int16, isAsync, isContinueWhenError bool) (retVal interface{}, err error) {
	startProcessTime := time.Now().Unix()
	vendorMap := make(map[int]bool)
	for _, vendorID := range vendorIDList {
		vendorMap[vendorID] = true
	}
	storeIDMap := make(map[int]bool)
	for _, storeID := range storeIDList {
		storeIDMap[storeID] = true
	}
	baseapi.SugarLogger.Debugf("StartOrEndOpStore start time: %v", time.Now())
	storeInfo, err := cms.GetStores(ctx, "", map[string]interface{}{}, 0, -1, utils.DefaultTimeValue, utils.DefaultTimeValue, 0, 0)

	if err != nil {
		baseapi.SugarLogger.Errorf("StartOrEndOpStore cms.GetStores error:%v", err)
	} else {
		taskFunc := func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
			storeListValue := batchItemList[0].(*cms.StoreExt)
			storeID := storeListValue.ID
			//filter for storeID
			if len(storeIDMap) > 0 {
				if _, ok := storeIDMap[storeID]; !ok {
					return retVal, err
				}
			} 
			if storeListValue.StoreMaps != nil {
				for _, vendorListValue := range storeListValue.StoreMaps {
					vendorID := int(utils.MustInterface2Int64(vendorListValue["vendorID"]))
					//filter for vendorID
					if len(vendorMap) > 0 {
						if _, ok := vendorMap[vendorID]; !ok {
							continue
						}
					}
					if _, ok := vendorList[vendorID]; ok {
						startOpStoreTime, endOpStoreTime := GetOpStoreTime(vendorID)
						if startTime != 0 && endTime != 0 {
							startOpStoreTime = startTime
							endOpStoreTime = endTime
							baseapi.SugarLogger.Debugf("StartOrEndOpStore SetStoreOptime:%d do:%d", startTime, endTime)
						}
						vendorStoreID := utils.Interface2String(vendorListValue["vendorStoreID"])
						baseapi.SugarLogger.Debugf("StartOrEndOpStore storeID:%d vendorID:%d vendorStoreID:%s", storeID, vendorID, vendorStoreID)
						singleStoreHandler := partner.GetPurchasePlatformFromVendorID(vendorID).(partner.ISingleStoreStoreSkuHandler)
						storeSkuNameList, err := singleStoreHandler.GetStoreSkusFullInfo(ctx, task, storeID, vendorStoreID, nil)
						if err != nil {
							baseapi.SugarLogger.Errorf("StartOrEndOpStore GetStoreSkusFullInfo error:%v storeID:%d vendorID:%d vendorStoreID:%s", err, storeID, vendorID, vendorStoreID)
						} else {
							SetSkuStock(isStart, storeSkuNameList)
							SetSpecialSkuStatus(ctx, storeID, vendorID, vendorStoreID, storeSkuNameList)
							storeSkuList := putils.StoreSkuFullList2Bare(storeSkuNameList)
							if vendorID == model.VendorIDMTWM {
								storeSkuList = GetFilterStoreSkuList(storeSkuList)
							}
							if len(storeSkuList) > 0 {
								if !isStart {
									AddOrDelExtraStoreOptime(ctx, vendorID, storeID, vendorStoreID, &storeListValue.Store, startOpStoreTime, endOpStoreTime, false)
								}

								_, err = putils.FreeBatchStoreSkuInfo("更新门店商品库存", func(task tasksch.ITask, batchedStoreSkuList []*partner.StoreSkuInfo) (result interface{}, successCount int, err error) {
									//var successList []*partner.StoreSkuInfo
									if _, err = singleStoreHandler.UpdateStoreSkusStock(ctx, storeID, vendorStoreID, batchedStoreSkuList); err == nil {
										//successList = batchedStoreSkuList
										//baseapi.SugarLogger.Debugf("StartOrEndOpStore successList:%v error:%v", successList, err)
									}
									return nil, 0, err
								}, ctx, task, storeSkuList, singleStoreHandler.GetStoreSkusBatchSize(partner.FuncUpdateStoreSkusStock), true)

								if isStart {
									AddOrDelExtraStoreOptime(ctx, vendorID, storeID, vendorStoreID, &storeListValue.Store, startOpStoreTime, endOpStoreTime, true)
								}
							}
						}
					}
				}
			}
			return retVal, err
		}
		task := tasksch.NewParallelTask("StartOrEndOpStore", tasksch.NewParallelConfig().SetParallelCount(taskParallelCount), ctx, taskFunc, storeInfo.Stores)
		tasksch.HandleTask(task, nil, true).Run()
		if isAsync {
			retVal = task.ID
		} else {
			_, err = task.GetResult(0)
			if err != nil {
				baseapi.SugarLogger.Debugf("StartOrEndOpStore tasksch error:%v", err)
			}
			retVal = "1"
		}
	}
	endProcessTime := time.Now().Unix()
	diff := endProcessTime - startProcessTime
	baseapi.SugarLogger.Debugf("StartOrEndOpStore end time: %v", time.Now())
	baseapi.SugarLogger.Debugf("StartOrEndOpStore cost time: %d sec", diff)

	return retVal, err
}

func GetVendorStoreRefreshTime(vendorID int) (startTimeList, stopTimeList []string) {
	isJXCS := globals.IsMainProductEnv()
	refreshTimeList := vendorStoreRefreshTimeList[vendorID]
	if isJXCS {
		startTimeList = []string{refreshTimeList[2]}
		stopTimeList = []string{refreshTimeList[3]}
	} else {
		startTimeList = []string{refreshTimeList[0]}
		stopTimeList = []string{refreshTimeList[1]}
	}
	return startTimeList, stopTimeList
}

func RefreshStore(vendorID int) {
	ctx := jxcontext.AdminCtx
	startTimeList, stopTimeList := GetVendorStoreRefreshTime(vendorID)
	vendorIDList := []int{vendorID}
	storeIDList := []int{}
	ScheduleTimerFunc("StartOpStore", func() {
		if !IsImportantTaskRunning(TaskNameSyncStoreSku) {
			StartOrEndOpStore(ctx, true, vendorIDList, storeIDList, 0, 0, false, true)
		}
	}, startTimeList)
	ScheduleTimerFunc("EndOpStore", func() {
		if !IsImportantTaskRunning(TaskNameSyncStoreSku) {
			StartOrEndOpStore(ctx, false, vendorIDList, storeIDList, 0, 0, false, true)
		}
	}, stopTimeList)
}

func InitEx() {
	for index, value := range vendorList {
		if value {
			RefreshStore(index)
		}
	}
}