dcbot/bot/bot.go

package bot

import (
	"fmt"
	"log"

	"github.com/Penguin-71630/meme-bot-frontend-dc/api"
	"github.com/Penguin-71630/meme-bot-frontend-dc/config"
	"github.com/bwmarrin/discordgo"
)

type Bot struct {
	session   *discordgo.Session
	config    *Config
	apiClient *api.Client
}

type Config struct {
	Token     string
	APIClient *api.Client
}

func New(cfg *config.Config) (*Bot, error) {
	// Create Discord session
	session, err := discordgo.New("Bot " + cfg.DiscordToken)
	if err != nil {
		return nil, fmt.Errorf("error creating Discord session: %w", err)
	}

	// Create API client
	apiClient := api.NewClient(cfg.APIBaseURL)

	bot := &Bot{
		session:   session,
		apiClient: apiClient,
		config: &Config{
			Token:     cfg.DiscordToken,
			APIClient: apiClient,
		},
	}

	// Register handlers
	bot.registerHandlers()

	// Set intents - only need guild messages for the ciallo listener
	session.Identify.Intents = discordgo.IntentsGuildMessages | discordgo.IntentsDirectMessages | discordgo.IntentsMessageContent

	return bot, nil
}

func (b *Bot) registerSlashCommands(guildID string) error {
	commands := []*discordgo.ApplicationCommand{
		{
			Name:        "ping",
			Description: "Check if bot is responsive",
		},
		{
			Name:        "greet",
			Description: "Get a friendly greeting",
		},
		{
			Name:        "echo",
			Description: "Bot repeats what you say",
			Options: []*discordgo.ApplicationCommandOption{
				{
					Type:        discordgo.ApplicationCommandOptionString,
					Name:        "message",
					Description: "Message to echo",
					Required:    true,
				},
			},
		},
		{
			Name:        "web",
			Description: "Get a login link to the web interface",
		},
	}

	for _, cmd := range commands {
		_, err := b.session.ApplicationCommandCreate(b.session.State.User.ID, guildID, cmd)
		if err != nil {
			return fmt.Errorf("cannot create command %s: %w", cmd.Name, err)
		}
	}

	return nil
}

func (b *Bot) clearSlashCommands(guildID string) error {
	commands, err := b.session.ApplicationCommands(b.session.State.User.ID, guildID)
	if err != nil {
		return err
	}

	for _, cmd := range commands {
		err := b.session.ApplicationCommandDelete(b.session.State.User.ID, guildID, cmd.ID)
		if err != nil {
			log.Printf("Failed to delete command %s: %v", cmd.Name, err)
		}
	}
	return nil
}

func (b *Bot) registerHandlers() {
	b.session.AddHandler(b.onReady)
	b.session.AddHandler(b.onMessageCreate)
	b.session.AddHandler(b.onInteractionCreate)
}

func (b *Bot) onReady(s *discordgo.Session, event *discordgo.Ready) {
	log.Printf("Logged in as: %v#%v", s.State.User.Username, s.State.User.Discriminator)

	// For development: set your guild ID here for instant updates
	// For production: use "" for global commands
	guildID := "1377176828833169468" // Replace with your Discord server ID for faster testing

	// clear slash commands
	if err := b.clearSlashCommands(guildID); err != nil {
		log.Printf("Error clearing slash commands: %v", err)
	}

	// Register slash commands
	if err := b.registerSlashCommands(guildID); err != nil {
		log.Printf("Error registering slash commands: %v", err)
	}

	// Set bot status
	err := s.UpdateGameStatus(0, "/ping to check status")
	if err != nil {
		log.Printf("Error setting status: %v", err)
	}
}

func (b *Bot) onInteractionCreate(s *discordgo.Session, i *discordgo.InteractionCreate) {
	if i.Type != discordgo.InteractionApplicationCommand {
		return
	}

	switch i.ApplicationCommandData().Name {
	case "ping":
		b.handleSlashPing(s, i)
	case "greet":
		b.handleSlashGreet(s, i)
	case "echo":
		b.handleSlashEcho(s, i)
	case "web":
		b.handleSlashWeb(s, i)
	}
}

func (b *Bot) Start() error {
	if err := b.session.Open(); err != nil {
		return fmt.Errorf("error opening connection: %w", err)
	}
	return nil
}

func (b *Bot) Stop() {
	if b.session != nil {
		b.session.Close()
	}
}