package ebaiapi

import (
	"fmt"
	"strings"

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

const (
	ActivityTypeDirectDown   = 2 // 商品直降
	ActivityTypeFullDiscount = 8 // 品类满减

	ActivityPFBaidu = 1
	ActivityPFELM   = 2
	ActivityPFAll   = 4

	ActivityConflictShare    = 0
	ActivityConfilictExclude = 1

	ActivityShowStatusEnabled  = 2
	ActivityShowStatusDisabled = 4
)

type ActivityRule struct {
	Accords int `json:"accords"` // 订单达到的金额，正整数，单位元。
	Sale    int `json:"sale"`    // 每单减价额度，正整数，单位元。
}

type ActivityInfo struct {
	ActivityID         int64           `json:"-"`
	ActivityName       string          `json:"activity_name"`
	ActivityType       int             `json:"activity_type"`
	StartTime          int64           `json:"start_time"` // 活动开始时间，时间戳，需大于当前时间。
	EndTime            int64           `json:"end_time"`
	OpenTime           string          `json:"open_time"` // "22:47"
	CloseTime          string          `json:"close_time"`
	WeekDay            string          `json:"weekday"` // 活动开始时间段内，每周具体星期几支持，默认活动生效时间段内全周支持。0,1,2,3,4,5,6代表周日到周六。
	ActivityPlatform   int             `json:"activity_platform"`
	IsConflictActivity int             `json:"is_conflict_activity"`
	DayLimit           int             `json:"day_limit"`   // 每日限购X单，1-1000整数。
	OrderLimit         int             `json:"order_limit"` // 每单限购商品数量。直降用到，满减没用到。1-1000整数。
	ActivityDesc       string          `json:"activity_desc"`
	ShowCategory       string          `json:"show_category"`
	PromotionSkuDesc   string          `json:"promotion_sku_desc"` // 店铺页活动商品的分类名称，不超过8个字。
	Rule               []*ActivityRule `json:"rule"`

	BaiduShopID int64 `json:"-"`
	ShowStatus  int   `json:"-"`
}

type ActivitySkuInfo struct {
	SkuID string `json:"sku_id"`
	Stock int    `json:"stock"`

	PromotionPrice float32 `json:"special_price"`    // 直降用
	StoreUserLimit int     `json:"store_user_limit"` // 直降用
}

type ActivitySkuInfoEx struct {
	ActivitySkuInfo
	BaiduShopID   int64   `json:"baidu_shop_id"`
	UpcName       string  `json:"upc_name"`
	OriginalPrice float32 `json:"original_price"`
}

type ActivitySkuInfo4Update struct {
	ActivitySkuInfo
	BaiduShopID int64  `json:"baidu_shop_id"`
	ShopID      string `json:"shop_id"`
	CustomSkuID string `json:"custom_sku_id"`
}

type ActivitySkuListInfo struct {
	ActivityID   int64                `json:"activity_id"`
	ActivityType int                  `json:"activity_type"`
	ActivityName string               `json:"activity_name"`
	SkuList      []*ActivitySkuInfoEx `json:"sku_list"`
}

var (
	ignoreActivityInfo = ActivityInfo{}
)

func (a *API) ActivityCreate(shopID string, baiduShopID, supplierID int64, activity *ActivityInfo) (activityID int64, err error) {
	params := utils.Struct2MapWithIgnore(activity, map[string]interface{}{
		"open_time":            ignoreActivityInfo.OpenTime,
		"close_time":           ignoreActivityInfo.CloseTime,
		"is_conflict_activity": ignoreActivityInfo.IsConflictActivity,
		"order_limit":          ignoreActivityInfo.OrderLimit,
		"rule":                 ignoreActivityInfo.Rule,
	})
	result, err := a.AccessAPI("activity.create", utils.MergeMaps(params, a.genShopIDParams(shopID, baiduShopID, supplierID)))
	if err == nil {
		return utils.Str2Int64(utils.Interface2String(result.Data.(map[string]interface{})["activity_id"])), nil
	}
	return 0, err
}

func (a *API) ActivityUpdate(activityID int64, shopID string, baiduShopID, supplierID int64, activity *ActivityInfo) (newActivityID int64, err error) {
	params := utils.Struct2MapWithIgnore(activity, map[string]interface{}{
		"open_time":            ignoreActivityInfo.OpenTime,
		"close_time":           ignoreActivityInfo.CloseTime,
		"weekday":              ignoreActivityInfo.WeekDay,
		"day_limit":            ignoreActivityInfo.DayLimit,
		"order_limit":          ignoreActivityInfo.OrderLimit,
		"activity_desc":        ignoreActivityInfo.ActivityDesc,
		"show_category":        ignoreActivityInfo.ShowCategory,
		"promotion_sku_desc":   ignoreActivityInfo.PromotionSkuDesc,
		"is_conflict_activity": ignoreActivityInfo.IsConflictActivity,
		"rule":                 ignoreActivityInfo.Rule,
	})
	params[KeyActivityID] = activityID
	result, err := a.AccessAPI("activity.update", utils.MergeMaps(params, a.genShopIDParams(shopID, baiduShopID, supplierID)))
	if err == nil {
		return utils.Str2Int64(utils.Interface2String(result.Data.(map[string]interface{})["activity_id"])), nil
	}
	return 0, err
}

func (a *API) ActivityDisable(activityID int64, shopID string, baiduShopID, supplierID int64) (err error) {
	params := a.genShopIDParams(shopID, baiduShopID, supplierID)
	params[KeyActivityID] = activityID
	_, err = a.AccessAPI("activity.disable", params)
	return err
}

func (a *API) ActivityGet(activityID int64, shopID string, baiduShopID, supplierID int64) (activityInfo *ActivityInfo, err error) {
	params := a.genShopIDParams(shopID, baiduShopID, supplierID)
	params[KeyActivityID] = activityID
	result, err := a.AccessAPI("activity.get", params)
	if err == nil {
		dataMap := result.Data.(map[string]interface{})
		activityInfo = &ActivityInfo{
			ActivityID:         utils.Str2Int64(utils.Interface2String(dataMap["activity_id"])),
			ActivityName:       utils.Interface2String(dataMap["activity_name"]),
			ActivityType:       int(utils.Str2Int64(utils.Interface2String(dataMap["activity_type"]))),
			StartTime:          utils.Str2Int64(utils.Interface2String(dataMap["start_time"])),
			EndTime:            utils.Str2Int64(utils.Interface2String(dataMap["end_time"])),
			OpenTime:           utils.Interface2String(dataMap["open_time"]),
			CloseTime:          utils.Interface2String(dataMap["close_time"]),
			WeekDay:            utils.Interface2String(dataMap["weekday"]),
			ActivityPlatform:   int(utils.Str2Int64(utils.Interface2String(dataMap["activity_platform"]))),
			IsConflictActivity: int(utils.Str2Int64(utils.Interface2String(dataMap["is_conflict_activity"]))),
			DayLimit:           int(utils.Str2Int64(utils.Interface2String(dataMap["day_limit"]))),
			OrderLimit:         int(utils.Str2Int64(utils.Interface2String(dataMap["order_limit"]))),
			ActivityDesc:       utils.Interface2String(dataMap["activity_desc"]),
			ShowCategory:       utils.Interface2String(dataMap["show_category"]),
			PromotionSkuDesc:   utils.Interface2String(dataMap["promotion_sku_desc"]),

			BaiduShopID: utils.Str2Int64(utils.Interface2String(dataMap["baidu_shop_id"])),
			ShowStatus:  int(utils.Str2Int64(utils.Interface2String(dataMap["show_status"]))),
		}
		if rule, ok := dataMap["rule"].([]interface{}); ok {
			for _, v := range rule {
				vMap := v.(map[string]interface{})
				activityInfo.Rule = append(activityInfo.Rule, &ActivityRule{
					Accords: int(utils.MustInterface2Int64(vMap["accords"])),
					Sale:    int(utils.MustInterface2Int64(vMap["sale"])),
				})
			}
		}
		return activityInfo, nil
	}
	return nil, err
}

func (a *API) ActivitySkuAddBatch(activityID int64, shopID string, baiduShopID int64, activityType int, skuList []*ActivitySkuInfo, isSkuIDCustom bool) (successIDs []string, err error) {
	params := a.genShopIDParams(shopID, baiduShopID, 0)
	params[KeyActivityID] = activityID
	skusKey := "activity_skus"
	if isSkuIDCustom {
		skusKey = "activity_custom_skus"
	}
	params[skusKey] = skuList2Str(activityType, skuList, isSkuIDCustom)
	result, err := a.AccessAPI("activity.sku.add.batch", params)
	if err == nil {
		return strings.Split(result.Data.(string), ","), nil
	}
	return nil, err
}

func skuList2Str(activityType int, skuList []*ActivitySkuInfo, isSkuIDCustom bool) string {
	skuList2 := []string{}
	for _, v := range skuList {
		strList := []string{
			v.SkuID,
			utils.Int2Str(v.Stock),
		}
		if activityType == ActivityTypeDirectDown {
			strList = append(strList, fmt.Sprintf("%.2f", v.PromotionPrice))
			strList = append(strList, utils.Int2Str(v.StoreUserLimit))
		}
		skuList2 = append(skuList2, strings.Join(strList, ":"))
	}
	return strings.Join(skuList2, ";")
}

func (a *API) ActivitySkuDeleteBatch(activityID int64, shopID string, baiduShopID int64, skuIDs []string, isSkuIDCustom bool) (successIDs []string, err error) {
	params := a.genShopIDParams(shopID, baiduShopID, 0)
	params[KeyActivityID] = activityID
	skusKey := "sku_id"
	if isSkuIDCustom {
		skusKey = "custom_sku_id"
	}
	params[skusKey] = strings.Join(skuIDs, ",")
	result, err := a.AccessAPI("activity.sku.delete.batch", params)
	if err == nil {
		return strings.Split(result.Data.(string), ","), nil
	}
	return nil, err
}

func (a *API) ActivitySkuList(activityID int64, shopID string, baiduShopID, supplierID int64, skuIDs []string, isSkuIDCustom bool) (activityInfo *ActivitySkuListInfo, err error) {
	params := a.genShopIDParams(shopID, baiduShopID, supplierID)
	params[KeyActivityID] = activityID
	if len(skuIDs) > 0 {
		skusKey := "sku_id"
		if isSkuIDCustom {
			skusKey = "custom_sku_id"
		}
		params[skusKey] = strings.Join(skuIDs, ",")
	}
	pageSize := 100
	page := 1
	params["page_size"] = pageSize
	for {
		var result *ResponseResult
		params["page"] = page
		result, err = a.AccessAPI("activity.sku.list", params)
		if err == nil {
			resultMap := result.Data.(map[string]interface{})
			if activityInfo == nil {
				activityInfo = &ActivitySkuListInfo{
					ActivityID:   activityID,
					ActivityType: int(utils.Str2Int64(utils.Interface2String(resultMap["activity_type"]))),
					ActivityName: utils.Interface2String(resultMap["activity_name"]),
				}
			}
			for _, v := range resultMap["sku_list"].([]interface{}) {
				skuMap := v.(map[string]interface{})
				activityInfo.SkuList = append(activityInfo.SkuList, &ActivitySkuInfoEx{
					ActivitySkuInfo: ActivitySkuInfo{
						SkuID:          utils.Interface2String(skuMap["sku_id"]),
						Stock:          int(utils.Str2Int64(utils.Interface2String(skuMap["stock"]))),
						PromotionPrice: float32(utils.Interface2Float64WithDefault(skuMap["promotion_price"], 0)),
					},
					BaiduShopID:   utils.Str2Int64(utils.Interface2String(skuMap["baidu_shop_id"])),
					OriginalPrice: float32(utils.Interface2Float64WithDefault(skuMap["original_price"], 0)),
					UpcName:       utils.Interface2String(skuMap["upc_name"]),
				})
			}
			if len(activityInfo.SkuList) >= int(utils.MustInterface2Int64(resultMap["total"])) {
				break
			}
			page++
		} else {
			break
		}
	}
	return activityInfo, err
}

func (a *API) ActivitySkuUpdateBatch(activityID int64, actSkuInfoList []*ActivitySkuInfo4Update) (faildInfoList []string, err error) {
	result, err := a.AccessAPI("activity.sku.update.batch", map[string]interface{}{
		KeyActivityID:  activityID,
		"act_sku_info": actSkuInfoList,
	})
	if err == nil {
		return strings.Split(result.Data.(string), ";"), nil
	}
	return nil, err
}