package srv_im

import (
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/url"
	"sort"
	"strings"
	"time"

	"91porn-server/app/service/adser"
	"91porn-server/common"
	"91porn-server/common/crypt"
	"91porn-server/common/enum/imad"
	"91porn-server/common/httputil"
	"91porn-server/common/imclient"
	"91porn-server/common/log"
	"91porn-server/common/stderr"
	"91porn-server/common/redis"
	"91porn-server/models/v/imusermod"
	"91porn-server/skd/skdg"
	"91porn-server/web/webg"
)

// srvImRedis 自适应当前进程可用的 Redis 客户端：
// skd cron 调用 SendAdNotify 时 webg.Redis 为 nil，必须用 skdg.Redis；
// web 服务调用时反之。两端写的是同一个 Redis 实例。
func srvImRedis() *redis.Client {
	if skdg.Redis != nil {
		return skdg.Redis
	}
	if webg.Redis != nil {
		return webg.Redis
	}
	return nil
}

// srvImAdCenterCfg 同样的自适应思路：从当前进程的 Conf 里读 AdCenter 配置。
type srvImAdCenter struct {
	ApiDomain    string
	MerchantCode string
	AppCode      string
	AesKey       string
}

func srvImAdCenterCfg() srvImAdCenter {
	if skdg.Conf != nil {
		c := skdg.Conf.AdCenter
		if c.ApiDomain != "" || c.MerchantCode != "" || c.AppCode != "" || c.AesKey != "" {
			return srvImAdCenter{ApiDomain: c.ApiDomain, MerchantCode: c.MerchantCode, AppCode: c.AppCode, AesKey: c.AesKey}
		}
	}
	if webg.Conf != nil {
		c := webg.Conf.AdCenter
		return srvImAdCenter{ApiDomain: c.ApiDomain, MerchantCode: c.MerchantCode, AppCode: c.AppCode, AesKey: c.AesKey}
	}
	return srvImAdCenter{}
}

const (
	adNotifyType             = "AD_NOTIFY"
	adNotifyTargetSpecified  = "specified"
	adNotifyTargetOnline     = "online"
	adNotifyOnlineScanLimit  = 1000
	adNotifyPassthroughBatch = 100
	adNotifyVisibleCacheTTL  = 24 * time.Hour
	maxAdNotifyAdsPerSlot    = 10
)

type AdNotifyReq struct {
	UIDs        []uint64 `json:"uids"`
	UserIDs     []uint64 `json:"userIds"`
	Position    string   `json:"position"`
	Positions   []string `json:"positions"`
	Target      string   `json:"target"`
	TraceID     string   `json:"traceId"`
	MaxUsers    int      `json:"maxUsers"`
	ChannelType string   `json:"channelType"`
}

type AdNotifyResp struct {
	TraceID                    string   `json:"traceId"`
	AdCount                    int      `json:"adCount"`
	Positions                  []string `json:"positions"`
	Target                     string   `json:"target"`
	CandidateUserCount         int      `json:"candidateUserCount"`
	TargetUserCount            int      `json:"targetUserCount"`
	OnlineUserCount            int      `json:"onlineUserCount"`
	OnlineStatusCheckedCount   int      `json:"onlineStatusCheckedCount"`
	OnlineStatusReturnedCount  int      `json:"onlineStatusReturnedCount"`
	OnlineStatusMissingCount   int      `json:"onlineStatusMissingCount"`
	OnlineStatusInvisibleCount int      `json:"onlineStatusInvisibleCount"`
	MessageID                  string   `json:"messageId"`
	MessageIDs                 []string `json:"messageIds"`
	MessageType                int      `json:"messageType"`
	ReceiverCount              int      `json:"receiverCount"`
	ImCreatedAt                int64    `json:"imCreatedAt"`
	Sent                       bool     `json:"sent"`
}

type adNotifyTarget struct {
	UID      uint64
	IMUserID int64
}

type adNotifyPassthroughSummary struct {
	MessageID     string
	MessageIDs    []string
	MessageType   int
	ReceiverCount int
	CreatedAt     int64
}

type adNotifyOnlineStatusSummary struct {
	Targets        []adNotifyTarget
	CheckedCount   int
	ReturnedCount  int
	MissingCount   int
	InvisibleCount int
}

func SendAdNotify(req AdNotifyReq) (AdNotifyResp, stderr.Code, string) {
	now := time.Now()
	positionsReq := normalizeAdNotifyPositions(req)
	for _, position := range positionsReq {
		if !imad.IsPositionCode(position) {
			return AdNotifyResp{}, stderr.ErrParamError, "positions 必须为 IM 广告位标识"
		}
	}
	if strings.TrimSpace(req.TraceID) == "" {
		req.TraceID = fmt.Sprintf("%s_%d", adNotifyType, now.UnixNano())
	}
	targetMode := normalizeAdNotifyTarget(req.Target)
	if targetMode == "" {
		return AdNotifyResp{}, stderr.ErrParamError, "target 仅支持 online 或 specified"
	}

	positions, adCount := resolveAdNotifyPositions(positionsReq)
	resp := AdNotifyResp{
		TraceID:   req.TraceID,
		AdCount:   adCount,
		Positions: positions,
		Target:    targetMode,
	}
	if len(positions) == 0 {
		return resp, stderr.Success, ""
	}

	payload, err := buildAdNotifyPayload(req, positions, now)
	if err != nil {
		return resp, stderr.ErrParamError, err.Error()
	}
	extInfo, err := json.Marshal(payload)
	if err != nil {
		return resp, stderr.ErrParamError, err.Error()
	}

	// online 模式：调 SendAppPassthrough 一次性广播给本商户/租户下所有在线用户，
	// 由 IM 平台自己 fan-out，省掉扫表 + 查在线 + 设可见 + 分批的流程
	if targetMode == adNotifyTargetOnline {
		return sendAdNotifyBroadcast(resp, req, string(extInfo))
	}

	// specified 模式：仍按 uid 拉取目标、查在线状态、分批走 SendOnlinePassthrough
	targets, code, msg := collectAdNotifyTargets(targetMode, req)
	if code != stderr.Success {
		return resp, code, msg
	}
	resp.CandidateUserCount = len(targets)
	resp.TargetUserCount = len(targets)
	if len(targets) == 0 {
		return resp, stderr.Success, ""
	}

	ensureAdNotifyOnlineStatusVisible(targets)
	onlineSummary, code, msg := filterOnlineAdNotifyTargets(targets)
	if code != stderr.Success {
		return resp, code, msg
	}
	onlineTargets := onlineSummary.Targets
	resp.OnlineUserCount = len(onlineTargets)
	resp.OnlineStatusCheckedCount = onlineSummary.CheckedCount
	resp.OnlineStatusReturnedCount = onlineSummary.ReturnedCount
	resp.OnlineStatusMissingCount = onlineSummary.MissingCount
	resp.OnlineStatusInvisibleCount = onlineSummary.InvisibleCount
	if len(onlineTargets) == 0 {
		return resp, stderr.Success, ""
	}

	result, code, msg := sendAdNotifyPassthrough(onlineTargets, imclient.OnlinePassthroughRequest{
		PassthroughType: adNotifyType,
		Content:         string(extInfo),
		ExtInfo:         string(extInfo),
		ChannelType:     req.ChannelType,
	})
	if code != stderr.Success {
		return resp, code, msg
	}
	resp.MessageID = result.MessageID
	resp.MessageIDs = result.MessageIDs
	resp.MessageType = result.MessageType
	resp.ReceiverCount = result.ReceiverCount
	resp.ImCreatedAt = result.CreatedAt
	resp.Sent = true
	return resp, stderr.Success, ""
}

// logAdNotifyBroadcastCurl 把广播请求拼成等价 curl 命令打日志（INFO 级别）。
// 仅包含 IM SDK 显式 header（X-Merchant-Code / X-App-Key / X-Client-Id / token），
// 签名相关 header 由 imclient 内部按请求计算，curl 复现时需要去掉签名校验或对接时再加。
func logAdNotifyBroadcastCurl(traceID, token string, body imclient.AppPassthroughRequest) {
	cfg := srvImV2Cfg()
	base := strings.TrimRight(cfg.BaseURL, "/")
	u := fmt.Sprintf("%s/api/endpoint/%s/%s/message/passthrough/send/batch/all",
		base, url.PathEscape(cfg.MerchantCode), url.PathEscape(cfg.TenantCode))
	raw, _ := json.Marshal(body)
	curl := fmt.Sprintf(`curl -X POST '%s' `+
		`-H 'Content-Type: application/json' `+
		`-H 'Accept: application/json' `+
		`-H 'X-Merchant-Code: %s' `+
		`-H 'X-App-Key: %s' `+
		`-H 'X-Client-Id: %s' `+
		`-H 'token: %s' `+
		`-d '%s'`,
		u, cfg.MerchantCode, cfg.AppKey, cfg.ClientID, token, string(raw))
	log.Info("SendAdNotify broadcast curl",
		log.Any("traceId", traceID), log.Any("curl", curl))
}

// sendAdNotifyBroadcast 走 IM 平台的"全在线广播"接口
// POST /api/endpoint/{merchantCode}/{tenantCode}/message/passthrough/send/batch/all
// 一次调用就把消息推给本商户/租户下所有在线用户，无需先查用户列表
func sendAdNotifyBroadcast(resp AdNotifyResp, req AdNotifyReq, extInfo string) (AdNotifyResp, stderr.Code, string) {
	c := newWebSDKClient()
	body := imclient.AppPassthroughRequest{
		PassthroughType: adNotifyType,
		Content:         extInfo,
		ExtInfo:         extInfo,
		ChannelType:     req.ChannelType,
	}
	var result *imclient.PassthroughResult
	err := withAppToken(c, func(token string) error {
		// 打印等价 curl，方便联调
		logAdNotifyBroadcastCurl(req.TraceID, token, body)
		var sendErr error
		result, sendErr = c.SendAppPassthrough(body, token)
		return sendErr
	})
	if err != nil {
		log.Error("SendAdNotify broadcast failed", log.Any("traceId", req.TraceID), log.E(err))
		return resp, stderr.Failure, err.Error()
	}
	if result != nil {
		resp.MessageID = result.MessageID
		resp.MessageType = result.MessageType
		resp.ReceiverCount = result.ReceiverCount
		resp.OnlineUserCount = result.ReceiverCount // 平台返回的就是实际推送到的在线数
		resp.ImCreatedAt = result.CreatedAt
	}
	resp.Sent = true
	return resp, stderr.Success, ""
}

func normalizeAdNotifyTarget(target string) string {
	switch strings.ToLower(strings.TrimSpace(target)) {
	case "":
		return adNotifyTargetSpecified
	case adNotifyTargetSpecified:
		return adNotifyTargetSpecified
	case adNotifyTargetOnline:
		return adNotifyTargetOnline
	default:
		return ""
	}
}

func collectAdNotifyTargets(targetMode string, req AdNotifyReq) ([]adNotifyTarget, stderr.Code, string) {
	switch targetMode {
	case adNotifyTargetOnline:
		return scanAdNotifyIMUsers(req.MaxUsers)
	case adNotifyTargetSpecified:
		uids := normalizeUIDs(append(req.UIDs, req.UserIDs...))
		if len(uids) == 0 {
			return nil, stderr.ErrParamError, "userIds不能为空；全量在线推送请传 target=online"
		}
		return resolveAdNotifyTargetsByUIDs(uids)
	default:
		return nil, stderr.ErrParamError, "target 仅支持 online 或 specified"
	}
}

func resolveAdNotifyTargetsByUIDs(uids []uint64) ([]adNotifyTarget, stderr.Code, string) {
	// uid → imUserId 走 imusermod（唯一真源）
	byUID, err := imusermod.IMUserIDMapByUIDs(uids)
	if err != nil {
		return nil, stderr.Failure, err.Error()
	}
	targets := make([]adNotifyTarget, 0, len(byUID))
	for _, uid := range uids {
		imUserID, ok := byUID[uid]
		if !ok {
			continue
		}
		targets = append(targets, adNotifyTarget{UID: uid, IMUserID: imUserID})
	}
	return targets, stderr.Success, ""
}

func scanAdNotifyIMUsers(maxUsers int) ([]adNotifyTarget, stderr.Code, string) {
	targets := make([]adNotifyTarget, 0)
	// 直接扫 im_user 表（只含已注册 IM 的用户），按 uid 游标分页。
	// 表本身就小，且天然只有"有 imUserId 的用户"，无需过滤 imUserId>0。
	var lastUID uint64
	for {
		limit := int64(adNotifyOnlineScanLimit)
		if maxUsers > 0 {
			remaining := int64(maxUsers - len(targets))
			if remaining <= 0 {
				break
			}
			if remaining < limit {
				limit = remaining
			}
		}
		list, err := imusermod.ListAfterUID(lastUID, limit)
		if err != nil {
			return nil, stderr.Failure, err.Error()
		}
		if len(list) == 0 {
			break
		}
		for i := range list {
			u := list[i]
			if u.UID == 0 || u.IMUserID <= 0 {
				continue
			}
			targets = append(targets, adNotifyTarget{UID: u.UID, IMUserID: u.IMUserID})
		}
		// 本批末条 uid 即下一页游标（按 uid 升序）
		lastUID = list[len(list)-1].UID
		// 本批不满 limit，说明已扫到末尾
		if int64(len(list)) < limit {
			break
		}
	}
	return targets, stderr.Success, ""
}

func resolveAdNotifyPositions(requested []string) ([]string, int) {
	if len(requested) > 0 {
		return requested, 0
	}
	slots, err := webAdSlots()
	if err != nil {
		return nil, 0
	}
	positions := listAdPositionsWithAds(slots)
	adCount := 0
	for _, position := range positions {
		ads := selectAdDetailsByPosition(slots, position)
		adCount += len(ads)
	}
	return positions, adCount
}

func normalizeAdNotifyPositions(req AdNotifyReq) []string {
	positions := make([]string, 0, len(req.Positions)+1)
	if position := strings.TrimSpace(req.Position); position != "" {
		positions = append(positions, position)
	}
	positions = append(positions, req.Positions...)
	seen := make(map[string]struct{}, len(positions))
	normalized := make([]string, 0, len(positions))
	for _, position := range positions {
		position = strings.TrimSpace(position)
		if position == "" {
			continue
		}
		if _, ok := seen[position]; ok {
			continue
		}
		seen[position] = struct{}{}
		normalized = append(normalized, position)
	}
	return normalized
}

func buildAdNotifyPayload(req AdNotifyReq, positions []string, now time.Time) (map[string]interface{}, error) {
	return map[string]interface{}{
		"type":      adNotifyType,
		"positions": positions,
		"traceId":   req.TraceID,
		"createdAt": now.UnixMilli(),
	}, nil
}

func ensureAdNotifyOnlineStatusVisible(targets []adNotifyTarget) {
	if len(targets) == 0 {
		return
	}
	c := newWebSDKClient()
	seen := make(map[int64]struct{}, len(targets))
	successCount := 0
	for _, target := range targets {
		if target.IMUserID <= 0 {
			continue
		}
		if _, ok := seen[target.IMUserID]; ok {
			continue
		}
		seen[target.IMUserID] = struct{}{}
		if !shouldEnsureAdNotifyOnlineStatusVisible(target.IMUserID) {
			continue
		}
		if err := withAppToken(c, func(token string) error {
			return c.SetOnlineStatus(imclient.SetOnlineStatusRequest{
				UserID:           target.IMUserID,
				ShowOnlineStatus: true,
			}, token)
		}); err != nil {
			log.Warn("SendAdNotify SetOnlineStatusVisible failed",
				log.Any("uid", target.UID), log.Any("imUserId", target.IMUserID), log.E(err))
			continue
		}
		markAdNotifyOnlineStatusVisible(target.IMUserID)
		successCount++
	}
	log.Info("SendAdNotify SetOnlineStatusVisible summary",
		log.Any("candidateCount", len(seen)), log.Any("successCount", successCount))
}

func shouldEnsureAdNotifyOnlineStatusVisible(imUserID int64) bool {
	r := srvImRedis()
	if r == nil {
		return true
	}
	cached, err := r.Get(adNotifyVisibleCacheKey(imUserID))
	if err != nil {
		log.Warn("SendAdNotify visible cache get failed", log.Any("imUserId", imUserID), log.E(err))
		return true
	}
	return cached == nil
}

func markAdNotifyOnlineStatusVisible(imUserID int64) {
	r := srvImRedis()
	if r == nil {
		return
	}
	if err := r.Set(adNotifyVisibleCacheKey(imUserID), 1, adNotifyVisibleCacheTTL); err != nil {
		log.Warn("SendAdNotify visible cache set failed", log.Any("imUserId", imUserID), log.E(err))
	}
}

func adNotifyVisibleCacheKey(imUserID int64) string {
	return fmt.Sprintf("im:online_status_visible:%d", imUserID)
}

func filterOnlineAdNotifyTargets(targets []adNotifyTarget) (adNotifyOnlineStatusSummary, stderr.Code, string) {
	imUserIDs := make([]int64, 0, len(targets))
	seen := make(map[int64]struct{}, len(targets))
	for _, target := range targets {
		if target.IMUserID <= 0 {
			continue
		}
		if _, ok := seen[target.IMUserID]; ok {
			continue
		}
		seen[target.IMUserID] = struct{}{}
		imUserIDs = append(imUserIDs, target.IMUserID)
	}
	summary := adNotifyOnlineStatusSummary{CheckedCount: len(imUserIDs)}
	statusByIMUserID := make(map[int64]bool, len(imUserIDs))
	invisibleCount := 0
	c := newWebSDKClient()
	for _, batch := range chunkInt64s(imUserIDs, maxIMOnlineStatusBatchSize) {
		var statuses []imclient.OnlineStatus
		err := withAppToken(c, func(token string) error {
			var statusErr error
			statuses, statusErr = c.BatchOnlineStatus(imclient.BatchOnlineStatusRequest{UserIDs: batch}, token)
			return statusErr
		})
		if err != nil {
			return summary, stderr.Failure, err.Error()
		}
		for _, item := range statuses {
			if item.UserID <= 0 {
				continue
			}
			statusByIMUserID[item.UserID] = item.Online
			if !item.Visible {
				invisibleCount++
			}
		}
	}
	summary.ReturnedCount = len(statusByIMUserID)
	summary.MissingCount = summary.CheckedCount - summary.ReturnedCount
	if summary.MissingCount < 0 {
		summary.MissingCount = 0
	}
	summary.InvisibleCount = invisibleCount
	summary.Targets = onlineAdNotifyTargets(targets, statusByIMUserID)
	log.Info("SendAdNotify online status summary",
		log.Any("checkedCount", summary.CheckedCount),
		log.Any("returnedCount", summary.ReturnedCount),
		log.Any("missingCount", summary.MissingCount),
		log.Any("onlineCount", len(summary.Targets)),
		log.Any("invisibleCount", summary.InvisibleCount),
		log.Any("sampleIMUserIds", sampleInt64s(imUserIDs, 10)),
	)
	return summary, stderr.Success, ""
}

func sampleInt64s(values []int64, limit int) []int64 {
	if limit <= 0 || len(values) == 0 {
		return nil
	}
	if len(values) < limit {
		limit = len(values)
	}
	return append([]int64(nil), values[:limit]...)
}

func onlineAdNotifyTargets(targets []adNotifyTarget, statusByIMUserID map[int64]bool) []adNotifyTarget {
	online := make([]adNotifyTarget, 0, len(targets))
	seen := make(map[int64]struct{}, len(targets))
	for _, target := range targets {
		if target.IMUserID <= 0 || !statusByIMUserID[target.IMUserID] {
			continue
		}
		if _, ok := seen[target.IMUserID]; ok {
			continue
		}
		seen[target.IMUserID] = struct{}{}
		online = append(online, target)
	}
	return online
}

func sendAdNotifyPassthrough(targets []adNotifyTarget, req imclient.OnlinePassthroughRequest) (adNotifyPassthroughSummary, stderr.Code, string) {
	var summary adNotifyPassthroughSummary
	c := newWebSDKClient()
	for _, batch := range chunkAdNotifyTargets(targets, adNotifyPassthroughBatch) {
		receiverIDs := make([]int64, 0, len(batch))
		for _, target := range batch {
			receiverIDs = append(receiverIDs, target.IMUserID)
		}
		req.ReceiverIDSet = receiverIDs
		var result *imclient.PassthroughResult
		err := withAppToken(c, func(token string) error {
			var sendErr error
			result, sendErr = c.SendOnlinePassthrough(req, token)
			return sendErr
		})
		if err != nil {
			return summary, stderr.Failure, err.Error()
		}
		if result == nil {
			continue
		}
		if summary.MessageID == "" {
			summary.MessageID = result.MessageID
		}
		summary.MessageType = result.MessageType
		summary.ReceiverCount += result.ReceiverCount
		summary.CreatedAt = result.CreatedAt
		summary.MessageIDs = append(summary.MessageIDs, result.MessageID)
	}
	return summary, stderr.Success, ""
}

func chunkAdNotifyTargets(targets []adNotifyTarget, size int) [][]adNotifyTarget {
	if size <= 0 {
		size = adNotifyPassthroughBatch
	}
	chunks := make([][]adNotifyTarget, 0, (len(targets)+size-1)/size)
	for start := 0; start < len(targets); start += size {
		end := start + size
		if end > len(targets) {
			end = len(targets)
		}
		chunks = append(chunks, targets[start:end])
	}
	return chunks
}

type webAdCenterResp struct {
	Code int    `json:"code"`
	Msg  string `json:"msg"`
	Data string `json:"data"`
}

func webAdSlots() ([]adser.AdSlot, error) {
	cfg := srvImAdCenterCfg()
	if cfg.ApiDomain == "" || cfg.MerchantCode == "" || cfg.AppCode == "" || cfg.AesKey == "" {
		return nil, errors.New("adCenter 未配置")
	}
	foreverCacheKey := fmt.Sprintf("jtAdForever-%s-%s", cfg.MerchantCode, cfg.AppCode)
	redisKey := fmt.Sprintf("jtAd-%s-%s", cfg.MerchantCode, cfg.AppCode)
	r := srvImRedis()
	if r != nil {
		str, err := r.Get(redisKey)
		if err != nil {
			log.Error(fmt.Sprintf("IM AdNotify 获取广告缓存异常:%v", err))
		}
		if str != nil {
			var cached []adser.AdSlot
			if err = json.Unmarshal([]byte(*str), &cached); err == nil {
				return cached, nil
			}
		}
	}

	req := adser.JtAdvertiseReq{
		MerchantCode: cfg.MerchantCode,
		AppCode:      cfg.AppCode,
		AdStatus:     1,
	}
	var serverResp *webAdCenterResp
	body, _ := json.Marshal(req)
	code, err := httputil.DefaultClientPostJsonWithResp(&serverResp, cfg.ApiDomain+"/openapi/getAdvertiseList", nil, body)
	if err != nil {
		return webAdSlotsFromLastTime(foreverCacheKey, err)
	}
	if code != http.StatusOK {
		return webAdSlotsFromLastTime(foreverCacheKey, fmt.Errorf("response status %d", code))
	}
	if serverResp == nil || serverResp.Code != 0 {
		msg := ""
		if serverResp != nil {
			msg = serverResp.Msg
		}
		return webAdSlotsFromLastTime(foreverCacheKey, fmt.Errorf("response code error: %s", msg))
	}
	adsData, err := crypt.AdDecrypt(serverResp.Data, cfg.AesKey)
	if err != nil {
		return nil, err
	}
	var slots []adser.AdSlot
	if err = json.Unmarshal([]byte(adsData), &slots); err != nil {
		return nil, err
	}
	for i := range slots {
		sort.Slice(slots[i].AdDetailInfoList, func(j, k int) bool {
			return slots[i].AdDetailInfoList[j].Sort < slots[i].AdDetailInfoList[k].Sort
		})
	}
	if r := srvImRedis(); r != nil {
		common.Go(func() {
			data, err := json.Marshal(&slots)
			if err != nil {
				return
			}
			_ = r.Set(foreverCacheKey, data, time.Hour*72)
			_ = r.Set(redisKey, data, time.Minute)
		})
	}
	return slots, nil
}

func webAdSlotsFromLastTime(cacheKey string, fallback error) ([]adser.AdSlot, error) {
	r := srvImRedis()
	if r == nil {
		return nil, fallback
	}
	str, err := r.Get(cacheKey)
	if err != nil || str == nil {
		return nil, fallback
	}
	var slots []adser.AdSlot
	if err = json.Unmarshal([]byte(*str), &slots); err != nil {
		return nil, fallback
	}
	return slots, nil
}

func listAdPositionsWithAds(slots []adser.AdSlot) []string {
	positions := make([]string, 0)
	seen := make(map[string]struct{})
	for _, slot := range slots {
		code := strings.TrimSpace(slot.AdvertiseLocationCode)
		if !imad.IsPositionCode(code) || len(slot.AdDetailInfoList) == 0 {
			continue
		}
		if _, ok := seen[code]; ok {
			continue
		}
		seen[code] = struct{}{}
		positions = append(positions, code)
	}
	sort.Strings(positions)
	return positions
}

func selectAdDetailsByPosition(slots []adser.AdSlot, position string) []adser.AdDetailInfo {
	position = strings.TrimSpace(position)
	matches := make([]adser.AdDetailInfo, 0)
	for _, slot := range slots {
		if strings.TrimSpace(slot.AdvertiseLocationCode) != position {
			continue
		}
		matches = append(matches, slot.AdDetailInfoList...)
	}
	if len(matches) > maxAdNotifyAdsPerSlot {
		matches = matches[:maxAdNotifyAdsPerSlot]
	}
	return matches
}