package rpc

import (
	"context"
	"errors"

	"github.com/iamxvbaba/td/tg"
	"github.com/iamxvbaba/td/tgerr"
	"go.uber.org/zap"

	"telesrv/internal/domain"
)

// 本文件是 poll 链路的响应/推送/事件辅助，与 reaction（messages_reactions_send.go）同构：
//   - 私聊：双方各记一条 message_poll durable event（无 pts 的 updateMessagePoll + aux pts 簿记），
//     离线端经 getDifference 拿到消息快照与最新 poll 状态；
//   - 频道：实时 fan-out 给在线 viewer（作者进 explicit 收件人），无 durable event——
//     与 channel reaction 现状一致（离线缺口见 compatibility-matrix.md，客户端靠 getPollResults 刷新）。

// pollMutationErr 把 poll/消息域错误映射为 RPC error。
func pollMutationErr(err error) error {
	switch {
	case err == nil:
		return nil
	case errors.Is(err, domain.ErrPollClosed):
		return pollClosedErr()
	case errors.Is(err, domain.ErrPollRevoteNotAllowed):
		return revoteNotAllowedErr()
	case errors.Is(err, domain.ErrPollOptionInvalid):
		return optionInvalidErr()
	case errors.Is(err, domain.ErrPollNotCreator):
		return tgerr.New(403, "MESSAGE_AUTHOR_REQUIRED")
	case errors.Is(err, domain.ErrPollNotFound), errors.Is(err, domain.ErrPollInvalid), errors.Is(err, domain.ErrMessageIDInvalid):
		return messageIDInvalidErr()
	default:
		return channelInvalidErr(err)
	}
}

// loadMessagePoll 按 viewer 视角加载消息上的 poll（已 enrich）。
func (r *Router) loadMessagePoll(ctx context.Context, userID int64, peer domain.Peer, msgID int) (*domain.MessagePoll, domain.Peer, bool) {
	switch peer.Type {
	case domain.PeerTypeChannel:
		if r.deps.Channels == nil {
			return nil, peer, false
		}
		history, err := r.deps.Channels.GetMessages(ctx, userID, peer.ID, []int{msgID})
		if err != nil {
			return nil, peer, false
		}
		for _, msg := range history.Messages {
			if msg.ID == msgID && msg.Media != nil && msg.Media.Kind == domain.MessageMediaKindPoll && msg.Media.Poll != nil {
				return msg.Media.Poll, peer, true
			}
		}
	case domain.PeerTypeUser:
		if r.deps.Messages == nil {
			return nil, peer, false
		}
		list, err := r.deps.Messages.GetMessages(ctx, userID, []int{msgID})
		if err != nil {
			return nil, peer, false
		}
		for _, msg := range list.Messages {
			if msg.ID == msgID && msg.Peer == peer && msg.Media != nil && msg.Media.Kind == domain.MessageMediaKindPoll && msg.Media.Poll != nil {
				return msg.Media.Poll, peer, true
			}
		}
	}
	return nil, peer, false
}

// pollUpdateRefs 收集 updateMessagePoll 响应需要的 users/chats（recent voters 头像 + channel 实体）。
// channel 由调用方传入（频道 poll 用结果里的 res.Channel；私聊传零值）：与 reaction fan-out 同款用
// 单个 channel 一次性投影 tgChannels，避免频道 poll fan-out 每 viewer 一次 GetChannel 的 DB N+1
// （poll 聚合 N+1 已由 ChannelPollFanoutViews 消除，这是 poll fan-out 残留的 per-viewer DB 调用）。
func (r *Router) pollUpdateRefs(ctx context.Context, viewerUserID int64, peer domain.Peer, poll *domain.MessagePoll, channel domain.Channel) ([]tg.UserClass, []tg.ChatClass) {
	userIDs := make([]int64, 0, domain.MaxPollRecentVoters)
	if poll != nil && poll.Results != nil {
		userIDs = append(userIDs, poll.Results.RecentVoters...)
	}
	users := r.tgUsersForIDs(ctx, viewerUserID, userIDs)
	chats := []tg.ChatClass{}
	if peer.Type == domain.PeerTypeChannel {
		if channel.ID != 0 {
			// fan-out 路径：调用方已带 channel，一次性投影（同 reaction），免 per-viewer GetChannel。
			chats = tgChannels(viewerUserID, []domain.Channel{channel})
		} else if r.deps.Channels != nil {
			// 非 fan-out 单 viewer 路径（getPollResults）：channel 未带，保持原 GetChannel 行为不变。
			if view, err := r.deps.Channels.GetChannel(ctx, viewerUserID, peer.ID); err == nil && view.Channel.ID != 0 {
				chats = []tg.ChatClass{tgChannelChatForView(viewerUserID, view)}
			}
		}
	}
	return users, chats
}

// privatePollUpdates 记录双方 durable event、推送双方在线 session，并返回投票者视角响应。
func (r *Router) privatePollUpdates(ctx context.Context, requestUserID int64, res domain.PrivateMessagePollResult) tg.UpdatesClass {
	recordedEvents := r.recordPrivateMessagePollEvents(ctx, requestUserID, res)
	var requesterUpdates *tg.Updates
	for _, msg := range res.Messages {
		if msg.ID <= 0 || msg.Media == nil || msg.Media.Poll == nil {
			continue
		}
		update := tgUpdateMessagePoll(msg.Peer, msg.ID, msg.Media.Poll)
		if update == nil {
			continue
		}
		users, chats := r.pollUpdateRefs(ctx, msg.OwnerUserID, msg.Peer, msg.Media.Poll, domain.Channel{})
		updates := &tg.Updates{
			Updates: []tg.UpdateClass{update},
			Users:   users,
			Chats:   chats,
			Date:    int(r.clock.Now().Unix()),
		}
		// message_poll 事件占账号 pts 但 updateMessagePoll 无 pts 字段，附 aux 簿记推水位。
		updates.Updates = appendAuxPtsBookkeeping(updates.Updates, recordedEvents[msg.OwnerUserID])
		if msg.OwnerUserID == requestUserID {
			requesterUpdates = updates
		}
		r.pushUserUpdates(ctx, msg.OwnerUserID, updates)
	}
	if requesterUpdates == nil {
		return tgEmptyUpdates(int(r.clock.Now().Unix()))
	}
	return requesterUpdates
}

func (r *Router) recordPrivateMessagePollEvents(ctx context.Context, requestUserID int64, res domain.PrivateMessagePollResult) map[int64]domain.UpdateEvent {
	if r.deps.Updates == nil {
		return nil
	}
	recorder, ok := r.deps.Updates.(messagePollUpdateRecorder)
	if !ok {
		return nil
	}
	authKeyID, _ := AuthKeyIDFrom(ctx)
	events := make(map[int64]domain.UpdateEvent, len(res.Messages))
	for _, msg := range res.Messages {
		if msg.OwnerUserID == 0 || msg.ID == 0 {
			continue
		}
		eventAuthKeyID := [8]byte{}
		if msg.OwnerUserID == requestUserID {
			eventAuthKeyID = authKeyID
		}
		event, _, err := recorder.RecordMessagePoll(ctx, eventAuthKeyID, msg.OwnerUserID, msg)
		if err != nil {
			r.log.Warn("record message poll event failed")
			continue
		}
		events[msg.OwnerUserID] = event
	}
	return events
}

// onEditMessageClosePoll 处理 editMessage + InputMediaPoll：当前唯一支持的 poll 编辑是
// 关闭（closed=true，仅 poll 创建者）；改题/改选项无官方客户端路径，显式拒绝。
func (r *Router) onEditMessageClosePoll(ctx context.Context, req *tg.MessagesEditMessageRequest, media *tg.InputMediaPoll) (tg.UpdatesClass, error) {
	if req.ID <= 0 || req.ID > domain.MaxMessageBoxID {
		return nil, messageIDInvalidErr()
	}
	if !media.Poll.Closed {
		return nil, mediaInvalidErr()
	}
	userID, peer, err := r.reactionPeer(ctx, req.Peer, nil)
	if err != nil {
		return nil, err
	}
	now := int(r.clock.Now().Unix())
	switch peer.Type {
	case domain.PeerTypeChannel:
		if r.deps.Channels == nil {
			return nil, messageIDInvalidErr()
		}
		res, err := r.deps.Channels.CloseMessagePoll(ctx, userID, domain.CloseChannelMessagePollRequest{
			UserID:    userID,
			ChannelID: peer.ID,
			MessageID: req.ID,
			Date:      now,
		})
		if err != nil {
			return nil, pollMutationErr(err)
		}
		return r.channelPollUpdates(ctx, userID, peer, req.ID, res, true), nil
	case domain.PeerTypeUser:
		if r.deps.Messages == nil {
			return nil, messageIDInvalidErr()
		}
		res, err := r.deps.Messages.CloseMessagePoll(ctx, userID, domain.ClosePrivateMessagePollRequest{
			UserID:    userID,
			Peer:      peer,
			MessageID: req.ID,
			Date:      now,
		})
		if err != nil {
			return nil, pollMutationErr(err)
		}
		return r.privatePollUpdates(ctx, userID, res), nil
	default:
		return nil, peerIDInvalidErr()
	}
}

// channelPollUpdates 组装投票者视角响应；push 为 true 时按 viewer 重建并 fan-out 给在线成员。
//
// Phase 4 模板化：fan-out 前一次性批量加载所有收件人的 per-viewer poll 投影（ChannelPollFanoutViews
// 把 viewer-invariant 聚合只算一次 + 批量 viewerOptions/可见性），消除原先每 viewer 一次 GetMessages
// 的 N+1。dispatch 仍同步（poll 是 viewer-only 无 durable event，改异步丢队列即永久漏）。预取未覆盖
// 的 viewer 回退逐 viewer loadMessagePoll 保正确（与旧路径字节同源）。actor echo 仍用 res poll（旧行为）。
func (r *Router) channelPollUpdates(ctx context.Context, userID int64, peer domain.Peer, msgID int, res domain.ChannelMessagePollResult, push bool) tg.UpdatesClass {
	var batched map[int64]*domain.MessagePoll
	if push && peer.Type == domain.PeerTypeChannel && r.deps.Channels != nil {
		recipients := r.channelFanoutRecipients(ctx, channelFanoutViewers, res.Channel.ID, res.Recipients)
		if len(recipients) > 0 {
			views, err := r.deps.Channels.ChannelPollFanoutViews(ctx, res.Channel.ID, msgID, recipients, int(r.clock.Now().Unix()))
			if err != nil {
				r.log.Warn("channel poll fanout prefetch failed; falling back to per-viewer reload",
					zap.Int64("channel_id", res.Channel.ID), zap.Int("msg_id", msgID), zap.Error(err))
			} else {
				batched = views
			}
		}
	}
	build := func(viewerUserID int64) *tg.Updates {
		poll := res.Message.Media.Poll
		if viewerUserID != userID {
			// 其它 viewer 的 chosen/correct/solution 门控不同，按其视角取投影。
			if p, evaluated := batched[viewerUserID]; evaluated {
				if p == nil {
					return nil // 预取已判定该 viewer 不可见
				}
				poll = p
			} else {
				// 预取未覆盖（极少：并发/收件人集漂移）→ 回退逐 viewer 重载。
				reloaded, _, found := r.loadMessagePoll(ctx, viewerUserID, peer, msgID)
				if !found {
					return nil
				}
				poll = reloaded
			}
		}
		update := tgUpdateMessagePoll(peer, msgID, poll)
		if update == nil {
			return nil
		}
		users, chats := r.pollUpdateRefs(ctx, viewerUserID, peer, poll, res.Channel)
		return &tg.Updates{
			Updates: []tg.UpdateClass{update},
			Users:   users,
			Chats:   chats,
			Date:    int(r.clock.Now().Unix()),
		}
	}
	updates := build(userID)
	if push {
		r.pushChannelViewerUpdates(ctx, userID, res.Channel.ID, res.Recipients, build)
	}
	if updates == nil {
		return tgEmptyUpdates(int(r.clock.Now().Unix()))
	}
	return updates
}