package mtwm

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

func (p *PurchaseHandler) SyncStoreCategory(ctx *jxcontext.Context, parentTask tasksch.ITask, storeID int, isAsync bool) (hint string, err error) {
	userName := ctx.GetUserName()
	strStoreID := utils.Int2Str(storeID)
	db := dao.GetDB()
	rootTask := tasksch.NewSeqTask("mtwm SyncStoreCategory", userName, func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
		level := step + 1
		catList, err := dao.GetStoreCategories(db, model.VendorIDMTWM, storeID, level)
		task := tasksch.NewParallelTask("mtwm SyncStoreCategory2", nil, userName, func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
			updateFields := []string{dao.GetSyncStatusStructField(model.VendorNames[model.VendorIDMTWM])}
			catInfo := batchItemList[0].(*dao.StoreCatSyncInfo)
			if globals.EnableStoreWrite && globals.EnableMtwmStoreWrite {
				if catInfo.MtwmSyncStatus&model.SyncFlagDeletedMask != 0 { // 删除
					err = api.MtwmAPI.RetailCatDelete(strStoreID, catInfo.MtwmID)
				} else if catInfo.MtwmSyncStatus&(model.SyncFlagNewMask|model.SyncFlagModifiedMask) != 0 { // 新增
					catName := catInfo.CatName
					subCatName := ""
					originName := ""
					if catInfo.MtwmSyncStatus&model.SyncFlagNewMask == 0 {
						originName = catInfo.MtwmID
					}
					if level == 2 {
						originName = catInfo.ParentCatName
						catName = catInfo.ParentCatName
						subCatName = catInfo.CatName
						if catInfo.MtwmSyncStatus&model.SyncFlagNewMask == 0 {
							originName = catInfo.MtwmID
							catName = catInfo.CatName
							subCatName = ""
						}
					}
					if catName == "" {
						panic("catName is empty")
					}
					if err := api.MtwmAPI.RetailCatUpdate(strStoreID, originName, catName, subCatName, catInfo.Seq); err == nil {
						catInfo.MtwmID = catInfo.CatName
						updateFields = append(updateFields, dao.GetVendorThingIDStructField(model.VendorNames[model.VendorIDMTWM]))
					}
				}
			}
			if err == nil {
				db2 := dao.GetDB()
				catInfo.MtwmSyncStatus = 0
				_, err = dao.UpdateEntity(db2, &catInfo.StoreSkuCategoryMap, updateFields...)
			}
			return nil, err
		}, catList)
		rootTask.AddChild(task).Run()
		_, err = task.GetResult(0)
		return nil, err
	}, 2)
	tasksch.AddChild(parentTask, rootTask).Run()
	if !isAsync {
		_, err = rootTask.GetResult(0)
	}
	return rootTask.ID, err
}

func (p *PurchaseHandler) ReadStoreCategories(storeID int) (cats []*model.SkuCategory, err error) {
	return nil, nil
}

func (p *PurchaseHandler) SyncLocalStoreCategory(db *dao.DaoDB, storeID int, userName string) (err error) {
	remoteCats, err := api.MtwmAPI.RetailCatList(utils.Int2Str(storeID))
	if err == nil {
		return err
	}
	if db == nil {
		db = dao.GetDB()
	}
	catMap := make(map[string]*dao.StoreCatSyncInfo)
	for i := 0; i < 2; i++ {
		localCats, err := dao.GetStoreCategories(db, model.VendorIDMTWM, storeID, i+1)
		if err != nil {
			return err
		}
		for _, cat := range localCats {
			cat.StoreSkuCategoryMap.MtwmSyncStatus = model.SyncFlagNewMask
			catMap[cat.ParentVendorCatID+"/"+cat.MtwmID] = cat
		}
	}
	strStoreID := utils.Int2Str(storeID)

	processRemoteCat := func(catName, parentCatName string) (err error) {
		localCat := catMap[parentCatName+"/"+catName]
		if localCat == nil {
			if err = api.MtwmAPI.RetailCatDelete(strStoreID, catName); err != nil {
				return err
			}
		} else {
			// localCat.StoreSkuCategoryMap.MtwmSyncStatus = model.SyncFlagModifiedMask
		}
		return nil
	}

	for _, remoteCat := range remoteCats {
		name := utils.Interface2String(remoteCat.Name)
		if err = processRemoteCat("", name); err != nil {
			return err
		}
		for _, subRemoteCat := range remoteCat.Children {
			if err = processRemoteCat(name, utils.Interface2String(subRemoteCat.Name)); err != nil {
				return err
			}
		}
	}
	return err
}

func (p *PurchaseHandler) ReadStoreSku(storeID, skuID int) (skuNameExt *model.SkuNameExt, err error) {
	return nil, nil
}

func (p *PurchaseHandler) SyncStoreSkus(ctx *jxcontext.Context, parentTask tasksch.ITask, storeID int, skuIDs []int, isAsync, isContinueWhenError bool) (hint string, err error) {
	return hint, err
}

func (p *PurchaseHandler) RefreshStoresAllSkusID(ctx *jxcontext.Context, parentTask tasksch.ITask, isAsync bool, storeIDs []int) (hint string, err error) {
	return hint, err
}

func (p *PurchaseHandler) FullSyncStoreSkus(ctx *jxcontext.Context, parentTask tasksch.ITask, storeID int, isAsync, isContinueWhenError bool) (hint string, err error) {
	return hint, err
}