package logic

import (
	"context"
	"encoding/json"
	"fmt"
	"time"

	deliverentity "spark-server/internal/module/deliver/entity"
	"spark-server/internal/module/group/entity"
	msgentity "spark-server/internal/module/message/entity"
	"spark-server/internal/pkg/reply"
)

func (s *Service) notice(ctx context.Context, g *entity.Group, actorID int64, kind string, targets []int64) error {
	if s.msgs == nil || s.ids == nil || g == nil || g.ConversationID <= 0 {
		return nil
	}
	msgID, err := s.ids.NextID()
	if err != nil {
		return err
	}
	now := time.Now()
	content := msgentity.NewSystem(&msgentity.System{Kind: kind})
	raw, err := content.Marshal()
	if err != nil {
		return err
	}
	msg := &msgentity.Message{
		ID: msgID, ConversationID: g.ConversationID, SenderID: 0, GroupID: g.ID,
		ClientMsgID: fmt.Sprintf("sys:group:%d", msgID),
		Type:        msgentity.TypeSystem, Kind: msgentity.KindGroup, Content: raw,
		Status: msgentity.StatusNormal, CreatedAtMS: now.UnixMilli(),
	}
	if err := s.msgs.Create(ctx, msg); err != nil {
		return err
	}
	if err := s.repo.UpdateLastMsg(ctx, g.ConversationID, msgID, now.UnixMilli()); err != nil {
		return err
	}
	if s.queue == nil {
		return nil
	}
	to, err := s.repo.ListMemberIDs(ctx, g.ID)
	if err != nil || len(to) == 0 {
		to = append([]int64{actorID}, targets...)
	}
	return s.queue.Push(ctx, &deliverentity.Job{
		MsgID: msgID, Cmd: cmdMessage, ConversationID: g.ConversationID,
		FromUserID: actorID, ToUserIDs: to,
		Payload: reply.MustMarshal(reply.OK(groupPushBody{
			MsgID: msgID, ConversationID: g.ConversationID, SenderID: 0,
			MessageType: msgentity.TypeSystem, Content: raw, CreatedAt: now.UnixMilli(),
		})),
	})
}

type groupPushBody struct {
	MsgID          int64           `json:"msg_id"`
	ConversationID int64           `json:"conversation_id"`
	SenderID       int64           `json:"sender_id"`
	MessageType    msgentity.Type  `json:"message_type"`
	Content        json.RawMessage `json:"content"`
	CreatedAt      int64           `json:"created_at"`
}