package jd

// 这里函数取得的信息，除了与自身实体相关的ID（比如PARENT ID），都已经转换成了本地ID了

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

const (
	DefBrandID      = 35247
	DefJdCategoryID = 20362
)

type tSkuInfoExt struct {
	model.SkuName
	JdID         int64  `orm:"column(jd_id)"`          // 商家类别
	JdCategoryID int    `orm:"column(jd_category_id)"` // 到家类别
	SkuCatID     int64  `orm:"column(sku_cat_id)"`     // 商家特殊类别
	Comment      string `orm:"size(255)" json:"comment"`
}

func (p *PurchaseHandler) CreateCategory(db *dao.DaoDB, cat *model.SkuCategory, userName string) (err error) {
	var jdPid int64
	if cat.ParentID != 0 {
		pCat := &model.SkuCategory{}
		pCat.ID = cat.ParentID
		if err = dao.GetEntity(db, pCat); err == nil {
			jdPid = pCat.JdID
		} else {
			return err
		}
	}
	if globals.EnableStoreWrite {
		result, err2 := api.JdAPI.AddShopCategory(jdPid, cat.Name, int(cat.Level), cat.Seq, userName)
		if err = err2; err == nil {
			if jdID := utils.Str2Int64WithDefault(result, 0); jdID != 0 {
				cat.JdID = jdID
			}
		}
	}
	return err
}

func (p *PurchaseHandler) ReadCategories() (cats []*model.SkuCategory, err error) {
	result, err := api.JdAPI.QueryCategoriesByOrgCode()
	if err == nil {
		cats = make([]*model.SkuCategory, len(result))
		for k, v := range result {
			cats[k] = &model.SkuCategory{
				ParentID: int(v.ParentId), // 这里是暂存，传递数据用，正确的值应该是本地的ID
				Name:     v.Name,
				Level:    int8(v.Level),
				Seq:      v.Sort,
				JdID:     v.Id,
			}
		}
		return cats, nil
	}
	return nil, err
}

func (p *PurchaseHandler) UpdateCategory(db *dao.DaoDB, cat *model.SkuCategory, userName string) error {
	if globals.EnableStoreWrite {
		return api.JdAPI.UpdateShopCategory(cat.JdID, cat.Name)
	}
	return nil
}

func (p *PurchaseHandler) DeleteCategory(db *dao.DaoDB, cat *model.SkuCategory, userName string) error {
	if globals.EnableStoreWrite {
		return api.JdAPI.DelShopCategory(cat.JdID)
	}
	return nil
}

func (p *PurchaseHandler) ReorderCategories(db *dao.DaoDB, parentCatID int, userName string) (err error) {
	var parentJDID int64
	if parentCatID != 0 {
		cat := &model.SkuCategory{}
		cat.ID = parentCatID
		if err = dao.GetEntity(db, cat); err != nil {
			return err
		}
		parentJDID = cat.JdID
	}
	var cats []*model.SkuCategory
	if err = dao.GetRows(db, &cats, "SELECT * FROM sku_category WHERE parent_id = ? ORDER BY seq", parentCatID); err == nil {
		jdCatIDs := make([]int64, len(cats))
		for k, v := range cats {
			jdCatIDs[k] = v.JdID
		}
		if globals.EnableStoreWrite {
			err = api.JdAPI.ChangeShopCategoryOrder(parentJDID, jdCatIDs)
		}
	}
	return err
}

func (p *PurchaseHandler) cuSku(db *dao.DaoDB, sku *model.Sku, handler func(skuExt *tSkuInfoExt, price int, skuName string, shopCategories []int64, addParams map[string]interface{}) (string, error)) (err error) {
	var skuInfoExt tSkuInfoExt
	err = dao.GetRow(nil, &skuInfoExt, `
	SELECT t2.*, t3.jd_id, t3.jd_category_id, t4.jd_id sku_cat_id
	FROM sku t1
	JOIN sku_name t2 ON t1.name_id = t2.id
	JOIN sku_category t3 ON t2.category_id = t3.id
	LEFT JOIN sku_category t4 ON t1.category_id = t4.id
	WHERE t1.id = ?
	`, sku.ID)
	if err == nil {
		shopCategories := []int64{skuInfoExt.JdID}
		if skuInfoExt.SkuCatID != 0 {
			shopCategories = append(shopCategories, skuInfoExt.SkuCatID)
		}
		if skuInfoExt.JdCategoryID == 0 {
			skuInfoExt.JdCategoryID = DefJdCategoryID
		}
		if skuInfoExt.BrandID == 0 {
			skuInfoExt.BrandID = DefBrandID
		}
		addParams := map[string]interface{}{}

		if skuInfoExt.IsGlobal == 0 { //如果不是全国可售，要查可售区域
			sellPlaces, err2 := dao.GetSellCities(db, skuInfoExt.ID, model.VendorIDJD)
			if err = err2; err == nil && len(sellPlaces) > 0 {
				sellCites := make([]int, len(sellPlaces))
				for k, v := range sellPlaces {
					sellCites[k] = v.JdCode
				}
				addParams["sellCities"] = sellCites
			}
		}
		if err == nil {
			skuName := jxutils.ComposeSkuName(skuInfoExt.Prefix, skuInfoExt.Name, sku.Comment, skuInfoExt.Unit, sku.SpecQuality, sku.SpecUnit, 0)
			skuPrice := jxutils.CaculateSkuPrice(skuInfoExt.Price, sku.SpecQuality, sku.SpecUnit, skuInfoExt.Unit)
			result, err2 := handler(&skuInfoExt, skuPrice, skuName, shopCategories, addParams)
			if err = err2; err == nil {
				if jdID := utils.Str2Int64WithDefault(result, 0); jdID != 0 {
					sku.JdID = jdID
				}
			}
		}
	}
	return err
}

func (p *PurchaseHandler) CreateSku(db *dao.DaoDB, sku *model.Sku, userName string) (err error) {
	return p.cuSku(db, sku, func(skuExt *tSkuInfoExt, price int, skuName string, shopCategories []int64, addParams map[string]interface{}) (vendorSkuID string, err error) {
		if globals.EnableStoreWrite {
			vendorSkuID, err = api.JdAPI.AddSku(utils.Int2Str(sku.ID), skuExt.JdCategoryID, shopCategories, skuExt.BrandID, skuName, price, jxutils.IntWeight2Float(sku.Weight), []string{skuExt.Img}, 1, true, addParams)
		}
		return vendorSkuID, err
	})
}

func (p *PurchaseHandler) ReadSku(vendorSkuID string) (skuNameExt *model.SkuNameExt, err error) {
	jdSkuID := utils.Str2Int64(vendorSkuID)
	result, _, err := api.JdAPI.QuerySkuInfos("", jdSkuID, 0, 0, false)
	if err == nil {
		if len(result) == 1 {
			skuNameExt = &model.SkuNameExt{}
			if picInfo, err2 := api.JdAPI.QueryListBySkuIds([]int64{jdSkuID}, nil); err2 == nil && len(picInfo) > 0 {
				skuNameExt.Img = utils.Interface2String(picInfo[0]["sourceImgUrl"])
			}
			mapData := result[0]
			skuNameStr := utils.Interface2String(mapData["skuName"])
			prefix, name, comment, specUnit, unit, specQuality := jxutils.SplitSkuName(skuNameStr)
			if name == "" {
				name = skuNameStr
				unit = "份"
				specUnit = "g"
			}
			skuNameExt.Prefix = prefix
			skuNameExt.Name = name
			skuNameExt.Unit = unit
			skuNameExt.Price = int(utils.MustInterface2Int64(mapData["skuPrice"]))
			skuNameExt.Skus = []*model.Sku{
				&model.Sku{
					SpecQuality: specQuality,
					SpecUnit:    specUnit,
					Weight:      jxutils.FloatWeight2Int(float32(utils.MustInterface2Float64(mapData["weight"]))),
					JdID:        utils.MustInterface2Int64(mapData["skuId"]),
					Status:      jdStatus2jxStatus(int(utils.MustInterface2Int64(mapData["fixedStatus"]))),
					Comment:     comment,
				},
			}
			skuNameExt.Skus[0].ID = int(utils.Str2Int64(utils.Interface2String(mapData["outSkuId"])))

			db := dao.GetDB()
			shopCategories := utils.Interface2Int64List(mapData["shopCategories"])
			if len(shopCategories) > 0 {
				skuCat := &model.SkuCategory{}
				skuCat.JdID = shopCategories[0]
				if dao.GetEntity(db, skuCat, "JdID") == nil {
					skuNameExt.CategoryID = skuCat.ID
				}
			}
			sellCities := utils.Interface2Int64List(mapData["sellCities"])
			for _, v := range sellCities {
				if v == 0 {
					skuNameExt.IsGlobal = 1
				}
			}
			if len(sellCities) == 0 || skuNameExt.IsGlobal == 1 {
				skuNameExt.IsGlobal = 1
			} else {
				var places []*model.Place
				if err = dao.GetRows(db, &places, "SELECT * FROM place WHERE jd_code IN ("+dao.GenQuestionMarks(len(sellCities))+") AND level = 2", sellCities); err == nil {
					skuNameExt.Places = make([]int, len(places))
					for k, v := range places {
						skuNameExt.Places[k] = v.Code
					}
				}
			}
		} else {
			err = partner.ErrCanNotFindItem
		}
	}
	return skuNameExt, err
}

func (p *PurchaseHandler) UpdateSku(db *dao.DaoDB, sku *model.Sku, userName string) (err error) {
	return p.cuSku(db, sku, func(skuExt *tSkuInfoExt, price int, skuName string, shopCategories []int64, addParams map[string]interface{}) (vendorSkuID string, err error) {
		params := utils.MergeMaps(addParams)
		params["categoryId"] = skuExt.JdCategoryID
		params["shopCategories"] = shopCategories
		params["brandId"] = skuExt.BrandID
		params["skuName"] = skuName
		params["weight"] = jxutils.IntWeight2Float(sku.Weight)
		params["images"] = []string{skuExt.Img}
		params["fixedStatus"] = jxStatus2jdStatus(sku.Status)
		if globals.EnableStoreWrite {
			vendorSkuID, err = api.JdAPI.UpdateSku(utils.Int2Str(sku.ID), params)
		}
		return vendorSkuID, err
	})
}

func (p *PurchaseHandler) DeleteSku(db *dao.DaoDB, sku *model.Sku, userName string) (err error) {
	params := map[string]interface{}{
		"fixedStatus": 4,
	}
	if globals.EnableStoreWrite {
		_, err = api.JdAPI.UpdateSku(utils.Int2Str(sku.ID), params)
	}
	return err
}

func (p *PurchaseHandler) RefreshAllSkusID(ctx *jxcontext.Context, parentTask tasksch.ITask, isAsync bool) (hint string, err error) {
	globals.SugarLogger.Debugf("jd RefreshAllSkusID")

	db := dao.GetDB()
	var skuPairs []*jdapi.SkuIDPair
	const stepCount = 2

	rootTask := tasksch.NewSeqTask("jd RefreshAllSkusID", ctx.GetUserName(), func(rootTask *tasksch.SeqTask, step int, params ...interface{}) (result interface{}, err error) {
		switch step {
		case 0:
			err = dao.GetRows(db, &skuPairs, `
			SELECT t1.id out_sku_id, t1.jd_id sku_id
			FROM sku t1
			WHERE t1.deleted_at = ?
			`, utils.DefaultTimeValue)
		default:
			taskName := "RefreshAllSkusID update id"
			if step != stepCount-1 {
				taskName = "RefreshAllSkusID update uuid"
			}
			task1 := tasksch.NewParallelTask(taskName, tasksch.NewParallelConfig().SetIsContinueWhenError(true).SetBatchSize(jdapi.MaxBatchSize4BatchUpdateOutSkuId), ctx.GetUserName(), func(t *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
				skuPairs := make([]*jdapi.SkuIDPair, len(batchItemList))
				for k, v := range batchItemList {
					pair := v.(*jdapi.SkuIDPair)
					skuPairs[k] = &jdapi.SkuIDPair{
						SkuId:    pair.SkuId,
						OutSkuId: pair.OutSkuId,
					}
					if step != stepCount-1 {
						skuPairs[k].OutSkuId = utils.GetUUID()
					}
				}
				globals.SugarLogger.Debug(utils.Format4Output(skuPairs, false))
				if true { //globals.EnableStoreWrite {
					_, err = api.JdAPI.BatchUpdateOutSkuId(skuPairs)
				}
				return nil, err
			}, skuPairs)
			rootTask.AddChild(task1).Run()
			_, err = task1.GetResult(0)
		}
		return nil, err
	}, stepCount)
	ctx.SetTaskOrAddChild(rootTask, parentTask)
	rootTask.Run()
	if !isAsync {
		_, err = rootTask.GetResult(0)
	}
	return rootTask.ID, err
}

func jdStatus2jxStatus(jdStatus int) (jxStatus int) {
	switch jdStatus {
	case 1:
		jxStatus = model.SkuStatusNormal
	case 2:
		jxStatus = model.SkuStatusDontSale
	case 4:
		jxStatus = model.SkuStatusDeleted
	}
	return jxStatus
}

func jxStatus2jdStatus(jxStatus int) (jdStatus int) {
	switch jxStatus {
	case model.SkuStatusNormal:
		jdStatus = 1
	case model.SkuStatusDontSale:
		jdStatus = 2
	case model.SkuStatusDeleted:
		jdStatus = 4
	}
	return jdStatus
}