cmd_messages.go

package main

import (
	"fmt"
	"net/url"
	"strings"

	"github.com/spf13/cobra"
)

func messagesCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "messages",
		Short: "Manage messages",
	}

	cmd.AddCommand(messagesListCmd())
	cmd.AddCommand(messagesSearchCmd())
	cmd.AddCommand(messagesSendCmd())
	cmd.AddCommand(messagesEditCmd())

	return cmd
}

func messagesListCmd() *cobra.Command {
	var cursor, direction string

	cmd := &cobra.Command{
		Use:   "list <chat-id>",
		Short: "List messages in a chat",
		Long: `List messages in a chat.

Returns messages sorted by timestamp with cursor-based pagination.

Examples:
  beeper messages list "!abc123:beeper.local"
  beeper messages list "!abc123:beeper.local" --direction before`,
		Args: cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			client, err := getClient()
			if err != nil {
				return err
			}

			params := map[string]interface{}{}
			if cursor != "" {
				params["cursor"] = cursor
			}
			if direction != "" {
				params["direction"] = direction
			}

			result, err := client.request("GET", "/v1/chats/"+url.PathEscape(cleanID(args[0]))+"/messages", params, nil)
			if err != nil {
				return err
			}
			outputResult(result)
			return nil
		},
	}

	cmd.Flags().StringVar(&cursor, "cursor", "", "Pagination cursor")
	cmd.Flags().StringVar(&direction, "direction", "", "Pagination direction: before or after")

	return cmd
}

func messagesSearchCmd() *cobra.Command {
	var query string
	var accountIDs, chatIDs, mediaTypes []string
	var chatType, sender string
	var after, before, cursor, direction string
	var includeMuted, excludeLowPriority bool
	var limit int

	cmd := &cobra.Command{
		Use:   "search",
		Short: "Search messages across chats",
		Long: `Search messages across chats.

Uses Beeper's message index for fast searching.

Examples:
  beeper messages search --query "meeting"
  beeper messages search --sender me --after "2025-01-01T00:00:00Z"
  beeper messages search --media-type image --media-type video`,
		RunE: func(cmd *cobra.Command, args []string) error {
			client, err := getClient()
			if err != nil {
				return err
			}

			trimmedQuery := strings.TrimSpace(query)
			if trimmedQuery == "" {
				hasOtherFilters := len(accountIDs) > 0 || len(chatIDs) > 0 || chatType != "" || sender != "" || len(mediaTypes) > 0 || after != "" || before != "" || cmd.Flags().Changed("include-muted") || cmd.Flags().Changed("exclude-low-priority") || limit > 0 || cursor != "" || direction != ""
				if !hasOtherFilters {
					return fmt.Errorf("query cannot be empty; provide --query or another filter")
				}
			}

			params := map[string]interface{}{}
			if trimmedQuery != "" {
				params["query"] = trimmedQuery
			}
			if len(accountIDs) > 0 {
				params["accountIDs"] = cleanIDs(accountIDs)
			}
			if len(chatIDs) > 0 {
				params["chatIDs"] = cleanIDs(chatIDs)
			}
			if chatType != "" {
				params["chatType"] = chatType
			}
			if sender != "" {
				params["sender"] = cleanID(sender)
			}
			if len(mediaTypes) > 0 {
				params["mediaTypes"] = mediaTypes
			}
			if after != "" {
				params["dateAfter"] = after
			}
			if before != "" {
				params["dateBefore"] = before
			}
			if cmd.Flags().Changed("include-muted") {
				params["includeMuted"] = includeMuted
			}
			if cmd.Flags().Changed("exclude-low-priority") {
				params["excludeLowPriority"] = excludeLowPriority
			}
			if limit > 0 {
				params["limit"] = limit
			}
			if cursor != "" {
				params["cursor"] = cursor
			}
			if direction != "" {
				params["direction"] = direction
			}

			result, err := client.request("GET", "/v1/messages/search", params, nil)
			if err != nil {
				return err
			}
			outputResult(result)
			return nil
		},
	}

	cmd.Flags().StringVarP(&query, "query", "q", "", "Search text")
	cmd.Flags().StringArrayVarP(&accountIDs, "account-ids", "a", nil, "Filter by account IDs")
	cmd.Flags().StringArrayVarP(&chatIDs, "chat-ids", "c", nil, "Filter by chat IDs")
	cmd.Flags().StringVar(&chatType, "chat-type", "", "Filter by chat type: group or single")
	cmd.Flags().StringVar(&sender, "sender", "", "Filter by sender: me, others, or user ID")
	cmd.Flags().StringArrayVar(&mediaTypes, "media-type", nil, "Filter by media type: any, video, image, link, file")
	cmd.Flags().StringVar(&after, "after", "", "Messages after this ISO datetime")
	cmd.Flags().StringVar(&before, "before", "", "Messages before this ISO datetime")
	cmd.Flags().BoolVar(&includeMuted, "include-muted", true, "Include muted chats")
	cmd.Flags().BoolVar(&excludeLowPriority, "exclude-low-priority", true, "Exclude low priority messages")
	cmd.Flags().IntVar(&limit, "limit", 0, "Max results")
	cmd.Flags().StringVar(&cursor, "cursor", "", "Pagination cursor")
	cmd.Flags().StringVar(&direction, "direction", "", "Pagination direction")

	return cmd
}

func messagesSendCmd() *cobra.Command {
	var replyTo, uploadID, filePath, attachmentType string
	var attachmentFilename, attachmentMimeType string
	var attachmentDuration float64
	var attachmentWidth, attachmentHeight int

	cmd := &cobra.Command{
		Use:   "send <chat-id> [text]",
		Short: "Send a message to a chat",
		Long: `Send a message to a chat with optional attachment.

Supports markdown formatting in the message text.
To send a file, either:
  1. Use --file to upload and send in one step
  2. Use --upload-id to reference a previously uploaded file

Attachment options:
  --type        Attachment type: gif, voiceNote, sticker (auto-detected if omitted)
  --duration    Duration in seconds (for audio/video)
  --filename    Override the filename
  --mime-type   Override the MIME type
  --width       Override image/video width
  --height      Override image/video height

Examples:
  # Send text message
  beeper messages send "!chatid:beeper.local" "Hello, world!"

  # Send with markdown
  beeper messages send "!chatid:beeper.local" "**Bold** and _italic_"

  # Send image with caption
  beeper messages send "!chatid:beeper.local" "Check this out!" --file /path/to/image.png

  # Send image only (no caption)
  beeper messages send "!chatid:beeper.local" --file /path/to/image.png

  # Send GIF
  beeper messages send "!chatid:beeper.local" --file /path/to/animation.gif --type gif

  # Send voice note
  beeper messages send "!chatid:beeper.local" --file /path/to/audio.ogg --type voiceNote --duration 15

  # Send sticker
  beeper messages send "!chatid:beeper.local" --file /path/to/sticker.webp --type sticker

  # Reply to a message
  beeper messages send "!chatid:beeper.local" "Reply text" --reply-to "msg456"

  # Use previously uploaded file
  beeper messages send "!chatid:beeper.local" "Here's the file" --upload-id "abc-123-def"`,
		Args: cobra.RangeArgs(1, 2),
		RunE: func(cmd *cobra.Command, args []string) error {
			client, err := getClient()
			if err != nil {
				return err
			}

			// Get text from args (optional when sending attachment only)
			text := ""
			if len(args) > 1 {
				text = args[1]
			}

			// If file path provided, upload first
			if filePath != "" {
				uploadResult, err := client.uploadFile("/v1/assets/upload", filePath)
				if err != nil {
					return err
				}
				if id, ok := uploadResult["uploadID"].(string); ok {
					uploadID = id
				}
			}

			body := map[string]interface{}{}
			if text != "" {
				body["text"] = text
			}
			if replyTo != "" {
				body["replyToMessageID"] = cleanID(replyTo)
			}
			if uploadID != "" {
				attachment := map[string]interface{}{
					"uploadID": uploadID,
				}
				if attachmentType != "" {
					attachment["type"] = attachmentType
				}
				if attachmentFilename != "" {
					attachment["fileName"] = attachmentFilename
				}
				if attachmentMimeType != "" {
					attachment["mimeType"] = attachmentMimeType
				}
				if attachmentDuration > 0 {
					attachment["duration"] = attachmentDuration
				}
				if attachmentWidth > 0 || attachmentHeight > 0 {
					size := map[string]interface{}{}
					if attachmentWidth > 0 {
						size["width"] = attachmentWidth
					}
					if attachmentHeight > 0 {
						size["height"] = attachmentHeight
					}
					attachment["size"] = size
				}
				body["attachment"] = attachment
			}

			result, err := client.request("POST", "/v1/chats/"+url.PathEscape(cleanID(args[0]))+"/messages", nil, body)
			if err != nil {
				return err
			}
			outputResult(result)
			return nil
		},
	}

	cmd.Flags().StringVarP(&replyTo, "reply-to", "r", "", "Message ID to reply to")
	cmd.Flags().StringVarP(&filePath, "file", "f", "", "File path to upload and attach")
	cmd.Flags().StringVar(&uploadID, "upload-id", "", "Upload ID from a previous assets upload")
	cmd.Flags().StringVar(&attachmentType, "type", "", "Attachment type: gif, voiceNote, or sticker")
	cmd.Flags().StringVar(&attachmentFilename, "filename", "", "Override attachment filename")
	cmd.Flags().StringVar(&attachmentMimeType, "mime-type", "", "Override attachment MIME type")
	cmd.Flags().Float64Var(&attachmentDuration, "duration", 0, "Duration in seconds (for audio/video)")
	cmd.Flags().IntVar(&attachmentWidth, "width", 0, "Override attachment width")
	cmd.Flags().IntVar(&attachmentHeight, "height", 0, "Override attachment height")

	return cmd
}

func messagesEditCmd() *cobra.Command {
	return &cobra.Command{
		Use:   "edit <chat-id> <message-id> <text>",
		Short: "Edit an existing message",
		Long: `Edit an existing message.

Examples:
  beeper messages edit "!abc123:beeper.local" "msg456" "Updated text"`,
		Args: cobra.ExactArgs(3),
		RunE: func(cmd *cobra.Command, args []string) error {
			client, err := getClient()
			if err != nil {
				return err
			}

			body := map[string]interface{}{
				"text": args[2],
			}

			result, err := client.request("PUT", "/v1/chats/"+url.PathEscape(cleanID(args[0]))+"/messages/"+url.PathEscape(cleanID(args[1])), nil, body)
			if err != nil {
				return err
			}
			outputResult(result)
			return nil
		},
	}
}