package cms

import (
	"errors"
	"fmt"
	"math"
	"strconv"
	"time"

	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/jxcallback/auth/weixin"
	"git.rosy.net.cn/jx-callback/business/jxutils"
	"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/business/model/dao"
	"git.rosy.net.cn/jx-callback/globals"
	"github.com/astaxie/beego/orm"
)

const (
	CopyStoreSkuModeFresh  = "fresh"
	CopyStoreSkuModeUpdate = "update"
	// CopyStoreSkuModeAdd    = "add"
)

// GetStoreSkus用
type StoreSkuNameExt struct {
	model.SkuName
	UnitPrice int                      `json:"unitPrice"`
	Skus      []map[string]interface{} `orm:"-" json:"skus"`
	SkusStr   string                   `json:"-"`
}

// GetStoreSkus用
type StoreSkuNamesInfo struct {
	TotalCount int                `json:"totalCount"`
	SkuNames   []*StoreSkuNameExt `json:"skuNames"`
}

// UpdateStoreSku用，API调用时
type StoreSkuBindSkuInfo struct {
	SkuID  int `json:"skuID"`
	IsSale int `json:"isSale"` // -1：不可售，0：忽略，1：可售

	ElmID  int64 `json:"elmID"`
	EbaiID int64 `json:"ebaiID"`
}

// UpdateStoreSku用，API调用时
type StoreSkuBindInfo struct {
	NameID     int                    `json:"nameID"`
	UnitPrice  int                    `json:"unitPrice"` // 对于是份的SKU就是单价（每斤价格），其它则为总价
	IsFocus    int                    `json:"isFocus"`   // -1：不关注，0：忽略，1：关注
	IsSale     int                    `json:"isSale"`    // -1：不可售，0：忽略，1：可售
	SubStoreID int                    `json:"subStoreID"`
	Skus       []*StoreSkuBindSkuInfo `json:"skus"`
}

type tStoreSkuBindAndSpec struct {
	model.StoreSkuBind
	SpecQuality  float32
	SpecUnit     string
	SkuNamePrice int
	SkuNameUnit  string
	RealSkuID    int `orm:"column(real_sku_id)"`
}

type SkuSaleInfo struct {
	StoreID int `orm:"column(store_id)"`
	SkuID   int `orm:"column(sku_id)"`
	Times   int // 销售的次数
	Count   int // 销售的总份数
}

type StoreOpRequestInfo struct {
	model.StoreOpRequest
	StoreName     string
	SkuNamePrefix string
	SkuNameName   string
}

// 商品不可售，直接排除
// 如果门店商品是可售状态，那么会忽略区域限制。否则有区域限制
func GetStoreSkus(ctx *jxcontext.Context, storeID int, isFocus bool, keyword string, params map[string]interface{}, offset, pageSize int) (skuNamesInfo *StoreSkuNamesInfo, err error) {
	db := dao.GetDB()
	sql := `
	FROM sku_name t1
	JOIN sku t2 ON t1.id = t2.name_id AND t2.deleted_at = ? AND t2.status = ?
	LEFT JOIN store_sku_bind t4 ON t4.sku_id = t2.id AND t4.deleted_at = ? AND t4.store_id = ?
	JOIN store t3 ON t3.id = ?
	LEFT JOIN sku_name_place_bind t5 ON t1.id = t5.name_id AND t3.city_code = t5.place_code
	WHERE t1.deleted_at = ? AND (t1.is_global = 1 OR t5.id IS NOT NULL OR t4.status = ?)
	`
	if isFocus {
		sql += " AND t4.sku_id IS NOT NULL"
	} else {
		sql += " AND t4.sku_id IS NULL"
	}
	sqlParams := []interface{}{
		utils.DefaultTimeValue,
		model.SkuStatusNormal,
		utils.DefaultTimeValue,
		storeID,
		storeID,
		utils.DefaultTimeValue,
		model.SkuStatusNormal,
	}
	if keyword != "" {
		keywordLike := "%" + keyword + "%"
		sql += " AND (t1.name LIKE ? OR t1.prefix LIKE ? OR t2.comment LIKE ?"
		sqlParams = append(sqlParams, keywordLike, keywordLike, keywordLike)

		if keywordInt64, err2 := strconv.ParseInt(keyword, 10, 64); err2 == nil {
			sql += " OR t2.jd_id = ? OR t4.id = ?"
			sqlParams = append(sqlParams, keywordInt64, keywordInt64)
		}
		sql += ")"
	}

	if params["nameID"] != nil {
		sql += " AND t1.id = ?"
		sqlParams = append(sqlParams, params["nameID"].(int))
	}
	if params["categoryID"] != nil {
		cat := &model.SkuCategory{}
		cat.ID = params["categoryID"].(int)
		if err = dao.GetEntity(db, cat); err != nil {
			return nil, err
		}
		sql += " AND (t1.category_id = ?"
		sqlParams = append(sqlParams, cat.ID)
		if cat.Level == 1 {
			sql += " OR t1.category_id IN (SELECT id FROM sku_category WHERE parent_id = ?)"
			sqlParams = append(sqlParams, cat.ID)
		}
		sql += ")"
	}
	if params["jdID"] != nil {
		sql += " AND t1.jd_id = ?"
		sqlParams = append(sqlParams, params["jdID"].(int))
	}
	if params["name"] != nil {
		sql += " AND t1.name LIKE ?"
		sqlParams = append(sqlParams, "%"+params["name"].(string)+"%")
	}
	if params["prefix"] != nil {
		sql += " AND t1.prefix LIKE ?"
		sqlParams = append(sqlParams, "%"+params["prefix"].(string)+"%")
	}
	if params["unit"] != nil {
		sql += " AND t1.unit = ?"
		sqlParams = append(sqlParams, params["unit"].(string))
	}
	if params["skuID"] != nil {
		skuID, ok := params["skuID"].(int)
		if ok {
			sql += " AND t2.id = ?"
			sqlParams = append(sqlParams, skuID)
		} else {
			skuIDs := params["skuID"].([]interface{})
			sql += " AND t2.id IN (" + dao.GenQuestionMarks(len(skuIDs)) + ")"
			sqlParams = append(sqlParams, skuIDs)
		}
	}
	if isFocus && params["fromStatus"] != nil {
		fromStatus := params["fromStatus"].(int)
		toStatus := fromStatus
		if params["toStatus"] != nil {
			toStatus = params["toStatus"].(int)
		}
		sql += " AND t4.status >= ? AND t4.status <= ?"
		sqlParams = append(sqlParams, fromStatus, toStatus)
	}
	sql += `
	GROUP BY
	t1.id,
	t1.created_at,
	t1.updated_at,
	t1.last_operator,
	t1.deleted_at,
	t1.prefix,
	t1.name,
	t1.brand_id,
	t1.category_id,
	t1.is_global,
	t1.unit,
	t1.price,
	t1.img,
	t1.elm_img_hash_code
	`
	sqlData := `
		SELECT
		SQL_CALC_FOUND_ROWS
		t1.id,
		t1.created_at,
		t1.updated_at,
		t1.last_operator,
		t1.deleted_at,
		t1.prefix,
		t1.name,
		t1.brand_id,
		t1.category_id,
		t1.is_global,
		t1.unit,
		t1.price,
		t1.img,
		t1.elm_img_hash_code,
		CONCAT("[", GROUP_CONCAT(DISTINCT CONCAT('{"id":', t2.id, ',"comment":"', t2.comment, '","status":', t2.status, ',"createdAt":"',
		CONCAT(REPLACE(IF(t4.created_at IS NULL, '1970-01-01 00:00:00', t4.created_at)," ","T"),"+08:00"), '","updatedAt":"', CONCAT(REPLACE(IF(t4.updated_at IS NULL, '1970-01-01 00:00:00', t4.updated_at)," ","T"),"+08:00"),
		'","lastOperator":"', IF(t4.last_operator IS NULL, '', t4.last_operator), '","specQuality":', t2.spec_quality, ',"specUnit":"', t2.spec_unit, '","weight":', t2.weight,
		',"jdID":', t2.jd_id, ',"categoryID":', t2.category_id,  ',"nameID":', t2.name_id, ',"subStoreID":', IF(t4.sub_store_id IS NULL, 0, t4.sub_store_id),
		',"price":', IF(t4.price IS NULL, 0, t4.price), ',"unitPrice":', IF(t4.unit_price IS NULL, t1.price, t4.unit_price),
		',"storeSkuStatus":', IF(t4.status IS NULL, 0, t4.status), "}")), "]") skus_str
		` + sql + `
	ORDER BY t1.id DESC
	LIMIT ? OFFSET ?`
	pageSize = jxutils.FormalizePageSize(pageSize)
	sqlOffset := offset
	sqlPageSize := pageSize
	isSaleInfo := params["stFromTime"] != nil
	if isSaleInfo {
		sqlOffset = 0
		sqlPageSize = jxutils.FormalizePageSize(-1)
	}
	sqlParams = append(sqlParams, sqlPageSize, sqlOffset)
	skuNamesInfo = &StoreSkuNamesInfo{}
	// globals.SugarLogger.Debug(sqlData)
	dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db)
			panic(r)
		}
	}()
	// globals.SugarLogger.Debug(sqlData, sqlParams)
	if err = dao.GetRows(db, &skuNamesInfo.SkuNames, sqlData, sqlParams...); err == nil {
		countInfo := &struct{ Ct int }{}
		if err = dao.GetRow(db, countInfo, "SELECT FOUND_ROWS() ct"); err == nil {
			skuNamesInfo.TotalCount = countInfo.Ct
			for _, skuName := range skuNamesInfo.SkuNames {
				if skuName.SkusStr != "" {
					if err = utils.UnmarshalUseNumber([]byte(skuName.SkusStr), &skuName.Skus); err != nil {
						dao.Rollback(db)
						return nil, err
					}
					if len(skuName.Skus) > 0 {
						skuName.UnitPrice = int(utils.MustInterface2Int64(skuName.Skus[0]["unitPrice"]))
						for _, v := range skuName.Skus {
							delete(v, "unitPrice")
						}
					} else {
						skuName.UnitPrice = skuName.Price
					}
				}
			}
			if isSaleInfo {
				var (
					saleInfoList       []*SkuSaleInfo
					skuIDs             []int
					timeList           []time.Time
					fromCount, toCount int
				)
				saleInfoMap := make(map[int64]*SkuSaleInfo)
				for _, skuName := range skuNamesInfo.SkuNames {
					for _, sku := range skuName.Skus {
						skuIDs = append(skuIDs, int(utils.MustInterface2Int64(sku["id"])))
					}
				}
				toTimeStr := ""
				if params["stToTime"] != nil {
					toTimeStr = params["stToTime"].(string)
				}
				if timeList, err = jxutils.BatchStr2Time(params["stFromTime"].(string), toTimeStr); err != nil {
					dao.Rollback(db)
					return nil, err
				}
				if params["stFromCount"] != nil {
					fromCount = params["stFromCount"].(int)
				}
				toCount = math.MaxInt32
				if params["stToCount"] != nil {
					toCount = params["stToCount"].(int)
				}
				// 不能用SQL筛除，否则不能区分是没有销量，还是不在条件中
				if saleInfoList, err = GetStoresSkusSaleInfo(ctx, []int{storeID}, skuIDs, timeList[0], timeList[1], 0, math.MaxInt32); err != nil {
					dao.Rollback(db)
					return nil, err
				}
				for _, saleInfo := range saleInfoList {
					saleInfoMap[int64(saleInfo.StoreID)*100000+int64(saleInfo.SkuID)] = saleInfo
				}
				storeID2 := int64(storeID) * 100000
				var newSkuNames []*StoreSkuNameExt
				for _, skuName := range skuNamesInfo.SkuNames {
					var newSkus []map[string]interface{}
					for _, sku := range skuName.Skus {
						saleInfo := saleInfoMap[storeID2+utils.MustInterface2Int64(sku["id"])]
						if saleInfo == nil && fromCount == 0 {
							saleInfo = &SkuSaleInfo{}
						}
						if saleInfo != nil && saleInfo.Count >= fromCount && saleInfo.Count <= toCount {
							sku["times"] = saleInfo.Times
							sku["count"] = saleInfo.Count
							newSkus = append(newSkus, sku)
						}
					}
					if len(newSkus) > 0 {
						skuName.Skus = newSkus
						newSkuNames = append(newSkuNames, skuName)
					}
				}
				skuNamesInfo.TotalCount = len(newSkuNames)
				skuNamesInfo.SkuNames = nil
				if offset < skuNamesInfo.TotalCount {
					endIndex := offset + pageSize
					if endIndex > skuNamesInfo.TotalCount {
						endIndex = skuNamesInfo.TotalCount
					}
					skuNamesInfo.SkuNames = newSkuNames[offset:endIndex]
				}
			}
		}
	}
	dao.Commit(db)
	return skuNamesInfo, err
}

func GetStoresSkusSaleInfo(ctx *jxcontext.Context, storeIDs []int, skuIDs []int, fromTime, toTime time.Time, fromCount, toCount int) (saleInfoList []*SkuSaleInfo, err error) {
	globals.SugarLogger.Debugf("GetStoresSkusSaleInfo storeIDs:%v, fromTime:%v, toTime:%v, fromCount:%d, toCount:%d", storeIDs, fromTime, toTime, fromCount, toCount)

	db := dao.GetDB()
	sql := `
	SELECT IF(t2.jx_store_id <> 0, jx_store_id, store_id) store_id, t1.sku_id, COUNT(*) times, SUM(count) count
	FROM order_sku t1
	JOIN goods_order t2 ON t1.vendor_order_id = t2.vendor_order_id AND t1.vendor_id = t2.vendor_id AND t2.status IN (?, ?)
	WHERE t1.order_created_at >= ? AND t1.order_created_at <= ?
	AND IF(t2.jx_store_id <> 0, jx_store_id, store_id) IN (` + dao.GenQuestionMarks(len(storeIDs)) + `)
	`
	if jxutils.IsTimeEmpty(toTime) {
		toTime = time.Now()
	}
	sqlParams := []interface{}{
		model.OrderStatusDelivered,
		model.OrderStatusFinished,
		fromTime,
		toTime,
		storeIDs,
	}
	if len(skuIDs) > 0 {
		sql += `
		AND IF(t1.jx_sku_id <> 0, t1.jx_sku_id, t1.sku_id) IN (` + dao.GenQuestionMarks(len(skuIDs)) + `)`
		sqlParams = append(sqlParams, skuIDs)
	}
	sql += `
	GROUP BY 1,2
	HAVING count >= ? AND  count <= ?
	`
	sqlParams = append(sqlParams, fromCount, toCount)
	// fmt.Println(sql)
	// fmt.Println(utils.Format4Output(sqlParams, false))
	if err = dao.GetRows(db, &saleInfoList, sql, sqlParams...); err == nil {
		// globals.SugarLogger.Debug(utils.Format4Output(saleInfoList, false))
		return saleInfoList, nil
	}
	return nil, err
}

func UpdateStoreSku(ctx *jxcontext.Context, storeID int, skuBindInfo *StoreSkuBindInfo) (num int64, err error) {
	return UpdateStoreSkus(ctx, storeID, []*StoreSkuBindInfo{skuBindInfo})
}

func UpdateStoreSkus(ctx *jxcontext.Context, storeID int, skuBindInfos []*StoreSkuBindInfo) (num int64, err error) {
	skuIDs, err := updateStoresSkusWithoutSync(ctx, []int{storeID}, skuBindInfos)
	num = int64(len(skuIDs))
	if err == nil && num > 0 {
		db := dao.GetDB()
		_, err = CurVendorSync.SyncStoresSkus(ctx, db, nil, []int{storeID}, skuIDs, false, false)
		return int64(len(skuIDs)), err
	}
	return 0, err
}

func UpdateStoresSkus(ctx *jxcontext.Context, storeIDs []int, skuBindInfos []*StoreSkuBindInfo) (num int64, err error) {
	skuIDs, err := updateStoresSkusWithoutSync(ctx, storeIDs, skuBindInfos)
	num = int64(len(skuIDs))
	if num > 0 {
		db := dao.GetDB()
		_, err = CurVendorSync.SyncStoresSkus(ctx, db, nil, storeIDs, skuIDs, false, false)
	}
	return num, err
}

func checkStoresSkusSaleCity(ctx *jxcontext.Context, db *dao.DaoDB, storeIDs []int, skuBindInfos []*StoreSkuBindInfo) (err error) {
	sql := `
	SELECT t1.id store_id, t2.id name_id, t2.name
	FROM store t1
	JOIN sku_name t2 ON t2.is_global = 0
	LEFT JOIN sku_name_place_bind t3 ON t2.id = t3.name_id AND t1.city_code = t3.place_code
	WHERE t3.id IS NULL
	`
	sql += " AND t1.id IN (" + dao.GenQuestionMarks(len(storeIDs)) + ")"
	nameIDs := make([]int, 0)
	for _, v := range skuBindInfos {
		if v.IsFocus == 1 {
			nameIDs = append(nameIDs, v.NameID)
		} else {
			for _, v2 := range v.Skus {
				if v2.IsSale == 1 {
					nameIDs = append(nameIDs, v.NameID)
					break
				}
			}
		}
	}
	if len(nameIDs) == 0 {
		return nil
	}
	sql += " AND t2.id IN (" + dao.GenQuestionMarks(len(nameIDs)) + ")"
	var invalidList []*struct {
		StoreID int `orm:"column(store_id)"`
		NameID  int `orm:"column(name_id)"`
		Name    string
	}
	if err = dao.GetRows(db, &invalidList, sql, storeIDs, nameIDs); err == nil {
		if len(invalidList) > 0 {
			errMsg := ""
			for _, v := range invalidList {
				errMsg += fmt.Sprintf("门店:%d，Name:%d(%s)销售区域错误！\n", v.StoreID, v.NameID, v.Name)
			}
			err = errors.New(errMsg)
		}
	}
	return err
}

func updateStoresSkusWithoutSync(ctx *jxcontext.Context, storeIDs []int, skuBindInfos []*StoreSkuBindInfo) (needSyncSkus []int, err error) {
	globals.SugarLogger.Debugf("updateStoresSkusWithoutSync, storeIDs:%v, skuBindInfos:%s", storeIDs, utils.Format4Output(skuBindInfos, false))
	db := dao.GetDB()
	if err = checkStoresSkusSaleCity(ctx, db, storeIDs, skuBindInfos); err != nil {
		return nil, err
	}
	if storeIDs, skuBindInfos, err = filterStorePriceChange(ctx, storeIDs, skuBindInfos); err != nil {
		return nil, err
	}

	userName := ctx.GetUserName()
	needSyncIDMap := make(map[int]int)
	dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db)
			panic(r)
		}
	}()
	for _, storeID := range storeIDs {
		for _, skuBindInfo := range skuBindInfos {
			inSkuBinds := skuBindInfo.Skus
			var allBinds []*tStoreSkuBindAndSpec
			if err = dao.GetRows(db, &allBinds, `
		SELECT t2.*, t1.id real_sku_id, t1.spec_quality, t1.spec_unit, t3.price sku_name_price, t3.unit sku_name_unit
		FROM sku t1
		LEFT JOIN store_sku_bind t2 ON t2.sku_id = t1.id AND store_id = ? AND t2.deleted_at = ?
		JOIN sku_name t3 ON t1.name_id = t3.id AND t3.deleted_at = ?
		WHERE t1.name_id = ? AND t1.deleted_at = ?
	`, storeID, utils.DefaultTimeValue, utils.DefaultTimeValue, skuBindInfo.NameID, utils.DefaultTimeValue); err == nil {
				// globals.SugarLogger.Debug(utils.Format4Output(allBinds, false))
				inSkuBinsMap := make(map[int]*StoreSkuBindSkuInfo, len(inSkuBinds))
				for _, v := range inSkuBinds {
					inSkuBinsMap[v.SkuID] = v
				}
				unitPrice := 0
				if skuBindInfo.UnitPrice != 0 {
					unitPrice = skuBindInfo.UnitPrice
				} else {
					unitPrice = allBinds[0].UnitPrice
					if unitPrice == 0 {
						unitPrice = allBinds[0].SkuNamePrice
					}
				}
				for _, v := range allBinds {
					var num int64
					inSkuBind := inSkuBinsMap[v.RealSkuID]
					// globals.SugarLogger.Debug(utils.Format4Output(inSkuBind, false))
					var skuBind *model.StoreSkuBind
					if v.ID == 0 {
						if skuBindInfo.IsFocus == 1 {
							skuBind = &model.StoreSkuBind{
								StoreID:    storeID,
								SkuID:      v.RealSkuID,
								SubStoreID: skuBindInfo.SubStoreID, // todo 这个应该从用户信息中自动获得
								UnitPrice:  unitPrice,
								Price:      jxutils.CaculateSkuPrice(unitPrice, v.SpecQuality, v.SpecUnit, v.SkuNameUnit),
								Status:     model.StoreSkuBindStatusDontSale, // 缺省不可售？
							}
							if tmpStatus := getSkuSaleStatus(inSkuBind, skuBindInfo); tmpStatus != model.StoreSkuBindStatusNA {
								skuBind.Status = tmpStatus
							}
							setStoreSkuBindStatus(skuBind, model.SyncFlagNewMask)
							dao.WrapAddIDCULDEntity(skuBind, userName)
							globals.SugarLogger.Debug(utils.Format4Output(skuBind, false))
							if err = dao.CreateEntity(db, skuBind); err != nil {
								dao.Rollback(db)
								return nil, err
							}
							num = 1
						}
					} else {
						skuBind = &v.StoreSkuBind

						if skuBindInfo.IsFocus == -1 {
							if num, err = dao.DeleteEntityLogically(db, skuBind, map[string]interface{}{
								model.FieldStatus:         model.StoreSkuBindStatusDeleted,
								model.FieldJdSyncStatus:   model.SyncFlagDeletedMask,
								model.FieldElmSyncStatus:  model.SyncFlagDeletedMask,
								model.FieldEbaiSyncStatus: model.SyncFlagDeletedMask,
							}, userName, nil); err != nil {
								dao.Rollback(db)
								return nil, err
							}
						} else {
							needUpdate := false
							if skuBindInfo.IsFocus == 1 {
								skuBind.Status = model.StoreSkuBindStatusDontSale // 缺省不可售？
								skuBind.DeletedAt = utils.DefaultTimeValue
								needUpdate = true
							}
							if tmpStatus := getSkuSaleStatus(inSkuBind, skuBindInfo); tmpStatus != model.StoreSkuBindStatusNA {
								skuBind.Status = tmpStatus
								setStoreSkuBindStatus(skuBind, model.SyncFlagSaleMask)
								needUpdate = true
							}
							if skuBindInfo.UnitPrice != 0 { // 这里是否需要加此条件限制
								skuBind.UnitPrice = unitPrice
								skuBind.Price = jxutils.CaculateSkuPrice(unitPrice, v.SpecQuality, v.SpecUnit, v.SkuNameUnit)
								setStoreSkuBindStatus(skuBind, model.SyncFlagPriceMask)
								needUpdate = true
							}
							if inSkuBind != nil && inSkuBind.EbaiID != 0 {
								skuBind.EbaiID = inSkuBind.EbaiID
								needUpdate = true
							}
							if inSkuBind != nil && inSkuBind.ElmID != 0 {
								skuBind.ElmID = inSkuBind.ElmID
								needUpdate = true
							}
							if needUpdate {
								setStoreSkuBindStatus(skuBind, model.SyncFlagModifiedMask)
								dao.WrapUpdateULEntity(skuBind, userName)
								if num, err = dao.UpdateEntity(db, skuBind); err != nil {
									dao.Rollback(db)
									return nil, err
								}
							}
						}
					}
					if skuBind != nil && num == 1 {
						needSyncIDMap[skuBind.SkuID] = 1
					}
				}
			} else {
				dao.Rollback(db)
				return nil, err
			}
		}
	}
	dao.Commit(db)
	skuIDs := jxutils.IntMap2List(needSyncIDMap)
	return skuIDs, err
}

func getSkuSaleStatus(inSkuBind *StoreSkuBindSkuInfo, skuBindInfo *StoreSkuBindInfo) int {
	tempSale := 0
	if inSkuBind != nil {
		tempSale = inSkuBind.IsSale
	} else {
		tempSale = skuBindInfo.IsSale
	}
	if tempSale == -1 {
		return model.StoreSkuBindStatusDontSale
	} else if tempSale == 1 {
		return model.StoreSkuBindStatusNormal
	}
	return model.StoreSkuBindStatusNA
}

func updateStoreSkusSaleWithoutSync(ctx *jxcontext.Context, storeID int, skuBindSkuInfos []*StoreSkuBindSkuInfo, userName string) (needSyncSkus []int, err error) {
	var num int64
	db := dao.GetDB()
	needSyncIDMap := make(map[int]int)
	dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db)
			panic(r)
		}
	}()
	for _, v := range skuBindSkuInfos {
		if v.IsSale != 0 {
			skuBind := &model.StoreSkuBind{}
			if v.IsSale == 1 {
				skuBind.Status = model.StoreSkuBindStatusNormal
			} else {
				skuBind.Status = model.StoreSkuBindStatusDontSale
			}
			if num, err = dao.UpdateEntityLogically(db, skuBind, map[string]interface{}{
				model.FieldStatus:       skuBind.Status,
				model.FieldJdSyncStatus: model.SyncFlagSaleMask | model.SyncFlagModifiedMask,
			}, userName, map[string]interface{}{
				model.FieldStoreID: storeID,
				model.FieldSkuID:   v.SkuID,
			}); err != nil {
				dao.Rollback(db)
				return nil, err
			}
			if num == 1 {
				needSyncIDMap[v.SkuID] = 1
			}
		}
	}
	dao.Commit(db)
	needSyncSkus = jxutils.IntMap2List(needSyncIDMap)
	return needSyncSkus, err
}

func UpdateStoresSkusSale(ctx *jxcontext.Context, storeIDs []int, skuBindSkuInfos []*StoreSkuBindSkuInfo, userName string) (num int64, err error) {
	for _, storeID := range storeIDs {
		skuIDs, err2 := updateStoreSkusSaleWithoutSync(ctx, storeID, skuBindSkuInfos, userName)
		if err = err2; err != nil {
			return 0, err
		}
		num += int64(len(skuIDs))
	}
	skuIDs := make([]int, 0)
	for _, v := range skuBindSkuInfos {
		skuIDs = append(skuIDs, v.SkuID)
	}
	db := dao.GetDB()
	_, err = CurVendorSync.SyncStoresSkus(ctx, db, nil, storeIDs, skuIDs, false, false)
	return num, err
}

func CopyStoreSkus(ctx *jxcontext.Context, fromStoreID, toStoreID int, copyMode string, params map[string]interface{}, userName string) (num int64, err error) {
	if copyMode != CopyStoreSkuModeFresh && copyMode != CopyStoreSkuModeUpdate {
		return 0, fmt.Errorf("不支持的拷贝模式：%s", copyMode)
	}

	db := dao.GetDB()
	if err = checkStoreExisting(db, fromStoreID); err != nil {
		return 0, err
	}
	if err = checkStoreExisting(db, toStoreID); err != nil {
		return 0, err
	}

	sqlCatAndSku := ""
	sqlCatAndSkuParams := make([]interface{}, 0)
	if params["categoryIDs"] != nil {
		var cats []int
		if err = utils.UnmarshalUseNumber([]byte(params["categoryIDs"].(string)), &cats); err != nil {
			return 0, err
		}
		if len(cats) > 0 {
			sqlCatAndSku += " AND (t3.category_id IN (" + dao.GenQuestionMarks(len(cats)) + ") OR t4.parent_id IN (" + dao.GenQuestionMarks(len(cats)) + "))"
			sqlCatAndSkuParams = append(sqlCatAndSkuParams, cats, cats)
		}
	}
	if params["skuIDs"] != nil {
		var skus []int
		if err = utils.UnmarshalUseNumber([]byte(params["skuIDs"].(string)), &skus); err != nil {
			return 0, err
		}
		if len(skus) > 0 {
			sqlCatAndSku += " AND t1.sku_id IN (" + dao.GenQuestionMarks(len(skus)) + ")"
			sqlCatAndSkuParams = append(sqlCatAndSkuParams, skus)
		}
	}
	pricePercentage := 100
	if params["pricePercentage"] != nil {
		pricePercentage = params["pricePercentage"].(int)
	}

	now := time.Now()
	if fromStoreID == toStoreID {
		// return 0, fmt.Errorf("源门店：%d与目标门店：%d相同", fromStoreID, toStoreID)
		sql := `
		UPDATE store_sku_bind t1
		JOIN sku t2 ON t1.sku_id = t2.id AND t2.deleted_at = ?
		JOIN sku_name t3 ON t2.name_id = t3.id AND t2.deleted_at = ?
		JOIN sku_category t4 ON t3.category_id = t4.id AND t2.deleted_at = ?
			SET t1.last_operator = ?,
			t1.updated_at = ?,
			t1.price = t1.price * ? / 100,
			t1.unit_price = t1.unit_price * ? / 100,
			t1.jd_sync_status = ?,
			t1.elm_sync_status = ?,
			t1.ebai_sync_status = ?
		WHERE t1.store_id = ? AND t1.deleted_at = ?
		`
		sqlParams := []interface{}{
			utils.DefaultTimeValue,
			utils.DefaultTimeValue,
			utils.DefaultTimeValue,
			userName,
			now,
			pricePercentage,
			pricePercentage,
			model.SyncFlagNewMask,
			model.SyncFlagNewMask,
			model.SyncFlagNewMask,
			toStoreID,
			utils.DefaultTimeValue,
		}
		sql += sqlCatAndSku
		sqlParams = append(sqlParams, sqlCatAndSkuParams)
		num, err = dao.ExecuteSQL(db, sql, sqlParams)
		return num, err
	}
	dao.Begin(db)
	defer func() {
		dao.Rollback(db)
		if r := recover(); r != nil {
			panic(r)
		}
	}()
	if copyMode == CopyStoreSkuModeFresh || copyMode == CopyStoreSkuModeUpdate {
		sqlDelete := `
		UPDATE store_sku_bind t1
		JOIN sku t2 ON t1.sku_id = t2.id AND t2.deleted_at = ?
		JOIN sku_name t3 ON t2.name_id = t3.id AND t2.deleted_at = ?
		JOIN sku_category t4 ON t3.category_id = t4.id AND t2.deleted_at = ?
		SET t1.deleted_at = ?,
		t1.updated_at = ?,
		t1.last_operator = ?,
		t1.status = ?,
		t1.jd_sync_status = IF(t1.jd_sync_status = ?, 0, ?),
		t1.elm_sync_status = IF(t1.elm_sync_status = ?, 0, ?),
		t1.ebai_sync_status = IF(t1.ebai_sync_status = ?, 0, ?)
		WHERE t1.store_id = ? AND t1.deleted_at = ?
		`
		sqlDeleteParams := []interface{}{
			utils.DefaultTimeValue,
			utils.DefaultTimeValue,
			utils.DefaultTimeValue,
			now,
			now,
			userName,
			model.StoreSkuBindStatusDeleted,
			model.SyncFlagNewMask,
			model.SyncFlagDeletedMask,
			model.SyncFlagNewMask,
			model.SyncFlagDeletedMask,
			model.SyncFlagNewMask,
			model.SyncFlagDeletedMask,
			toStoreID,
			utils.DefaultTimeValue,
		}
		if copyMode == CopyStoreSkuModeUpdate {
			sqlDelete += sqlCatAndSku
			sqlDeleteParams = append(sqlDeleteParams, sqlCatAndSkuParams)
		}
		// globals.SugarLogger.Debug(sqlDelete)
		if _, err = dao.ExecuteSQL(db, sqlDelete, sqlDeleteParams); err != nil {
			return 0, err
		}
	}
	sql := `
	UPDATE store_sku_bind t1
	JOIN store_sku_bind t0 ON t0.store_id = ? AND t0.sku_id = t1.sku_id AND t0.deleted_at = ?
	JOIN sku t2 ON t1.sku_id = t2.id AND t2.deleted_at = ?
	JOIN sku_name t3 ON t2.name_id = t3.id AND t3.deleted_at = ?
	JOIN sku_category t4 ON t3.category_id = t4.id AND t4.deleted_at = ?
	SET t1.last_operator = ?,
		t1.updated_at = ?,
		t1.deleted_at = ?,
		t1.sub_store_id = 0,
		t1.price = t0.price * ? / 100,
		t1.unit_price = t0.unit_price * ? / 100,
		t1.status = t0.status,
		t1.jd_sync_status = ?,
		t1.elm_sync_status = ?,
		t1.ebai_sync_status = ?
	WHERE t1.store_id = ? AND (t1.deleted_at = ? OR t1.deleted_at = ?)
	`
	sqlParams := []interface{}{
		fromStoreID,
		utils.DefaultTimeValue,
		utils.DefaultTimeValue,
		utils.DefaultTimeValue,
		utils.DefaultTimeValue,
		userName,
		now,
		utils.DefaultTimeValue,
		pricePercentage,
		pricePercentage,
		model.SyncFlagNewMask,
		model.SyncFlagNewMask,
		model.SyncFlagNewMask,
		toStoreID,
		utils.DefaultTimeValue,
		now,
	}
	// todo 这里以上一步的删除时间作为一个判断条件，是有冲突的可能的
	sql += sqlCatAndSku
	sqlParams = append(sqlParams, sqlCatAndSkuParams)
	globals.SugarLogger.Debug(sql)
	num, err = dao.ExecuteSQL(db, sql, sqlParams)
	globals.SugarLogger.Debug(num)
	if err != nil {
		return 0, err
	}

	sql = `
	INSERT INTO store_sku_bind(created_at, updated_at, last_operator, deleted_at, store_id, sku_id, sub_store_id, price, unit_price, status, jd_sync_status, elm_sync_status, ebai_sync_status)
	SELECT ?, ?, ?, ?, ?,
	t1.sku_id, 0, t1.price * ? / 100, t1.unit_price * ? / 100, t1.status, ?, ?, ?
	FROM store_sku_bind t1
	JOIN sku t2 ON t1.sku_id = t2.id AND t2.deleted_at = ?
	JOIN sku_name t3 ON t2.name_id = t3.id AND t3.deleted_at = ?
	JOIN sku_category t4 ON t3.category_id = t4.id AND t4.deleted_at = ?
	LEFT JOIN store_sku_bind t0 ON t1.sku_id = t0.sku_id AND t0.store_id = ? AND t0.deleted_at = ?
	WHERE t1.store_id = ? AND t1.deleted_at = ?
	`
	sqlParams = []interface{}{
		now, now, userName, utils.DefaultTimeValue, toStoreID,
		pricePercentage,
		pricePercentage,
		model.SyncFlagNewMask,
		model.SyncFlagNewMask,
		model.SyncFlagNewMask,
		utils.DefaultTimeValue,
		utils.DefaultTimeValue,
		utils.DefaultTimeValue,
		toStoreID,
		utils.DefaultTimeValue,
		fromStoreID,
		utils.DefaultTimeValue,
	}
	sql += sqlCatAndSku + " AND t0.id IS NULL"
	sqlParams = append(sqlParams, sqlCatAndSkuParams)
	num, err = dao.ExecuteSQL(db, sql, sqlParams)
	if err != nil {
		return 0, err
	}
	dao.Commit(db)
	return num, err
}

func shouldPendingStorePriceChange(ctx *jxcontext.Context, storeID int, skuBindInfo *StoreSkuBindInfo) bool {
	return globals.EnablePendingChange && ctx.GetLoginType() == weixin.LoginType
}

func filterStorePriceChange(ctx *jxcontext.Context, storeIDs []int, skuBindInfos []*StoreSkuBindInfo) (filteredStoreIDs []int, filteredSkuBindInfos []*StoreSkuBindInfo, err error) {
	globals.SugarLogger.Debug("filterStorePriceChange")
	if globals.EnablePendingChange {
		db := dao.GetDB()
		dao.Begin(db)
		defer dao.Rollback(db)
		for _, storeID := range storeIDs {
			for _, skuBindInfo := range skuBindInfos {
				shouldPending := shouldPendingStorePriceChange(ctx, storeID, skuBindInfo)
				if shouldPending {
					changeReq := &model.StoreOpRequest{
						Type:      model.RequestTypeChangePrice,
						StoreID:   storeID,
						ItemID:    skuBindInfo.NameID,
						Status:    model.RequestStatusNew,
						UserID:    ctx.GetUserName(),
						IntParam1: skuBindInfo.UnitPrice,
						IntParam2: skuBindInfo.IsSale,
					}
					if skuBindInfo.IsFocus == 1 {
						changeReq.Type = model.RequestTypeFocusSkuName
					}
					if len(skuBindInfo.Skus) > 0 {
						changeReq.JsonParam = string(utils.MustMarshal(skuBindInfo.Skus))
					}

					dao.WrapAddIDCULDEntity(changeReq, ctx.GetUserName())
					if err = dao.CreateOrUpdate(db, changeReq); err != nil {
						return nil, nil, err
					}

					// 去除价格相关的部分
					if skuBindInfo.IsFocus == 1 {
						skuBindInfo.IsFocus = 0
					}
					skuBindInfo.UnitPrice = 0
				}
			}
		}
		dao.Commit(db)
	}
	return storeIDs, skuBindInfos, nil
}

func AcceptStoreOpRequests(ctx *jxcontext.Context, reqIDs []int) (err error) {
	if globals.EnablePendingChange {
		if len(reqIDs) > 0 {
			subErrors := make(map[int]error)
			db := dao.GetDB()
			for _, reqID := range reqIDs {
				op := &model.StoreOpRequest{}
				op.ID = reqID
				if err2 := dao.GetEntity(db, op); err2 != nil {
					subErrors[reqID] = err2
				} else {
					if op.Status == model.RequestStatusNew {
						skuBindInfo := &StoreSkuBindInfo{
							NameID:    op.ItemID,
							UnitPrice: op.IntParam1,
							IsSale:    op.IntParam2,
						}
						if op.Type == model.RequestTypeFocusSkuName {
							skuBindInfo.IsFocus = 1
						}
						if op.JsonParam != "" {
							if err2 = utils.UnmarshalUseNumber([]byte(op.JsonParam), &skuBindInfo.Skus); err2 != nil {
								subErrors[reqID] = err2
							}
						}
						if err2 == nil {
							_, err2 := UpdateStoresSkus(ctx, []int{op.StoreID}, []*StoreSkuBindInfo{skuBindInfo})
							isLocalSucess := true
							if err2 != nil {
								subErrors[reqID] = err2
								if !isSyncError(err2) {
									isLocalSucess = false
								}
							}
							if isLocalSucess {
								if err2 := changeStoreOpStatus(ctx, []int{reqID}, model.RequestStatusAccepted, ""); err2 != nil {
									subErrors[reqID] = err2
								}
							}
						}
					}
				}
			}
			if len(subErrors) > 0 {
				errMsg := ""
				for k, v := range subErrors {
					errMsg += fmt.Sprintf("req:%d, error:%s\n", k, v.Error())
				}
				err = errors.New(errMsg)
			}
		}
	}
	return err
}

func RejectStoreOpRequests(ctx *jxcontext.Context, reqIDs []int, rejectReason string) (err error) {
	return changeStoreOpStatus(ctx, reqIDs, model.RequestStatusRejected, rejectReason)
}

// 当前些函数只针对type为： RequestTypeChangePrice与RequestTypeFocusSkuName的查询才有效
func GetStoreOpRequests(ctx *jxcontext.Context, fromTime, toTime time.Time, keyword string, params map[string]interface{}, offset, pageSize int) (requestList []*StoreOpRequestInfo, err error) {
	if globals.EnablePendingChange {
		sql := `
	SELECT t1.id, t1.created_at, t1.updated_at, t1.last_operator, t1.deleted_at,
	t1.type, t1.store_id, t1.item_id, t1.status, t1.user_id, t1.int_param1, t1.int_param2,
	t2.name store_name, t3.prefix sku_name_prefix, t3.name sku_name_name, AVG(t5.unit_price) unit_price
	FROM store_op_request t1
	JOIN store t2 ON t1.store_id = t2.id
	JOIN sku_name t3 ON t1.item_id = t3.id
	JOIN sku t4 ON t3.id = t4.name_id
	LEFT JOIN store_sku_bind t5 ON t1.store_id = t5.store_id AND t4.id = t5.sku_id AND t5.deleted_at = ?
	WHERE t1.created_at >= ? AND t1.created_at <= ?
	`
		sqlParams := []interface{}{
			utils.DefaultTimeValue,
			fromTime,
			toTime,
		}
		if keyword != "" {
			keywordLike := "%" + keyword + "%"
			sql += " AND ( t2.name LIKE ? OR t3.name LIKE ?"
			sqlParams = append(sqlParams, keywordLike, keywordLike)
			if keywordInt64, err2 := strconv.ParseInt(keyword, 10, 64); err2 == nil {
				sql += " OR t1.store_id = ? OR t1.item_id = ?"
				sqlParams = append(sqlParams, keywordInt64, keywordInt64)
			}
			sql += ")"
		}
		if params["storeIDs"] != nil {
			var storeIDs []int
			if err = utils.UnmarshalUseNumber([]byte(params["storeIDs"].(string)), &storeIDs); err != nil {
				return nil, err
			}
			if len(storeIDs) > 0 {
				sql += " AND t1.store_id IN (" + dao.GenQuestionMarks(len(storeIDs)) + ")"
				sqlParams = append(sqlParams, storeIDs)
			}
		}
		if params["types"] != nil {
			var typeList []int
			if err = utils.UnmarshalUseNumber([]byte(params["types"].(string)), &typeList); err != nil {
				return nil, err
			}
			if len(typeList) > 0 {
				sql += " AND t1.type IN (" + dao.GenQuestionMarks(len(typeList)) + ")"
				sqlParams = append(sqlParams, typeList)
			}
		}
		if params["statuss"] != nil {
			var statusList []int
			if err = utils.UnmarshalUseNumber([]byte(params["statuss"].(string)), &statusList); err != nil {
				return nil, err
			}
			if len(statusList) > 0 {
				sql += " AND t1.status IN (" + dao.GenQuestionMarks(len(statusList)) + ")"
				sqlParams = append(sqlParams, statusList)
			}
		}
		sql += `
	GROUP BY 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
	LIMIT ? OFFSET ?`
		pageSize = jxutils.FormalizePageSize(pageSize)
		sqlOffset := offset
		sqlPageSize := pageSize
		sqlParams = append(sqlParams, sqlPageSize, sqlOffset)
		db := dao.GetDB()
		// globals.SugarLogger.Debug(sql)
		// globals.SugarLogger.Debug(utils.Format4Output(sqlParams, false))
		if err = dao.GetRows(db, &requestList, sql, sqlParams...); err == nil {
			return requestList, nil
		}
	}
	return nil, err
}

func changeStoreOpStatus(ctx *jxcontext.Context, reqIDs []int, status int8, rejectReason string) (err error) {
	globals.SugarLogger.Debugf("changeStoreOpStatus, reqIDs:%v", reqIDs)
	if globals.EnablePendingChange {
		if len(reqIDs) > 0 {
			db := dao.GetDB()
			dao.Begin(db)
			defer dao.Rollback(db)
			for _, reqID := range reqIDs {
				op := &model.StoreOpRequest{}
				op.Remark = rejectReason
				op.Status = status
				dao.WrapUpdateULEntity(op, ctx.GetUserName())
				op.DeletedAt = time.Now()
				op.ID = reqID
				// globals.SugarLogger.Debug(utils.Format4Output(op, false))
				if _, err = dao.UpdateEntity(db, op, "Remark", "Status", "DeletedAt", "LastOperator", "UpdatedAt"); err != nil {
					return err
				}
			}
			dao.Commit(db)
		}
	}
	return err
}

func setStoreSkuBindStatus(skuBind *model.StoreSkuBind, status int8) {
	skuBind.JdSyncStatus |= status
	skuBind.ElmSyncStatus |= status
	skuBind.EbaiSyncStatus |= status
}

func checkStoreExisting(db *dao.DaoDB, storeID int) (err error) {
	store := &model.Store{}
	store.ID = storeID
	if err = dao.GetEntity(db, store); err != nil {
		if err == orm.ErrNoRows {
			return fmt.Errorf("门店：%d不存在", storeID)
		}
		return err
	}
	return nil
}