goMuffin/commands/learnedDataList.go

package commands

import (
	"context"
	"fmt"
	"strconv"
	"strings"

	"git.wh64.net/muffin/goMuffin/configs"
	"git.wh64.net/muffin/goMuffin/databases"
	"git.wh64.net/muffin/goMuffin/utils"
	"github.com/bwmarrin/discordgo"
	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo"
)

var (
	LIST_MIN_VALUE float64 = 10.0
	LIST_MAX_VALUE float64 = 100.0
)

var LearnedDataListCommand *Command = &Command{
	ApplicationCommand: &discordgo.ApplicationCommand{
		Type:        discordgo.ChatApplicationCommand,
		Name:        "리스트",
		Description: "당신이 가ㄹ르쳐준 지식을 나열해요.",
		Options: []*discordgo.ApplicationCommandOption{
			{
				Type:        discordgo.ApplicationCommandOptionString,
				Name:        "단어",
				Description: "해당 단어가 포함된 결과만 찾아요.",
				Required:    false,
			},
			{
				Type:        discordgo.ApplicationCommandOptionString,
				Name:        "대답",
				Description: "해당 대답이 포함된 결과만 찾아요.",
				Required:    false,
			},
			{
				Type:        discordgo.ApplicationCommandOptionInteger,
				Name:        "개수",
				Description: "한 페이지당 보여줄 지식의 데이터 양을 정해요.",
				MinValue:    &LIST_MIN_VALUE,
				MaxValue:    LIST_MAX_VALUE,
				Required:    false,
			},
		},
	},
	Aliases: []string{"list", "목록", "지식목록"},
	DetailedDescription: &DetailedDescription{
		Usage: fmt.Sprintf("%s리스트", configs.Config.Bot.Prefix),
		Examples: []string{
			fmt.Sprintf("%s리스트 ㅁㄴㅇㄹ", configs.Config.Bot.Prefix),
			fmt.Sprintf("%s리스트 단어:안녕", configs.Config.Bot.Prefix),
			fmt.Sprintf("%s리스트 대답:머핀", configs.Config.Bot.Prefix),
		},
	},
	Category: Chatting,
	MessageRun: func(ctx *MsgContext) {
		var length int

		filter := bson.D{{Key: "user_id", Value: ctx.Msg.Author.ID}}
		query := strings.Join(*ctx.Args, " ")

		if match := utils.RegexpLearnQueryCommand.FindStringSubmatch(query); match != nil {
			filter = append(filter, bson.E{
				Key: "command",
				Value: bson.M{
					"$regex": match[1],
				},
			})
		}

		if match := utils.RegexpLearnQueryResult.FindStringSubmatch(query); match != nil {
			filter = append(filter, bson.E{
				Key: "result",
				Value: bson.M{
					"$regex": match[1],
				},
			})
		}

		if match := utils.RegexpLearnQueryLength.FindStringSubmatch(query); match != nil {
			var err error
			length, err := strconv.Atoi(match[1])

			if err != nil {
				utils.NewMessageSender(ctx.Msg).
					AddEmbed(&discordgo.MessageEmbed{
						Title:       "❌ 오류",
						Description: "개수의 값은 숫자여야해요.",
						Color:       utils.EmbedFail,
					}).
					SetReply(true).
					Send()
				return
			}

			if float64(length) < LIST_MIN_VALUE {
				utils.NewMessageSender(ctx.Msg).
					AddEmbed(&discordgo.MessageEmbed{
						Title:       "❌ 오류",
						Description: fmt.Sprintf("개수의 값은 %d보다 커야해요.", int(LIST_MIN_VALUE)),
						Color:       utils.EmbedFail,
					}).
					SetReply(true).
					Send()
				return
			}

			if float64(length) > LIST_MAX_VALUE {
				utils.NewMessageSender(ctx.Msg).
					AddEmbed(&discordgo.MessageEmbed{
						Title:       "❌ 오류",
						Description: fmt.Sprintf("개수의 값은 %d보다 작아야해요.", int(LIST_MAX_VALUE)),
						Color:       utils.EmbedFail,
					}).
					SetReply(true).
					Send()
				return
			}
		}
		learnedDataListRun(ctx.Msg.Session, ctx.Msg, ctx.Msg.Author.GlobalName, ctx.Msg.Author.AvatarURL("512"), filter, length)
	},
	ChatInputRun: func(ctx *ChatInputContext) {
		ctx.Inter.DeferReply(true)

		var length int

		filter := bson.D{{Key: "user_id", Value: ctx.Inter.Member.User.ID}}

		if opt, ok := ctx.Inter.Options["단어"]; ok {
			filter = append(filter, bson.E{
				Key: "command",
				Value: bson.M{
					"$regex": opt.StringValue(),
				},
			})
		}

		if opt, ok := ctx.Inter.Options["대답"]; ok {
			filter = append(filter, bson.E{
				Key: "result",
				Value: bson.M{
					"$regex": opt.StringValue(),
				},
			})
		}

		if opt, ok := ctx.Inter.Options["개수"]; ok {
			length = int(opt.IntValue())
		}
		learnedDataListRun(ctx.Inter.Session, ctx.Inter, ctx.Inter.Member.User.GlobalName, ctx.Inter.Member.User.AvatarURL("512"), filter, length)
	},
}

func getDescriptions(data *[]databases.Learn, length int) (descriptions []string) {
	var builder strings.Builder
	MAX_LENGTH := 100

	if length == 0 {
		length = 25
	}

	tempDesc := []string{}

	for _, data := range *data {
		command := data.Command
		result := data.Result

		if runeCommand := []rune(command); len(runeCommand) >= MAX_LENGTH {
			command = string(runeCommand)[:MAX_LENGTH] + "..."
		}

		if runeResult := []rune(result); len(runeResult) >= MAX_LENGTH {
			result = string(runeResult[:MAX_LENGTH]) + "..."
		}

		tempDesc = append(tempDesc, fmt.Sprintf("- %s: %s\n", command, result))
	}

	for i, s := range tempDesc {
		builder.WriteString(s)

		if (i+1)%length == 0 {
			descriptions = append(descriptions, builder.String())
			builder.Reset()
		}
	}

	if builder.Len() > 0 {
		descriptions = append(descriptions, builder.String())
	}
	return
}

func learnedDataListRun(s *discordgo.Session, m any, globalName, avatarUrl string, filter bson.D, length int) {
	var data []databases.Learn

	cur, err := databases.Database.Learns.Find(context.TODO(), filter)
	if err != nil {
		if err == mongo.ErrNoDocuments {
			utils.NewMessageSender(m).
				AddEmbed(&discordgo.MessageEmbed{
					Title:       "❌ 오류",
					Description: "당신은 지식ㅇ을 가르쳐준 적이 없어요!",
					Color:       utils.EmbedFail,
				}).
				SetReply(true).
				Send()
			return
		}

		fmt.Println(err)

		utils.NewMessageSender(m).
			AddEmbed(&discordgo.MessageEmbed{
				Title:       "❌ 오류",
				Description: "데이터를 가져오는데 실패했어요.",
				Color:       utils.EmbedFail,
			}).
			SetReply(true).
			Send()
		return
	}

	defer cur.Close(context.TODO())

	cur.All(context.TODO(), &data)

	utils.NewPaginationEmbedBuilder(m, getDescriptions(&data, length)).
		SetEmbed(&discordgo.MessageEmbed{
			Title: fmt.Sprintf("%s님이 알려주신 지식", globalName),
			Color: utils.EmbedDefault,
			Thumbnail: &discordgo.MessageEmbedThumbnail{
				URL: avatarUrl,
			},
		}).
		SetDefaultDesc(utils.CodeBlock("md", fmt.Sprintf("# 총 %d개에요.\n", len(data))+"%s")).
		Start()
}