package cms

import (
	"errors"

	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/jxcallback/scheduler/basesch"
	"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 VendorSync struct {
}

var (
	MultiStoresVendorHandlers []partner.IMultipleStoresHandler
	SingleStoreVendorIDs      []int
)

var (
	ErrHaveNotImplementedYet = errors.New("还没有实现")
	ErrEntityNotExist        = errors.New("找不到相应实体")
)

func Init() {
	for k, v := range basesch.FixedBaseScheduler.PurchasePlatformHandlers {
		if multiHandler, ok := v.(partner.IMultipleStoresHandler); ok {
			MultiStoresVendorHandlers = append(MultiStoresVendorHandlers, multiHandler)
		} else if _, ok := v.(partner.ISingleStoreHandler); ok {
			SingleStoreVendorIDs = append(SingleStoreVendorIDs, k)
		} else {
			panic("delivery platform type is wrong!")
		}
	}
}

func (v *VendorSync) SyncCategory(db *dao.DaoDB, categoryID int, isForce bool, userName string) (err error) {
	if db == nil {
		db = dao.GetDB()
	}
	// v.LoopSingleStoreVendors(db, "SyncCategory", userName, func(batchItemList []interface{}, params ...interface{}) (interface{}, error) {
	// 	storeMap := batchItemList[0].(*model.StoreMap)
	// 	handler := GetPurchaseHandler(storeMap.VendorID).(partner.ISingleStoreHandler)
	// 	return nil, nil
	// })

	err = v.LoopMultiStoresVendors(db, func(batchItemList []interface{}, params ...interface{}) (interface{}, error) {
		multiStoresHandler := batchItemList[0].(partner.IMultipleStoresHandler)
		var cats []*model.SkuCategory
		cond := make(map[string]interface{})
		if categoryID > 0 {
			cond[model.FieldID] = categoryID
		}
		if err = dao.GetEntities(db, &cats, cond, true); err == nil {
			tasksch.RunTask("", func(batchItemList []interface{}, params ...interface{}) (interface{}, error) {
				cat := batchItemList[0].(*model.SkuCategory)
				if (cat.JdSyncStatus & model.SyncFlagDeletedMask) != 0 { //删除
					err = multiStoresHandler.DeleteCategory(cat, userName)
				} else if (cat.JdSyncStatus&model.SyncFlagNewMask) != 0 || isForce { // 新增
					err = multiStoresHandler.CreateCategory(cat, userName)
				} else if (cat.JdSyncStatus & model.SyncFlagModifiedMask) != 0 { // 修改
					err = multiStoresHandler.UpdateCategory(cat, userName)
				}
				if err == nil {
					cat.JdSyncStatus = 0
					_, err = dao.UpdateEntity(db, cat, model.FieldJdSyncStatus)
				}
				return nil, err
			}, nil, len(cats), 1, "", cats)
		}
		return nil, err
	})
	return err
}

func (v *VendorSync) SyncStore(db *dao.DaoDB, vendorID int, store *model.Store, isForce bool, userName string) (err error) {
	globals.SugarLogger.Debugf("SyncStore, store:%s", utils.Format4Output(store, true))
	if db == nil {
		db = dao.GetDB()
	}
	err = v.LoopStoreMap(db, store.ID, func(batchItemList []interface{}, params ...interface{}) (interface{}, error) {
		storeMap := batchItemList[0].(*model.StoreMap)
		globals.SugarLogger.Debugf("SyncStore, storeMap:%s", utils.Format4Output(store, true))
		if (vendorID == -1 || vendorID == storeMap.VendorID) && (isForce || storeMap.SyncStatus != 0) {
			if handler := GetPurchaseHandler(storeMap.VendorID); handler != nil {
				if err = handler.UpdateStore(store.ID, userName); err == nil {
					storeMap.SyncStatus = 0
					_, err = dao.UpdateEntity(db, storeMap, model.FieldSyncStatus)
				}
			}
		}
		return nil, err
	})
	return err
}

func (v *VendorSync) SyncSku(db *dao.DaoDB, nameID, skuID int, isForce bool, userName string) (err error) {
	if db == nil {
		db = dao.GetDB()
	}
	// v.LoopSingleStoreVendors(db, "SyncSku", userName, func(batchItemList []interface{}, params ...interface{}) (interface{}, error) {
	// 	storeMap := batchItemList[0].(*model.StoreMap)
	// 	handler := GetPurchaseHandler(storeMap.VendorID).(partner.ISingleStoreHandler)
	// 	return nil, nil
	// })
	err = v.LoopMultiStoresVendors(db, func(batchItemList []interface{}, params ...interface{}) (interface{}, error) {
		multiStoresHandler := batchItemList[0].(partner.IMultipleStoresHandler)
		var skuList []*model.Sku
		cond := make(map[string]interface{})
		if nameID != -1 {
			cond[model.FieldNameID] = nameID
		}
		if skuID != -1 {
			cond[model.FieldID] = skuID
		}
		if err = dao.GetEntities(db, &skuList, cond, true); err == nil {
			tasksch.RunTask("", func(batchItemList []interface{}, params ...interface{}) (interface{}, error) {
				sku := batchItemList[0].(*model.Sku)
				if (skuID == -1 || skuID == sku.ID) && (isForce || sku.JdSyncStatus != 0) {
					updateFields := []string{model.FieldJdSyncStatus}
					if sku.JdSyncStatus&model.SyncFlagDeletedMask != 0 { // 删除
						err = multiStoresHandler.CreateSku(sku, userName)
						updateFields = append(updateFields, model.FieldJdID)
					} else if sku.JdSyncStatus&model.SyncFlagNewMask != 0 { // 新增
						err = multiStoresHandler.DeleteSku(sku, userName)
					} else if sku.JdSyncStatus&model.SyncFlagModifiedMask != 0 { // 修改
						err = multiStoresHandler.UpdateSku(sku, userName)
					}
					if err == nil {
						sku.JdSyncStatus = 0
						dao.UpdateEntity(db, sku, updateFields...)
					}
				}
				return nil, err
			}, nil, len(skuList), 1, "", skuList)
		}
		return nil, err
	})
	return err
}

//
func (v *VendorSync) SyncStoreSku(db *dao.DaoDB, storeID int, skuIDs []int, isForce bool, userName string) (err error) {
	globals.SugarLogger.Debug("SyncStoreSku")
	if db == nil {
		db = dao.GetDB()
	}
	err = v.LoopStoreMap(db, storeID, func(batchItemList []interface{}, params ...interface{}) (interface{}, error) {
		storeMap := batchItemList[0].(*model.StoreMap)
		if handler := GetPurchaseHandler(storeMap.VendorID); handler != nil {
			err = handler.SyncStoreSku(storeID, skuIDs, isForce, userName)
		}
		return nil, err
	})
	return err
}

func (v *VendorSync) LoopStoreMap(db *dao.DaoDB, storeID int, handler tasksch.WorkFunc) (err error) {
	storeMaps, err := GetStoreVendorMaps(db, storeID, -1)
	if err == nil {
		task := tasksch.RunTask("", handler, nil, len(storeMaps), 1, "", storeMaps)
		_, err = task.GetResult(0)
	}
	return err
}

func (v *VendorSync) LoopMultiStoresVendors(db *dao.DaoDB, handler tasksch.WorkFunc) (err error) {
	task := tasksch.RunTask("", handler, nil, len(MultiStoresVendorHandlers), 1, "", MultiStoresVendorHandlers)
	_, err = task.GetResult(0)
	return err
}

func (v *VendorSync) LoopSingleStoreVendors(db *dao.DaoDB, taskName, userName string, handler tasksch.WorkFunc) (err error) {
	var storeMaps []*model.StoreMap
	if err = dao.GetRows(db, &storeMaps, `
	SELECT *
	FROM store_map
	WHERE vendor_id IN (`+dao.GenQuestionMarks(len(SingleStoreVendorIDs))+")", SingleStoreVendorIDs); err == nil {
		parellelCount := len(storeMaps)
		if parellelCount > 20 {
			parellelCount = 20
		}
		tasksch.RunManagedTask(taskName, handler, nil, parellelCount, 1, userName, storeMaps)
	}
	return err
}