cheapo/cmd/cheapo/chatto.go

package main

import (
	"fmt"
	"os"
	"strings"

	"github.com/joho/godotenv"
	"github.com/spf13/cobra"

	"gogs.netdome.biz/paul/cheapo/internal/chatto"
	"gogs.netdome.biz/paul/cheapo/internal/game"
)

// loadEnv reads a .env file from the working directory if present (godotenv).
// Existing environment variables take precedence over .env values.
func loadEnv() {
	_ = godotenv.Load()
}

// chattoClientFromEnv builds a Chatto client from the CHATTO_TOKEN
// environment variable (or .env file); CHATTO_BASE_URL defaults to the public
// Chatto server (https://chat.chatto.run). The token is provided by the
// operator; this tool never fetches credentials itself.
func chattoClientFromEnv() (*chatto.Client, error) {
	loadEnv()
	base := os.Getenv("CHATTO_BASE_URL")
	if base == "" {
		base = "https://chat.chatto.run"
	}
	token := os.Getenv("CHATTO_TOKEN")
	if token == "" {
		return nil, fmt.Errorf("CHATTO_TOKEN must be set (base URL: %s, overridable via CHATTO_BASE_URL)", base)
	}
	return chatto.NewClient(base, token), nil
}

// formatGames renders games as a Chatto Markdown message body.
func formatGames(games []game.Game, upcoming bool) string {
	if len(games) == 0 {
		if upcoming {
			return "🗓 **Upcoming free games:** none announced."
		}
		return "🎮 **Current free games:** none on offer."
	}

	var b strings.Builder
	if upcoming {
		b.WriteString("## 🗓 Upcoming free games\n\n")
	} else {
		b.WriteString("## 🎮 Current free games\n\n")
	}

	// One table per store keeps columns uniform (dates only for epic).
	b.WriteString("| Game | Store | Period |\n")
	b.WriteString("|---|---|---|\n")
	for _, g := range games {
		period := "—"
		if g.Kind == "upcoming" && !g.StartDate.IsZero() && !g.EndDate.IsZero() {
			period = fmt.Sprintf("from %s, until %s",
				g.StartDate.Local().Format("02.01."),
				g.EndDate.Local().Format("02.01."))
		} else if !g.EndDate.IsZero() {
			period = "until " + g.EndDate.Local().Format("02.01.")
		}
		fmt.Fprintf(&b, "| **%s** | [%s](%s) | %s |\n",
			escapePipe(g.Title), g.Store, g.URL, period)
	}

	b.WriteString("\n_As of now — free from/until 17:00 Europe/Berlin each._")
	return b.String()
}

// escapePipe prevents table cell breakage via titles containing '|'.
func escapePipe(s string) string {
	return strings.ReplaceAll(s, "|", "\\|")
}

// chattoSendCmd posts the current free games to a Chatto room.
func chattoSendCmd() *cobra.Command {
	var (
		roomID   string
		upcoming bool
	)
	cmd := &cobra.Command{
		Use:   "chatto-send",
		Short: "Post current free games to a Chatto room",
		Long: `Fetches the free games and posts them as a message to the Chatto room.

Credentials come from the CHATTO_BASE_URL and CHATTO_TOKEN environment
variables (set by the operator, never fetched automatically).`,
		RunE: func(cmd *cobra.Command, args []string) error {
			ctx := cmd.Context()
			c, err := chattoClientFromEnv()
			if err != nil {
				return err
			}
			if roomID == "" {
				return fmt.Errorf("--room is required (room ID)")
			}

			var games []game.Game
			if upcoming {
				// Upcoming windows only exist for Epic.
				u := newEpic()
				games, err = u.GetUpcomingGames(ctx)
				if err != nil {
					return err
				}
			} else {
				games, err = fetchAll(ctx)
				if err != nil && len(games) == 0 {
					return err
				}
			}

			msg, err := c.CreateMessage(ctx, roomID, formatGames(games, upcoming), "")
			if err != nil {
				return err
			}
			fmt.Fprintf(cmd.OutOrStdout(), "✅ Sent: event %s\n", msg.EventID)
			return nil
		},
	}
	cmd.Flags().StringVar(&roomID, "room", "", "Chatto room ID (e.g. RtLrcOrNgvv3StA)")
	cmd.Flags().BoolVar(&upcoming, "upcoming", false, "Post upcoming instead of current free games (Epic only)")
	return cmd
}

// chattoRoomsCmd lists rooms visible to the token's user — verification helper.
func chattoRoomsCmd() *cobra.Command {
	return &cobra.Command{
		Use:   "chatto-rooms",
		Short: "List visible Chatto rooms (client verification)",
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := chattoClientFromEnv()
			if err != nil {
				return err
			}
			rooms, err := c.ListRooms(cmd.Context())
			if err != nil {
				return err
			}
			out := cmd.OutOrStdout()
			for _, r := range rooms {
				fmt.Fprintf(out, "%s\t%s\t%s\n", r.ID, r.Kind, r.Name)
			}
			fmt.Fprintf(out, "(%d rooms)\n", len(rooms))
			return nil
		},
	}
}