package postgres

import (
	"context"
	"encoding/binary"
	"errors"
	"fmt"
	"github.com/jackc/pgx/v5"
	"hash"
	"sort"
	"telesrv/internal/domain"
	"telesrv/internal/store/postgres/sqlcgen"
	"time"
)

func (s *MessageStore) SetMessageReactions(ctx context.Context, req domain.SetPrivateMessageReactionsRequest) (domain.PrivateMessageReactionsResult, error) {
	if req.UserID == 0 || req.Peer.Type != domain.PeerTypeUser || req.Peer.ID == 0 || req.MessageID <= 0 || req.MessageID > domain.MaxMessageBoxID {
		return domain.PrivateMessageReactionsResult{}, domain.ErrMessageIDInvalid
	}
	if len(req.Reactions) > domain.MaxChannelMessageReactionsPerUser {
		return domain.PrivateMessageReactionsResult{}, domain.ErrMessageIDInvalid
	}
	req.Reactions = domain.TrimMessageReactionsToUserMax(req.Reactions, req.ReactionsPerUserMax)
	if req.Date == 0 {
		req.Date = int(time.Now().Unix())
	}
	for _, reaction := range req.Reactions {
		if !reaction.Valid() {
			return domain.PrivateMessageReactionsResult{}, domain.ErrMessageIDInvalid
		}
	}
	if req.Peer.ID == req.UserID {
		return s.setSavedMessageTags(ctx, req)
	}
	beginner, ok := s.db.(txBeginner)
	if !ok {
		return domain.PrivateMessageReactionsResult{}, fmt.Errorf("set message reactions: db does not support transactions")
	}
	tx, err := beginner.Begin(ctx)
	if err != nil {
		return domain.PrivateMessageReactionsResult{}, fmt.Errorf("begin set message reactions tx: %w", err)
	}
	qtx := sqlcgen.New(tx)
	committed := false
	defer func() {
		if !committed {
			_ = tx.Rollback(ctx)
		}
	}()

	if err := lockUsersForUpdate(ctx, tx, req.UserID, req.Peer.ID); err != nil {
		return domain.PrivateMessageReactionsResult{}, fmt.Errorf("lock set message reactions users: %w", err)
	}

	var target struct {
		boxID            int32
		privateMessageID int64
		messageSenderID  int64
	}
	if err := tx.QueryRow(ctx, `
SELECT box_id, private_message_id, message_sender_id
FROM message_boxes
WHERE owner_user_id = $1
  AND box_id = $2
  AND peer_type = $3
  AND peer_id = $4
  AND NOT deleted
LIMIT 1
FOR UPDATE`, req.UserID, int32(req.MessageID), string(req.Peer.Type), req.Peer.ID).Scan(&target.boxID, &target.privateMessageID, &target.messageSenderID); err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return domain.PrivateMessageReactionsResult{}, domain.ErrMessageIDInvalid
		}
		return domain.PrivateMessageReactionsResult{}, fmt.Errorf("get message for reactions: %w", err)
	}
	if _, err := tx.Exec(ctx, `
DELETE FROM private_message_reactions
WHERE message_sender_id = $1
  AND private_message_id = $2
  AND user_id = $3`, target.messageSenderID, target.privateMessageID, req.UserID); err != nil {
		return domain.PrivateMessageReactionsResult{}, fmt.Errorf("delete old message reactions: %w", err)
	}
	for i, reaction := range req.Reactions {
		if _, err := tx.Exec(ctx, `
INSERT INTO private_message_reactions (
  message_sender_id,
  private_message_id,
  user_id,
  reaction_type,
  reaction_value,
  big,
  reaction_date,
  chosen_order
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
ON CONFLICT (message_sender_id, private_message_id, user_id, reaction_type, reaction_value)
DO UPDATE SET
  big = EXCLUDED.big,
  reaction_date = EXCLUDED.reaction_date,
  chosen_order = EXCLUDED.chosen_order,
  updated_at = now()`,
			target.messageSenderID,
			target.privateMessageID,
			req.UserID,
			string(reaction.Type),
			reaction.Value(),
			req.Big,
			int32(req.Date),
			int32(i+1),
		); err != nil {
			return domain.PrivateMessageReactionsResult{}, fmt.Errorf("insert message reaction: %w", err)
		}
	}
	if target.messageSenderID != 0 && target.messageSenderID != req.UserID {
		if _, err := tx.Exec(ctx, `
UPDATE message_boxes b
SET reaction_unread = EXISTS (
    SELECT 1
    FROM private_message_reactions r
    WHERE r.message_sender_id = b.message_sender_id
      AND r.private_message_id = b.private_message_id
      AND r.user_id <> b.owner_user_id
)
WHERE b.owner_user_id = $1
  AND b.message_sender_id = $2
  AND b.private_message_id = $3`, target.messageSenderID, target.messageSenderID, target.privateMessageID); err != nil {
			return domain.PrivateMessageReactionsResult{}, fmt.Errorf("update private reaction unread: %w", err)
		}
		if _, err := tx.Exec(ctx, `
UPDATE dialogs d
SET unread_reactions_count = (
    SELECT COUNT(*)::int
    FROM message_boxes m
    WHERE m.owner_user_id = d.user_id
      AND m.peer_type = d.peer_type
      AND m.peer_id = d.peer_id
      AND NOT m.deleted
      AND m.reaction_unread
),
updated_at = now()
WHERE d.user_id = $1
  AND d.peer_type = $2
  AND d.peer_id = $3`, target.messageSenderID, string(domain.PeerTypeUser), req.UserID); err != nil {
			return domain.PrivateMessageReactionsResult{}, fmt.Errorf("refresh private reaction unread dialog: %w", err)
		}
	}

	boxes, err := qtx.ListVisibleMessageBoxesByPrivateMessage(ctx, sqlcgen.ListVisibleMessageBoxesByPrivateMessageParams{
		OwnerUserIds:     privateMessageOwnerIDs(req.UserID, req.Peer.ID),
		MessageSenderID:  target.messageSenderID,
		PrivateMessageID: target.privateMessageID,
	})
	if err != nil {
		return domain.PrivateMessageReactionsResult{}, fmt.Errorf("list visible reaction boxes: %w", err)
	}
	res := domain.PrivateMessageReactionsResult{Messages: make([]domain.Message, 0, len(boxes))}
	for _, box := range boxes {
		msg, err := messageFromVisibleBoxRow(box)
		if err != nil {
			return domain.PrivateMessageReactionsResult{}, err
		}
		res.Messages = append(res.Messages, msg)
	}
	if err := s.enrichPrivateMessageReactions(ctx, tx, req.UserID, res.Messages); err != nil {
		return domain.PrivateMessageReactionsResult{}, err
	}
	for _, msg := range res.Messages {
		if msg.OwnerUserID == req.UserID && msg.Reactions != nil {
			res.Reactions = *msg.Reactions
			break
		}
	}
	if err := tx.Commit(ctx); err != nil {
		return domain.PrivateMessageReactionsResult{}, fmt.Errorf("commit set message reactions tx: %w", err)
	}
	committed = true
	return res, nil
}

func (s *MessageStore) GetMessageReactions(ctx context.Context, req domain.PrivateMessageReactionsRequest) (domain.PrivateMessageReactionsResult, error) {
	if req.OwnerUserID == 0 || req.Peer.Type != domain.PeerTypeUser || req.Peer.ID == 0 || len(req.IDs) > domain.MaxGetMessageIDs {
		return domain.PrivateMessageReactionsResult{}, domain.ErrMessageIDInvalid
	}
	if len(req.IDs) == 0 {
		return domain.PrivateMessageReactionsResult{}, nil
	}
	boxIDs := make([]int32, 0, len(req.IDs))
	for _, id := range req.IDs {
		if id <= 0 || id > domain.MaxMessageBoxID {
			return domain.PrivateMessageReactionsResult{}, domain.ErrMessageIDInvalid
		}
		boxIDs = append(boxIDs, int32(id))
	}
	rows, err := s.q.GetMessageBoxesByIDs(ctx, sqlcgen.GetMessageBoxesByIDsParams{
		OwnerUserID: req.OwnerUserID,
		BoxIds:      boxIDs,
	})
	if err != nil {
		return domain.PrivateMessageReactionsResult{}, fmt.Errorf("get message reactions boxes: %w", err)
	}
	res := domain.PrivateMessageReactionsResult{Messages: make([]domain.Message, 0, len(rows))}
	for _, row := range rows {
		if row.PeerType != string(req.Peer.Type) || row.PeerID != req.Peer.ID {
			continue
		}
		msg, err := messageFromIDRow(row)
		if err != nil {
			return domain.PrivateMessageReactionsResult{}, err
		}
		res.Messages = append(res.Messages, msg)
	}
	if err := s.enrichPrivateMessageReactions(ctx, s.db, req.OwnerUserID, res.Messages); err != nil {
		return domain.PrivateMessageReactionsResult{}, err
	}
	for _, msg := range res.Messages {
		if msg.Reactions != nil {
			res.Reactions = *msg.Reactions
			break
		}
	}
	return res, nil
}

type privateMessageReactionRow struct {
	messageSenderID  int64
	privateMessageID int64
	userID           int64
	reaction         domain.MessageReaction
	big              bool
	date             int
	chosenOrder      int
}

type privateMessageReactionKey struct {
	messageSenderID  int64
	privateMessageID int64
}

func (s *MessageStore) enrichPrivateMessageReactions(ctx context.Context, db sqlcgen.DBTX, viewerUserID int64, messages []domain.Message) error {
	if len(messages) == 0 {
		return nil
	}
	// poll enrichment 与 reactions 同点位挂载：所有私聊消息读路径都经过本函数，
	// poll media 的权威 closed/聚合/viewer 门控在此一并填充（见 message_polls.go）。
	if err := s.enrichPrivateMessagePolls(ctx, db, viewerUserID, messages); err != nil {
		return err
	}
	if err := s.enrichSavedMessageTags(ctx, db, messages); err != nil {
		return err
	}
	keySet := make(map[privateMessageReactionKey]struct{}, len(messages))
	senderIDs := make([]int64, 0, len(messages))
	privateIDs := make([]int64, 0, len(messages))
	for _, msg := range messages {
		if msg.OwnerUserID != 0 &&
			msg.Peer == (domain.Peer{Type: domain.PeerTypeUser, ID: msg.OwnerUserID}) {
			continue
		}
		if msg.UID == 0 || msg.From.ID == 0 {
			continue
		}
		key := privateMessageReactionKey{messageSenderID: msg.From.ID, privateMessageID: msg.UID}
		if _, ok := keySet[key]; ok {
			continue
		}
		keySet[key] = struct{}{}
		senderIDs = append(senderIDs, key.messageSenderID)
		privateIDs = append(privateIDs, key.privateMessageID)
	}
	if len(senderIDs) == 0 {
		return nil
	}
	rows, err := db.Query(ctx, `
WITH wanted AS (
  SELECT message_sender_id, private_message_id
  FROM unnest($1::bigint[], $2::bigint[]) AS w(message_sender_id, private_message_id)
)
SELECT r.message_sender_id, r.private_message_id, r.user_id, r.reaction_type, r.reaction_value, r.big, r.reaction_date, r.chosen_order
FROM private_message_reactions r
JOIN wanted w
  ON w.message_sender_id = r.message_sender_id
 AND w.private_message_id = r.private_message_id
ORDER BY r.message_sender_id ASC, r.private_message_id ASC, r.reaction_date DESC, r.user_id DESC, r.reaction_type ASC, r.reaction_value ASC`, senderIDs, privateIDs)
	if err != nil {
		return fmt.Errorf("load private message reactions: %w", err)
	}
	defer rows.Close()
	byMessage := make(map[privateMessageReactionKey][]privateMessageReactionRow)
	for rows.Next() {
		var (
			messageSenderID int64
			uid             int64
			userID          int64
			reactionType    string
			value           string
			big             bool
			date            int32
			chosenOrder     int32
		)
		if err := rows.Scan(&messageSenderID, &uid, &userID, &reactionType, &value, &big, &date, &chosenOrder); err != nil {
			return fmt.Errorf("scan private message reactions: %w", err)
		}
		reaction, ok := domain.MessageReactionFromValue(domain.MessageReactionType(reactionType), value)
		if !ok {
			continue
		}
		key := privateMessageReactionKey{messageSenderID: messageSenderID, privateMessageID: uid}
		byMessage[key] = append(byMessage[key], privateMessageReactionRow{
			messageSenderID:  messageSenderID,
			privateMessageID: uid,
			userID:           userID,
			reaction:         reaction,
			big:              big,
			date:             int(date),
			chosenOrder:      int(chosenOrder),
		})
	}
	if err := rows.Err(); err != nil {
		return fmt.Errorf("private message reactions rows: %w", err)
	}
	for i := range messages {
		key := privateMessageReactionKey{messageSenderID: messages[i].From.ID, privateMessageID: messages[i].UID}
		// chosen/My 是 per-viewer 字段，必须按该副本的 box owner 视角解析：
		// SetMessageReactions 会同时返回双方 owner 的副本，若统一用请求者视角，
		// 对端收到的 updateMessageReactions 会把发起者的 reaction 标成"自己选的"
		//（TDesktop 非 min 更新直接以 chosen_order 覆盖本地 my 状态）。
		viewpoint := messages[i].OwnerUserID
		if viewpoint == 0 {
			viewpoint = viewerUserID
		}
		reactions := privateMessageReactionsFromRows(byMessage[key], viewpoint)
		applyPrivateMessageReactionUnread(&reactions, messages[i])
		if len(reactions.Results) == 0 && len(reactions.Recent) == 0 {
			continue
		}
		messages[i].Reactions = &reactions
	}
	return nil
}

func applyPrivateMessageReactionUnread(reactions *domain.ChannelMessageReactions, msg domain.Message) {
	if reactions == nil || len(reactions.Recent) == 0 || msg.From.ID == 0 {
		return
	}
	for i := range reactions.Recent {
		reactions.Recent[i].SenderUserID = msg.From.ID
		if msg.ReactionUnread && msg.From.ID == msg.OwnerUserID && reactions.Recent[i].UserID != msg.OwnerUserID {
			reactions.Recent[i].Unread = true
		}
	}
}

func privateMessageReactionsFromRows(rows []privateMessageReactionRow, viewerUserID int64) domain.ChannelMessageReactions {
	out := domain.ChannelMessageReactions{
		CanSeeList: true,
		Results:    []domain.ChannelMessageReactionCount{},
		Recent:     []domain.ChannelMessagePeerReaction{},
	}
	if len(rows) == 0 {
		return out
	}
	type aggregate struct {
		reaction    domain.MessageReaction
		count       int
		chosenOrder int
		latestDate  int
	}
	aggregates := make(map[string]*aggregate)
	recent := make([]domain.ChannelMessagePeerReaction, 0, len(rows))
	for _, row := range rows {
		key := row.reaction.Key()
		item := aggregates[key]
		if item == nil {
			item = &aggregate{reaction: row.reaction}
			aggregates[key] = item
		}
		item.count++
		if row.userID == viewerUserID && row.chosenOrder > 0 && (item.chosenOrder == 0 || row.chosenOrder < item.chosenOrder) {
			item.chosenOrder = row.chosenOrder
		}
		if row.date > item.latestDate {
			item.latestDate = row.date
		}
		recent = append(recent, domain.ChannelMessagePeerReaction{
			UserID:      row.userID,
			Reaction:    row.reaction,
			Big:         row.big,
			My:          row.userID == viewerUserID,
			ChosenOrder: row.chosenOrder,
			Date:        row.date,
		})
	}
	items := make([]aggregate, 0, len(aggregates))
	for _, item := range aggregates {
		items = append(items, *item)
	}
	sort.Slice(items, func(i, j int) bool {
		if items[i].count != items[j].count {
			return items[i].count > items[j].count
		}
		if items[i].latestDate != items[j].latestDate {
			return items[i].latestDate > items[j].latestDate
		}
		return items[i].reaction.Key() < items[j].reaction.Key()
	})
	for _, item := range items {
		out.Results = append(out.Results, domain.ChannelMessageReactionCount{
			Reaction:    item.reaction,
			Count:       item.count,
			ChosenOrder: item.chosenOrder,
		})
	}
	sort.Slice(recent, func(i, j int) bool {
		if recent[i].Date != recent[j].Date {
			return recent[i].Date > recent[j].Date
		}
		if recent[i].UserID != recent[j].UserID {
			return recent[i].UserID > recent[j].UserID
		}
		return recent[i].Reaction.Key() < recent[j].Reaction.Key()
	})
	if len(recent) > domain.MaxChannelMessageReactionRecent {
		recent = recent[:domain.MaxChannelMessageReactionRecent]
	}
	out.Recent = recent
	return out
}

func writeMessageReactionsHash(h hash.Hash64, reactions *domain.ChannelMessageReactions) {
	if reactions == nil {
		_, _ = h.Write([]byte{0})
		return
	}
	var buf [16]byte
	if reactions.AsTags {
		_, _ = h.Write([]byte{1})
	} else {
		_, _ = h.Write([]byte{0})
	}
	for _, item := range reactions.Results {
		_, _ = h.Write([]byte(item.Reaction.Type))
		_, _ = h.Write([]byte{0})
		_, _ = h.Write([]byte(item.Reaction.Value()))
		_, _ = h.Write([]byte{0})
		binary.LittleEndian.PutUint32(buf[:4], uint32(item.Count))
		binary.LittleEndian.PutUint32(buf[4:8], uint32(item.ChosenOrder))
		_, _ = h.Write(buf[:8])
	}
	_, _ = h.Write([]byte{0xfe})
	for _, item := range reactions.Recent {
		_, _ = h.Write([]byte(item.Reaction.Type))
		_, _ = h.Write([]byte{0})
		_, _ = h.Write([]byte(item.Reaction.Value()))
		_, _ = h.Write([]byte{0})
		binary.LittleEndian.PutUint64(buf[:8], uint64(item.UserID))
		binary.LittleEndian.PutUint32(buf[8:12], uint32(item.Date))
		binary.LittleEndian.PutUint32(buf[12:16], uint32(item.ChosenOrder))
		_, _ = h.Write(buf[:])
	}
}