package ebaiapi

import (
	"fmt"
	"regexp"
	"strings"

	"git.rosy.net.cn/baseapi/utils"
)

const (
	SkuStatusOnline  = 1
	SkuStatusOffline = 0
)

const (
	UPCTypeStandard = 1
	UPCTypePrivate  = 0
)
const (
	MaxLeftNum = 99999
)

type CategoryInfo struct {
	CategoryID int64           `json:"category_id"`
	Name       string          `json:"name"`
	Rank       int             `json:"rank"` // 店内分类独有
	Children   []*CategoryInfo `json:"children"`
	Level      int             `json:"level"`
}

type PageDataInfo struct {
	Total int
	Page  int
	Pages int
	List  []map[string]interface{}
}

var (
	skuExistReg = regexp.MustCompile(`\s?,\s?sku_id:(\d+)`)
)

// category相关的函数，shop_custom_id可重

func (a *API) ShopCategoryCreate(shopID string, parentID int64, name string, rank int) (catID int64, err error) {
	result, err := a.AccessAPI("sku.shop.category.create", map[string]interface{}{
		KeyShopID:            shopID,
		"parent_category_id": parentID,
		"name":               name,
		"rank":               rank,
	})
	if err == nil {
		return utils.Str2Int64(utils.Interface2String(result.Data.(map[string]interface{})["category_id"])), nil
	}
	return 0, err
}

func (a *API) ShopCategoryGet(shopID string) (cats []*CategoryInfo, err error) {
	result, err := a.AccessAPI("sku.shop.category.get", utils.Params2Map(KeyShopID, shopID))
	if err == nil {
		if inMap, ok := result.Data.(map[string]interface{}); ok { // fuck it
			cats := interface2CatList(inMap["categorys"], 1)
			return cats, nil
		}
	}
	return nil, err
}

func (a *API) ShopCategoryUpdate(shopID string, categoryID int64, name string, rank int) (err error) {
	_, err = a.AccessAPI("sku.shop.category.update", map[string]interface{}{
		KeyShopID:     shopID,
		"category_id": categoryID,
		"name":        name,
		"rank":        rank,
	})
	if errWithCode, ok := err.(*utils.ErrorWithCode); ok {
		if errWithCode.Level() == 0 && errWithCode.IntCode() == 1 { //忽略同名错误
			err = nil
		}
	}
	return err
}

func (a *API) ShopCategoryDelete(shopID string, categoryID int64) (err error) {
	_, err = a.AccessAPI("sku.shop.category.delete", map[string]interface{}{
		KeyShopID:     shopID,
		"category_id": categoryID,
	})
	return err
}

func (a *API) SkuGetItemsByCategoryId(shopID string, categoryID int64) (skus []map[string]interface{}, err error) {
	result, err := a.AccessAPI("sku.getItemsByCategoryId", map[string]interface{}{
		KeyShopID:     shopID,
		"category_id": categoryID,
	})
	if err == nil {
		return utils.Slice2MapSlice(result.Data.([]interface{})), nil
	}
	return nil, err
}

func (a *API) SkuList(shopID string, params map[string]interface{}) (skuInfo *PageDataInfo, err error) {
	defParams := map[string]interface{}{
		KeyShopID: shopID,
	}
	result, err := a.AccessAPI("sku.list", utils.MergeMaps(params, defParams))
	if err == nil {
		data := result.Data.(map[string]interface{})
		return &PageDataInfo{
			Total: int(utils.MustInterface2Int64(data["total"])),
			Page:  int(utils.MustInterface2Int64(data["page"])),
			Pages: int(utils.MustInterface2Int64(data["pages"])),
			List:  utils.Slice2MapSlice(data["list"].([]interface{})),
		}, nil
	}
	return nil, err
}

func (a *API) SkuCreate(shopID string, customSkuID int, params map[string]interface{}) (skuID int64, err error) {
	defParams := map[string]interface{}{
		KeyShopID:      shopID,
		KeyCustomSkuID: customSkuID,
	}
	if params["upc"] == nil {
		defParams["upc_type"] = UPCTypePrivate
		defParams["upc"] = "upc-" + utils.Int2Str(customSkuID)
	}
	if params["brand_id"] == nil {
		defParams["brand_id"] = 0
	}
	if params["brand_name"] == nil {
		defParams["brand_name"] = "无" // 很狗血的是，你还必须填个无才行。。。
	}
	params = utils.MergeMaps(params, defParams)
	// baseapi.SugarLogger.Debugf(utils.Format4Output(params, false))
	result, err := a.AccessAPI("sku.create", params)
	if err == nil {
		return utils.Str2Int64(utils.Interface2String(result.Data.(map[string]interface{})[KeySkuID])), nil
	}
	return 0, err
}

func GetEbaiSkuIDFromError(err error) int64 {
	if err2, ok := err.(*utils.ErrorWithCode); ok && err2.IntCode() == 1 && strings.Index(err2.ErrMsg(), "shop sku exist") >= 0 {
		searchResult := skuExistReg.FindStringSubmatch(err2.ErrMsg())
		if searchResult != nil && len(searchResult[1]) > 0 {
			return utils.Str2Int64(searchResult[1])
		}
	}
	return 0
}

func (a *API) SkuUpdate(shopID string, ebaiSkuID int64, params map[string]interface{}) (skuID int64, err error) {
	defParams := map[string]interface{}{
		KeyShopID: shopID,
		KeySkuID:  ebaiSkuID,
	}
	result, err := a.AccessAPI("sku.update", utils.MergeMaps(params, defParams))
	if err == nil {
		return utils.Str2Int64(utils.Interface2String(result.Data.(map[string]interface{})[KeySkuID])), nil
	}
	return 0, err
}

func (a *API) SkuDelete(shopID, skuIDsStr string) (err error) {
	params := map[string]interface{}{
		KeyShopID: shopID,
		KeySkuID:  skuIDsStr,
	}
	_, err = a.AccessAPI("sku.delete", params)
	if err == nil {
		return nil
	}
	return err
}

func (a *API) SkuDeleteByCustomIDs(shopID, customSkuIDsStr string) (err error) {
	params := map[string]interface{}{
		KeyShopID:      shopID,
		KeyCustomSkuID: customSkuIDsStr,
	}
	_, err = a.AccessAPI("sku.delete", params)
	if err == nil {
		return nil
	}
	return err
}

func (a *API) SkuOnline(shopID, skuIDsStr string) (err error) {
	params := map[string]interface{}{
		KeyShopID: shopID,
		KeySkuID:  skuIDsStr,
	}
	_, err = a.AccessAPI("sku.online", params)
	if err == nil {
		return nil
	}
	return err
}

func (a *API) SkuOffline(shopID, skuIDsStr string) (err error) {
	params := map[string]interface{}{
		KeyShopID: shopID,
		KeySkuID:  skuIDsStr,
	}
	_, err = a.AccessAPI("sku.offline", params)
	if err == nil {
		return nil
	}
	return err
}

func (a *API) SkuShopCategoryMap(shopID string, skuID int64, categoryIDsStr string) (err error) {
	params := map[string]interface{}{
		KeyShopID:     shopID,
		KeySkuID:      skuID,
		"category_id": categoryIDsStr,
	}
	_, err = a.AccessAPI("sku.shop.category.map", params)
	if err == nil {
		return nil
	}
	return err
}

// 饿百的这个API有点怪，虽然有shopID参数，但返回的链接可以跨店使用
func (a *API) SkuUploadRTF(shopID, rtfDetail string) (rtfURL string, err error) {
	params := map[string]interface{}{
		KeyShopID:    shopID,
		"rtf_detail": rtfDetail,
	}
	result, err := a.AccessAPI("sku.uploadrtf", params)
	if err == nil {
		rtfURL = utils.Interface2String(result.Data.(map[string]interface{})["url"])
	}
	return rtfURL, err
}

func BuildRFTFromImgs(imgList ...string) string {
	imgList2 := make([]string, len(imgList))
	for index, img := range imgList {
		imgList2[index] = fmt.Sprintf(`<img align="absmiddle" src="%s"  alt="%s" />`, img, img)
	}
	return strings.Join(imgList2, "\n")
}

//
func interface2CatList(data interface{}, level int) (cats []*CategoryInfo) {
	maps, ok := data.([]interface{})
	if ok {
		cats = make([]*CategoryInfo, len(maps))
		for index, v := range maps {
			cats[index] = interface2Cat(v, level)
		}
	}
	return cats
}

func interface2Cat(data interface{}, level int) (cat *CategoryInfo) {
	catMap := data.(map[string]interface{})
	cat = &CategoryInfo{
		CategoryID: utils.MustInterface2Int64(catMap["category_id"]),
		Name:       utils.Interface2String(catMap["name"]),
		Rank:       int(utils.MustInterface2Int64(catMap["rank"])),
		Children:   interface2CatList(catMap["children"], level+1),
		Level:      level,
	}
	return cat
}