package jd

import (
	"time"

	"git.rosy.net.cn/jx-callback/business/partner"

	"git.rosy.net.cn/jx-callback/business/jxutils"

	"git.rosy.net.cn/jx-callback/globals"
	"git.rosy.net.cn/jx-callback/globals/api"

	"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"
)

type LogicUpdateInfo struct {
	Item      interface{}
	KVs       map[string]interface{}
	Condition map[string]interface{}
}

func CreatePromotionInfos(promotionType int, name string, beginDate, endDate time.Time, outInfoId, advertising, traceId string) (infoId int64, err error) {
	if globals.EnableJdStoreWrite {
		if promotionType == model.ActSkuDirectDown {
			return api.JdAPI.CreatePromotionInfosSingle(name, beginDate, endDate, outInfoId, advertising, traceId)
		} else {
			return api.JdAPI.CreatePromotionInfosLimitTime(name, beginDate, endDate, outInfoId, advertising, traceId)
		}
	} else {
		infoId = jxutils.GenFakeID()
	}
	return infoId, err
}

func CreatePromotionRules(promotionType int, infoId int64, outInfoId string, limitDevice, limitPin, limitCount, limitDaily int, traceId string) (err error) {
	if globals.EnableJdStoreWrite {
		if promotionType == model.ActSkuDirectDown {
			return api.JdAPI.CreatePromotionRulesSingle(infoId, outInfoId, limitDevice, limitPin, limitCount, limitDaily, traceId)
		} else {
			return api.JdAPI.CreatePromotionRulesLimitTime(infoId, outInfoId, limitDevice, limitPin, limitCount, limitDaily, traceId)
		}
	}
	return err
}

func CreatePromotionSku(promotionType int, infoId int64, outInfoId string, skus []*jdapi.PromotionSku, traceId string) (skusResult []*jdapi.PromotionSku, err error) {
	if globals.EnableJdStoreWrite {
		if promotionType == model.ActSkuDirectDown {
			return api.JdAPI.CreatePromotionSkuSingle(infoId, outInfoId, skus, traceId)
		} else {
			return api.JdAPI.CreatePromotionSkuLimitTime(infoId, outInfoId, skus, traceId)
		}
	}
	return skusResult, err
}

func CancelPromotionSku(promotionType int, infoId int64, outInfoId string, skus []*jdapi.PromotionSku, traceId string) (err error) {
	if globals.EnableJdStoreWrite {
		if promotionType == model.ActSkuDirectDown {
			return api.JdAPI.CancelPromotionSkuSingle(infoId, outInfoId, skus, traceId)
		} else {
			return api.JdAPI.CancelPromotionSkuLimitTime(infoId, outInfoId, skus, traceId)
		}
	}
	return err
}

func ConfirmPromotion(promotionType int, infoId int64, outInfoId, traceId string) (err error) {
	if globals.EnableJdStoreWrite {
		if promotionType == model.ActSkuDirectDown {
			return api.JdAPI.ConfirmPromotionSingle(infoId, outInfoId, traceId)
		} else {
			return api.JdAPI.ConfirmPromotionLimitTime(infoId, outInfoId, traceId)
		}
	}
	return err
}

func CancelPromotion(promotionType int, infoId int64, outInfoId, traceId string) (err error) {
	if globals.EnableJdStoreWrite {
		if promotionType == model.ActSkuDirectDown {
			return api.JdAPI.CancelPromotionSingle(infoId, outInfoId, traceId)
		} else {
			return api.JdAPI.CancelPromotionLimitTime(infoId, outInfoId, traceId)
		}
	}
	return err
}

func AdjustPromotionTime(promotionType int, infoId int64, outInfoId string, endDate time.Time, traceId string) (err error) {
	if globals.EnableJdStoreWrite {
		if promotionType == model.ActSkuDirectDown {
			return api.JdAPI.AdjustPromotionTimeSingle(infoId, outInfoId, endDate, traceId)
		} else {
			return api.JdAPI.AdjustPromotionTimeLimitTime(infoId, outInfoId, endDate, traceId)
		}
	}
	return err
}

func AdjustPromotionSku(promotionType int, infoId int64, outInfoId string, skus []*jdapi.PromotionSku, traceId string) (skusResult []*jdapi.PromotionSku, err error) {
	if globals.EnableJdStoreWrite {
		if promotionType == model.ActSkuDirectDown {
			return api.JdAPI.AdjustPromotionSkuSingle(infoId, outInfoId, skus, traceId)
		} else {
			return api.JdAPI.AdjustPromotionSkuLimitTime(infoId, outInfoId, skus, traceId)
		}
	}
	return skusResult, err
}

func getTraceID(ctx *jxcontext.Context) (traceID string) {
	traceID = ctx.GetUserName() + utils.GetUUID()
	return traceID
}

func storeSku2Jd(actStoreSku []*model.ActStoreSku2, handler func(syncStatus int) bool) (jdActStoreSku []*jdapi.PromotionSku) {
	for _, v := range actStoreSku {
		if handler(v.SyncStatus) {
			jdActStoreSku = append(jdActStoreSku, &jdapi.PromotionSku{
				StationNo:      utils.Str2Int64(v.VendorStoreID),
				SkuID:          utils.Str2Int64(v.VendorSkuID),
				PromotionPrice: v.ActPrice,
				// LimitSkuCount:0,
			})
		}
	}
	return jdActStoreSku
}

func (c *PurchaseHandler) CreateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreMap []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
	if act.Type < model.ActOrderBegin {
		act.VendorActID, err = createSkuAct(ctx, act, actStoreSku)
	} else {

	}
	return err
}

func createSkuAct(ctx *jxcontext.Context, act *model.Act2, actStoreSku []*model.ActStoreSku2) (vendorActID string, err error) {
	traceID := getTraceID(ctx)
	outInfoID := ""
	if act.VendorActID == "" {
		outInfoID = utils.Int2Str(act.ID)
	}
	infoID, err2 := CreatePromotionInfos(act.Type, act.Name, act.BeginAt, act.EndAt, outInfoID, act.Advertising, traceID)
	if err = err2; err == nil {
		vendorActID = utils.Int64ToStr(infoID)
		if err = CreatePromotionRules(act.Type, infoID, "", act.LimitDevice, act.LimitPin, act.LimitCount, act.LimitDaily, traceID); err == nil {
			if _, err = CreatePromotionSku(act.Type, infoID, "", storeSku2Jd(actStoreSku, model.IsSyncStatusNeedCreate), traceID); err == nil {
				err = ConfirmPromotion(act.Type, infoID, "", traceID)
			}
		}
	}
	return vendorActID, err
}

func cancelSkuActSkus(ctx *jxcontext.Context, actType int, vendorActID string, actStoreSku []*model.ActStoreSku2) (err error) {
	if skuList := storeSku2Jd(actStoreSku, model.IsSyncStatusNeedDelete); len(skuList) > 0 {
		err = CancelPromotionSku(actType, utils.Str2Int64(vendorActID), "", skuList, getTraceID(ctx))
	}
	return err
}

func (c *PurchaseHandler) UpdateAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actOrderRules []*model.ActOrderRule, actStoreMap2Remove, actStoreMap2Add, actStoreMap2Update []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
	return err
}

func (c *PurchaseHandler) CancelAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actStoreMap []*model.ActStore2, actStoreSku []*model.ActStoreSku2) (err error) {
	traceID := getTraceID(ctx)
	if act.Type < model.ActOrderBegin {
		outInfoID := utils.Int2Str(act.ID)
		err = CancelPromotion(act.Type, 0, outInfoID, traceID)
	}
	return err
}

func (c *PurchaseHandler) SyncAct(ctx *jxcontext.Context, parentTask tasksch.ITask, act *model.Act2, actStoreList []*model.ActStore2, actStoreSkuList []*model.ActStoreSku2) (err error) {
	traceID := getTraceID(ctx)

	actStoreMap := partner.SplitActStore(actStoreList)
	actStoreSkuMap := partner.SplitActStoreSku(actStoreSkuList)
	var actStoreSkuList4Create, actStoreSkuList4Delete []*model.ActStoreSku2
	var okList []*LogicUpdateInfo
	for _, actStore := range actStoreMap {
		for _, actStoreSku := range actStoreSkuMap[actStore.StoreID] {
			if model.IsSyncStatusNeedCreate(actStoreSku.SyncStatus) {
				if actStore.VendorActID == "" {
					actStoreSkuList4Create = append(actStoreSkuList4Create, actStoreSku)
				} else {
					if actStoreSku.VendorActID, err = createSkuAct(ctx, act, []*model.ActStoreSku2{actStoreSku}); err != nil {
						return err
					}
					okList = append(okList, &LogicUpdateInfo{
						Item: partner.ActStoreSku2ActStoreSkuMap(actStoreSku),
						KVs: map[string]interface{}{
							model.FieldSyncStatus:  0,
							model.FieldVendorActID: actStoreSku.VendorActID,
						},
					})
				}
			} else if model.IsSyncStatusNeedDelete(actStoreSku.SyncStatus) {
				if actStoreSku.VendorActID == "" {
					actStoreSkuList4Delete = append(actStoreSkuList4Delete, actStoreSku)
				} else {
					if err = CancelPromotion(act.Type, utils.Str2Int64(actStoreSku.VendorActID), "", traceID); err != nil {
						return err
					}
					okList = append(okList, &LogicUpdateInfo{
						Item: partner.ActStoreSku2ActStoreSkuMap(actStoreSku),
						KVs: map[string]interface{}{
							model.FieldSyncStatus: 0,
							model.FieldDeletedAt:  time.Now(),
						},
					})
				}
			}
		}
		if actStore.VendorActID != "" {
			if model.IsSyncStatusDelete(actStore.SyncStatus) {
				if err = CancelPromotion(act.Type, utils.Str2Int64(actStore.VendorActID), "", traceID); err != nil {
					return err
				}
				okList = append(okList, &LogicUpdateInfo{
					Item: partner.ActStore2ActStoreMap(actStore),
					KVs: map[string]interface{}{
						model.FieldSyncStatus: 0,
						model.FieldDeletedAt:  time.Now(),
					},
				})

			} else if len(actStoreSkuList4Delete) > 0 {
				if err = cancelSkuActSkus(ctx, act.Type, actStore.VendorActID, actStoreSkuList4Delete); err != nil {
					return err
				}
			}
			for _, v := range actStoreSkuList4Delete {
				okList = append(okList, &LogicUpdateInfo{
					Item: partner.ActStoreSku2ActStoreSkuMap(v),
					KVs: map[string]interface{}{
						model.FieldSyncStatus: 0,
						model.FieldDeletedAt:  time.Now(),
					},
				})
			}
			actStoreSkuList4Delete = nil
		}

		if act.VendorActID != "" {
			if len(actStoreSkuList4Create) > 0 {
				if actStore.VendorActID, err = createSkuAct(ctx, act, actStoreSkuList4Create); err != nil {
					return err
				}
				okList = append(okList, &LogicUpdateInfo{
					Item: partner.ActStore2ActStoreMap(actStore),
					KVs: map[string]interface{}{
						model.FieldSyncStatus: 0,
					},
				})
				for _, v := range actStoreSkuList4Create {
					okList = append(okList, &LogicUpdateInfo{
						Item: partner.ActStoreSku2ActStoreSkuMap(v),
						KVs: map[string]interface{}{
							model.FieldSyncStatus: 0,
						},
					})
				}
				actStoreSkuList4Create = nil
			}
		}
	}
	// db := dao.GetDB()

	return err
}