EngiBot/main.go

package main

import (
    "flag"
    "fmt"
    "log"
    "os"
    "os/signal"
    "syscall"
    "strings"
    "regexp"
    "context"
    "time"

    "github.com/bwmarrin/discordgo"
    "github.com/wader/goutubedl"
    "mvdan.cc/xurls/v2" // Peak lazy
)

func main() {
    // Variables used for command line parameters
    var (
        commands = []*discordgo.ApplicationCommand {
            {
                Name: "ping",
                Description: "Hopefully replies with pong or else I'll be sad.",
            },
            {
                Name: "sping",
                Description: "Hopefully replies with pong silently or else I'll be sad.",
            },
            {
                Name: "slowping",
                Description: "Hopefully replies with pong 10 seconds later or else I'll be sad.",
            },
        }
        commandHandlers = map[string]func(s *discordgo.Session, i *discordgo.InteractionCreate) {
            "ping": func(s *discordgo.Session, i *discordgo.InteractionCreate) {
                if i.Interaction.Member != nil {
                    log.Printf("%s#%s invoked ping command", i.Interaction.Member.User.Username, i.Interaction.Member.User.Discriminator)
                } else if i.Interaction.User != nil {
                    log.Printf("%s#%s invoked ping command", i.Interaction.User.Username, i.Interaction.User.Discriminator)
                }
                s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
                    Type: discordgo.InteractionResponseChannelMessageWithSource,
                    Data: &discordgo.InteractionResponseData{
                        //Flags:   1 << 6, // Only lets issuer see initial response
                        Content: "Pong!",
                    },
                })
            },

            "sping": func(s *discordgo.Session, i *discordgo.InteractionCreate) {
                if i.Interaction.Member != nil {
                    log.Printf("%s#%s invoked ping command", i.Interaction.Member.User.Username, i.Interaction.Member.User.Discriminator)
                } else if i.Interaction.User != nil {
                    log.Printf("%s#%s invoked ping command", i.Interaction.User.Username, i.Interaction.User.Discriminator)
                }
                s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
                    Type: discordgo.InteractionResponseChannelMessageWithSource,
                    Data: &discordgo.InteractionResponseData{
                        Flags:   1 << 6, // Only lets issuer see initial response
                        Content: "Pong!",
                    },
                })
            },

            "slowping": func(s *discordgo.Session, i *discordgo.InteractionCreate) {
                if i.Interaction.Member != nil {
                    log.Printf("%s#%s invoked ping command", i.Interaction.Member.User.Username, i.Interaction.Member.User.Discriminator)
                } else if i.Interaction.User != nil {
                    log.Printf("%s#%s invoked ping command", i.Interaction.User.Username, i.Interaction.User.Discriminator)
                }
                s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
                    Type: discordgo.InteractionResponseChannelMessageWithSource,
                    Data: &discordgo.InteractionResponseData{
                        //Flags:   1 << 6, // Only lets issuer see initial response
                        Content: "No problem.",
                    },
                })

                time.Sleep(time.Second * 10)

                _, err := s.FollowupMessageCreate(i.Interaction, true, &discordgo.WebhookParams{
                    Content: "Pong!",
                })
                if err != nil {
                    log.Println(err)
                }
            },
        }
    )

    // Lazyinator 9001
    var (
        s *discordgo.Session
        err error
    )

    // Bot params
    var (
        GuildID        = flag.String("guild", "", "Test guild ID. If not passed - bot registers commands globally")
        BotToken       = flag.String("token", "", "Bot access token")
    )

    flag.Parse()

    s, err = discordgo.New("Bot " + *BotToken)
    if err != nil {
        fmt.Println("error creating Discord session,", err)
        return
    }

    s.AddHandler(func(s *discordgo.Session, i *discordgo.InteractionCreate) {
        if h, ok := commandHandlers[i.ApplicationCommandData().Name]; ok {
            h(s, i)
        }
    })

    // Message to print when bot is ready to go
    s.AddHandler(func(s *discordgo.Session, r *discordgo.Ready) {
        log.Printf("Logged in as: %v#%v\n", s.State.User.Username, s.State.User.Discriminator)
    })

    // Register the messageCreate func as a callback for MessageCreate events.
    s.AddHandler(messageCreate)

    // In this example, we only care about receiving message events.
    //s.Identify.Intents = discordgo.IntentsGuildMessages

    // Open a websocket connection to Discord and begin listening.
    err = s.Open()
    if err != nil {
        fmt.Println("error opening connection,", err)
        return
    }

    log.Println("Adding commands...")

    registeredCommands, err := s.ApplicationCommandBulkOverwrite(s.State.User.ID, *GuildID, commands)
    if err != nil {
        log.Panic(err)
    }

    // Just incase
    defer s.Close()

    // Wait here until CTRL-C or other term signal is received.
    log.Println("Bot is running.  Press CTRL-C to exit.")
    sc := make(chan os.Signal, 1)
    signal.Notify(sc, syscall.SIGINT, syscall.SIGTERM, os.Interrupt, os.Kill)
    <-sc

    log.Printf("Signal received, closing bot...")
    // Cleanly close down the Discord session.
    for _, v := range registeredCommands {
        err := s.ApplicationCommandDelete(s.State.User.ID, *GuildID, v.ID)
        if err != nil {
            log.Panicf("Cannot delete '%v' command: %v", v.Name, err)
        }
    }
    s.Close()
}

// This function will be called (due to AddHandler above) every time a new
// message is created on any channel that the authenticated bot has access to.
func messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
    // Ignore all messages created by the bot itself
    // This isn't required in this specific example but it's a good practice.
    if m.Author.ID == s.State.User.ID {
        return
    }
    /*
    // If the message is "ping" reply with "Pong!"
    if m.Content == "ping" {
        s.ChannelMessageSend(m.ChannelID, "Pong!")
    }

    // If the message is "pong" reply with "Ping!"
    if m.Content == "pong" {
        s.ChannelMessageSend(m.ChannelID, "Ping!")
    }
    */

    //log.Printf("[%s] %s#%s: %s", m.ID, m.Author.Username, m.Author.Discriminator, m.Content)

    rxStrict := xurls.Strict()
    urls := rxStrict.FindAllString(m.Content, -1)
    if len(urls) > 0 {
        message := discordgo.MessageSend {
            Content: "Woah there partner! I detect some services that don't embed very well in Discord. Let me help you with that!\n",
            Reference: m.Reference(),
            Files: []*discordgo.File{},
        }

        log.Println("URLs detected!")

        respond := false

        for _, url := range urls {
            if output, _ := regexp.MatchString("http.*twitter.com/.*/status", url); output {
                log.Println("Cringe twitter post detected.")

                goutubedl.Path = "yt-dlp"
                result, err := goutubedl.New(context.Background(), url, goutubedl.Options{})
                if err != nil {
                    // Probably no videos in it, don't care
                    log.Println(err)
                    //s.ChannelMessageSend(m.ChannelID, err.Error())
                    continue
                }

                // Get rid of the stupid short URL that Shitter appends to everything
                message.Content = message.Content + fmt.Sprintf("\"%s\"\n", strings.Trim(regexp.MustCompile("https://t.co/.*").ReplaceAllString(result.Info.Description, ""), " ")) // Still ugly

                var choice goutubedl.Format
                for i := len(result.Formats())-1; i >= 0; i-- {
                    size := result.Formats()[i].FilesizeApprox
                    if size < 8*1024*1024 {
                        choice = result.Formats()[i]
                        log.Printf("Choice: %s | Size: %fM\n", choice.FormatID, size/1024/1024)
                        break
                    }
                }

                downloadResult, err := result.Download(context.Background(), choice.FormatID)
                if err != nil {
                    log.Println(err)
                    //s.ChannelMessageSend(m.ChannelID, err.Error())
                    continue
                }

                message.Files = append(message.Files, &discordgo.File {
                    Name: fmt.Sprintf("%s.%s", result.Info.ID, choice.Ext),
                    ContentType: "text/plain", // This is of course not true, but Discord doesn't give a shit
                    Reader: downloadResult,
                })

                respond = true

                defer downloadResult.Close()
            }
        }
        if respond {
            if message, err := s.ChannelMessageSendComplex(m.ChannelID, &message); err != nil {
                log.Println(message)
                log.Println(err)
            } else {
                log.Printf("Successfully responded to %s", m.ID)
            }
        }
    }
}