mastermind-bot/main.go

package main

import (
	"encoding/json"
	"log"
	"os"
	"os/signal"

	dg "github.com/bwmarrin/discordgo"
)

type Settings struct {
	Token   string     `json:"token"`
	Server  string     `json:"server"`
	Ranking [][]string `json:"ranking"`
}

var stg Settings

func init() {
	file, err := os.ReadFile("settings.json")
	if err != nil {
		log.Fatalf("Error while reading settings.json : %s", err)
	}
	if err := json.Unmarshal(file, &stg); err != nil {
		log.Fatalf("Error while reading settings.json : %s", err.Error())
	}
}

var descs = map[string]*dg.ApplicationCommand{
	"ping": &dg.ApplicationCommand{
		Name:        "ping",
		Description: "Replies with pong",
		DescriptionLocalizations: &map[dg.Locale]string{
			dg.French: "Répond pong",
		},
	},
	"sub": &dg.ApplicationCommand{
		Name:        "sub",
		Description: "Submit a guess",
		DescriptionLocalizations: &map[dg.Locale]string{
			dg.French: "Envoie un essais pour deviner",
		},
		// /!\ Make sure to update handler if other options are added
		// Guess options are added in init function
		// It's assumed in handler that there aren't other options
		Options: []*dg.ApplicationCommandOption{},
	},
}

func send_error(s *dg.Session, i *dg.Interaction, reason string) {
	s.InteractionRespond(i, &dg.InteractionResponse{
		Type: dg.InteractionResponseChannelMessageWithSource,
		Data: &dg.InteractionResponseData{
			Embeds: []*dg.MessageEmbed{
				{
					Title:       "⚠️ Something went wrong",
					Description: reason,
					Color:       0xFF0000,
				},
			},
		},
	})
}

// Handlers are separated because we need to be able to access descs
var handlers = map[string]func(*dg.Session, *dg.InteractionCreate){
	"ping": func(s *dg.Session, i *dg.InteractionCreate) {
		s.InteractionRespond(i.Interaction, &dg.InteractionResponse{
			Type: dg.InteractionResponseChannelMessageWithSource,
			Data: &dg.InteractionResponseData{
				Content: ":ping_pong: Pong !",
			},
		})
	},
	"sub": func(s *dg.Session, i *dg.InteractionCreate) {
		// red := 0
		// green := 0
		for _, opt := range descs["sub"].Options {
			val := i.ApplicationCommandData().GetOption(opt.Name)
			if val == nil {
				send_error(s, i.Interaction, "Missing option")
				return
			}
			if val.Type != dg.ApplicationCommandOptionUser {
				send_error(s, i.Interaction, "Invalid option type")
				return
			}
			// guess := val.Value.(string)

		}
	},
}

// Just in case...
var duplicateNames = []string{
	"bis", "ter", "quater", "quinquies", "sexies", "septies", "octies", "nonies", "decies", "undecies", "duodecies", "terdecies", "quaterdecies", "quindecies", "sexdecies", "septdecies", "octodecies", "novodecies", "vicies",
}

func init() {
	for _, r := range stg.Ranking {
		for i, _ := range r[1:] {
			opt := dg.ApplicationCommandOption{
				Type:        dg.ApplicationCommandOptionUser,
				Description: "Guess for student " + r[0],
				DescriptionLocalizations: map[dg.Locale]string{
					dg.French: "Supposition pour l'élève " + r[0],
				},
				Required: true,
			}
			if i == 0 {
				opt.Name = r[0]
			} else {
				opt.Name = r[0] + "_" + duplicateNames[i-1]
			}
			descs["sub"].Options = append(descs["sub"].Options, &opt)
		}
	}
}

func main() {
	s, _ := dg.New("Bot " + stg.Token)
	s.AddHandler(func(s *dg.Session, r *dg.Ready) {
		log.Printf("Ready!")
	})
	err := s.Open()
	if err != nil {
		log.Panicf("Failed to create session : %s", err)
	}
	s.AddHandler(func(s *dg.Session, i *dg.InteractionCreate) {
		if i.Type != dg.InteractionApplicationCommand {
			log.Printf("Warning : Received unknown interaction type (%s)", i.Type.String())
		}
		if h, ok := handlers[i.ApplicationCommandData().Name]; ok {
			h(s, i)
			log.Printf("Reveived command \"%s\"", i.ApplicationCommandData().Name)
		} else {
			log.Printf("Warning : Received unknown command \"%s\" (id:%s)", i.ApplicationCommandData().Name, i.ApplicationCommandData().ID)
		}
	})

	// Create commands
	for _, d := range descs {
		if _, err := s.ApplicationCommandCreate(s.State.User.ID, stg.Server, d); err != nil {
			log.Panicf("Failed to create command : %s", err)
		}
	}

	defer s.Close()
	stop := make(chan os.Signal, 1)
	signal.Notify(stop, os.Interrupt)
	log.Println("Press Ctrl+C to exit")
	<-stop
}