package cms

import (
	"fmt"
	"time"

	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/baseapi/utils/errlist"
	"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/model/dao"
	"git.rosy.net.cn/jx-callback/business/partner"
	"git.rosy.net.cn/jx-callback/globals"
)

type tMultiStoreVendorInfo struct {
	VendorID int
	OrgCode  string
}

func CombineVendorIDAndOrgCode(vendorID int, orgCode string) string {
	return fmt.Sprintf("%d-%s", vendorID, orgCode)
}

func getMultiStoreVendorInfoList() (list []*tMultiStoreVendorInfo) {
	vendorIDs := partner.GetMultiStoreVendorIDs()
	for _, vendorID := range vendorIDs {
		orgCodeList := partner.CurAPIManager.GetAppOrgCodeList(vendorID)
		for _, v := range orgCodeList {
			list = append(list, &tMultiStoreVendorInfo{
				VendorID: vendorID,
				OrgCode:  v,
			})
		}
	}
	return list
}

func SyncCategories(ctx *jxcontext.Context, parentTask tasksch.ITask, vendorIDs []int, appOrgCodes []string, catIDs []int, isAsync bool) (hint string, err error) {
	globals.SugarLogger.Debugf("SyncCategories catIDs:%v", catIDs)
	db := dao.GetDB()
	catList, err := dao.GetSkuCategoryWithVendor(db, nil, nil, -1, catIDs, true)
	if err == nil && len(catList) > 0 {
		// todo 按vendorID orgCode合并操作
		task := tasksch.NewParallelTask(fmt.Sprintf("同步分类:%v", catIDs), nil, ctx,
			func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
				catVendorInfo := batchItemList[0].(*dao.SkuStoreCatInfo)
				if multiStoresHandler, ok := partner.GetPurchasePlatformFromVendorID(catVendorInfo.VendorID).(partner.IMultipleStoresHandler); ok {
					if model.IsSyncStatusDelete(catVendorInfo.CatSyncStatus) { //删除
						if !dao.IsVendorThingIDEmpty(catVendorInfo.VendorCatID) &&
							model.IsSyncStatusNeedDelete(catVendorInfo.CatSyncStatus) {
							err = multiStoresHandler.DeleteCategory2(ctx, catVendorInfo)
						}
					} else if model.IsSyncStatusNew(catVendorInfo.CatSyncStatus) { // 新增
						err = multiStoresHandler.CreateCategory2(ctx, catVendorInfo)
					} else if model.IsSyncStatusUpdate(catVendorInfo.CatSyncStatus) { // 修改
						err = multiStoresHandler.UpdateCategory2(ctx, catVendorInfo)
					}
				} else {
					err = fmt.Errorf("平台:%d不合法", catVendorInfo.VendorID)
				}
				if err = OnThingSync(ctx, dao.GetDB(), SkuCategoryVendor2ThingMap(catVendorInfo), err); err == nil {
					retVal = []int{1}
				}
				return retVal, err
			}, catList)
		tasksch.HandleTask(task, parentTask, len(catIDs) > 0).Run()
		if isAsync {
			hint = task.GetID()
		} else {
			resultList, err2 := task.GetResult(0)
			if err = err2; err == nil {
				hint = utils.Int2Str(len(resultList))
			}
		}
	}
	return hint, err
}

func SyncSkus(ctx *jxcontext.Context, parentTask tasksch.ITask, vendorIDs []int, appOrgCodes []string, nameIDs, skuIDs []int, isAsync bool) (hint string, err error) {
	globals.SugarLogger.Debugf("SyncSkus nameIDs:%v, skuIDs:%v", nameIDs, skuIDs)
	db := dao.GetDB()
	skuList, err := dao.GetSkusWithVendor(db, nil, nil, nameIDs, skuIDs, true)
	if err == nil && len(skuList) > 0 {
		// todo 按vendorID orgCode合并操作
		task := tasksch.NewParallelTask(fmt.Sprintf("同步商品:%v,%v", nameIDs, skuIDs), nil, ctx,
			func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
				skuVendorInfo := batchItemList[0].(*dao.StoreSkuSyncInfo)
				skuVendorInfo.SkuName = jxutils.ComposeSkuName(skuVendorInfo.Prefix, skuVendorInfo.Name, skuVendorInfo.Comment, skuVendorInfo.Unit, skuVendorInfo.SpecQuality, skuVendorInfo.SpecUnit, 0)
				skuVendorInfo.MergedStatus = jxutils.MergeSkuStatus(skuVendorInfo.Status, skuVendorInfo.NameStatus)
				if multiStoresHandler, ok := partner.GetPurchasePlatformFromVendorID(skuVendorInfo.VendorID).(partner.IMultipleStoresHandler); ok {
					if model.IsSyncStatusDelete(skuVendorInfo.SkuSyncStatus) { //删除
						if !dao.IsVendorThingIDEmpty(skuVendorInfo.VendorSkuID) &&
							model.IsSyncStatusNeedDelete(skuVendorInfo.SkuSyncStatus) {
							err = multiStoresHandler.DeleteSku2(ctx, skuVendorInfo)
						}
					} else if model.IsSyncStatusNew(skuVendorInfo.SkuSyncStatus) { // 新增
						err = multiStoresHandler.CreateSku2(ctx, skuVendorInfo)
					} else if model.IsSyncStatusUpdate(skuVendorInfo.SkuSyncStatus) { // 修改
						err = multiStoresHandler.UpdateSku2(ctx, skuVendorInfo)
					}
				} else {
					err = fmt.Errorf("平台:%d不合法", skuVendorInfo.VendorID)
				}
				if err = OnThingSync(ctx, dao.GetDB(), SkuVendor2ThingMap(skuVendorInfo), err); err == nil {
					retVal = []int{1}
				}
				return retVal, err
			}, skuList)
		tasksch.HandleTask(task, parentTask, len(skuList) > 0).Run()
		if isAsync {
			hint = task.GetID()
		} else {
			resultList, err2 := task.GetResult(0)
			if err = err2; err == nil {
				hint = utils.Int2Str(len(resultList))
			}
		}
	}
	return hint, err
}

func SyncReorderCategories(ctx *jxcontext.Context, parentCatID int, isAsync bool) (hint string, err error) {
	globals.SugarLogger.Debugf("SyncReorderCategories parentCatID:%d", parentCatID)
	db := dao.GetDB()
	hint, err = CurVendorSync.LoopMultiStoresVendors(ctx, db, fmt.Sprintf("分类重排序:%d", parentCatID), isAsync, false,
		func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
			vendorInfo := batchItemList[0].(*tMultiStoreVendorInfo)
			multiStoresHandler := CurVendorSync.GetMultiStoreHandler(vendorInfo.VendorID)
			if multiStoresHandler != nil {
				catList, err2 := dao.GetSkuCategoryWithVendor(db, []int{vendorInfo.VendorID}, []string{vendorInfo.OrgCode}, parentCatID, nil, false)
				if err = err2; err == nil {
					var vendorCatIDList []string
					for _, v := range catList {
						if v.VendorCatID != "" {
							vendorCatIDList = append(vendorCatIDList, v.VendorCatID)
						}
					}
					if len(vendorCatIDList) > 0 {
						if err = multiStoresHandler.ReorderCategories2(ctx, vendorInfo.OrgCode, catList[0].ParentVendorCatID, vendorCatIDList); err == nil {
							retVal = []int{len(vendorCatIDList)}
						}
					}
				}
			} else {
				err = fmt.Errorf("非法平台:%d", vendorInfo.VendorID)
			}
			return retVal, err
		})
	return hint, err
}

func OnCreateThing(ctx *jxcontext.Context, db *dao.DaoDB, thingID int64, thingType int8) (err error) {
	if thingType == model.ThingTypeSkuName {
		return nil
	}
	errList := errlist.New()
	for _, v := range getMultiStoreVendorInfoList() {
		thingMap := &model.ThingMap{
			ThingID:       thingID,
			ThingType:     thingType,
			VendorID:      v.VendorID,
			VendorOrgCode: v.OrgCode,
			SyncStatus:    model.SyncFlagNewMask,
		}
		dao.WrapAddIDCULDEntity(thingMap, ctx.GetUserName())
		errList.AddErr(dao.CreateEntity(db, thingMap))
	}
	// return errList.GetErrListAsOne()
	return nil
}

func OnUpdateThing(ctx *jxcontext.Context, db *dao.DaoDB, thingID int64, thingType int8) (err error) {
	if thingType == model.ThingTypeSkuName {
		return nil
	}
	errList := errlist.New()
	for _, v := range getMultiStoreVendorInfoList() {
		thingMap := &model.ThingMap{
			ThingID:       thingID,
			ThingType:     thingType,
			VendorID:      v.VendorID,
			VendorOrgCode: v.OrgCode,
		}
		thingMap.DeletedAt = utils.DefaultTimeValue
		if err2 := dao.GetEntity(db, thingMap, "ThingID", "ThingType", "VendorID", "VendorOrgCode", model.FieldDeletedAt); err2 == nil {
			thingMap.SyncStatus |= model.SyncFlagModifiedMask
			thingMap.LastOperator = ctx.GetUserName()
			_, err2 = dao.UpdateEntity(db, thingMap)
			errList.AddErr(err2)
		} else if !dao.IsNoRowsError(err2) {
			errList.AddErr(err2)
		}
	}
	// return errList.GetErrListAsOne()
	return nil
}

func OnDeleteThing(ctx *jxcontext.Context, db *dao.DaoDB, thingID int64, thingType int8) (err error) {
	if thingType == model.ThingTypeSkuName {
		return nil
	}
	errList := errlist.New()
	for _, v := range getMultiStoreVendorInfoList() {
		thingMap := &model.ThingMap{
			ThingID:       thingID,
			ThingType:     thingType,
			VendorID:      v.VendorID,
			VendorOrgCode: v.OrgCode,
		}
		thingMap.DeletedAt = utils.DefaultTimeValue
		if err2 := dao.GetEntity(db, thingMap, "ThingID", "ThingType", "VendorID", "VendorOrgCode", model.FieldDeletedAt); err2 == nil {
			if model.IsSyncStatusNew(thingMap.SyncStatus) {
				thingMap.SyncStatus = 0
				thingMap.DeletedAt = time.Now()
			} else {
				thingMap.SyncStatus |= model.SyncFlagDeletedMask
			}
			thingMap.LastOperator = ctx.GetUserName()
			_, err2 = dao.UpdateEntity(db, thingMap)
			errList.AddErr(err2)
		} else if !dao.IsNoRowsError(err2) {
			errList.AddErr(err2)
		}
	}
	// return errList.GetErrListAsOne()
	return nil
}

func SkuCategoryVendor2ThingMap(cat *dao.SkuStoreCatInfo) (thingMap *model.ThingMap) {
	thingMap = &model.ThingMap{
		ThingID:       int64(cat.ID),
		ThingType:     model.ThingTypeCategory,
		VendorID:      cat.VendorID,
		VendorOrgCode: cat.VendorOrgCode,

		SyncStatus:    cat.CatSyncStatus,
		VendorThingID: cat.VendorCatID,
	}
	thingMap.ID = cat.MapID // 一定要赋值
	return thingMap
}

func SkuVendor2ThingMap(sku *dao.StoreSkuSyncInfo) (thingMap *model.ThingMap) {
	thingMap = &model.ThingMap{
		ThingID:       int64(sku.SkuID),
		ThingType:     model.ThingTypeSku,
		VendorID:      sku.VendorID,
		VendorOrgCode: sku.VendorOrgCode,

		SyncStatus:    sku.SkuSyncStatus,
		VendorThingID: sku.VendorSkuID,
	}
	thingMap.ID = sku.BindID // 一定要赋值
	return thingMap
}

func OnThingSync(ctx *jxcontext.Context, db *dao.DaoDB, thingMap *model.ThingMap, syncErr error) (err error) {
	globals.SugarLogger.Debugf("OnThingSync thingMap:%s", utils.Format4Output(thingMap, true))
	if syncErr != nil {
		err = syncErr
		thingMap.Remark = utils.LimitUTF8StringLen(err.Error(), 255)
		dao.UpdateEntity(db, thingMap, "Remark")
	} else {
		updateFields := []string{
			model.FieldSyncStatus,
			model.FieldUpdatedAt,
			model.FieldLastOperator,
			"Remark",
		}
		if model.IsSyncStatusDelete(thingMap.SyncStatus) { //删除
			thingMap.DeletedAt = time.Now()
			thingMap.VendorThingID = ""
			updateFields = append(updateFields, "VendorThingID", model.FieldDeletedAt)
		} else if model.IsSyncStatusNew(thingMap.SyncStatus) { // 新增
			updateFields = append(updateFields, "VendorThingID")
		}
		thingMap.SyncStatus = 0
		thingMap.LastOperator = ctx.GetUserName()
		thingMap.UpdatedAt = time.Now()
		thingMap.Remark = ""
		_, err = dao.UpdateEntity(db, thingMap, updateFields...)
	}
	return err
}