189 lines
4.5 KiB
Go
189 lines
4.5 KiB
Go
package main
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
|
|
logger "git.site.quack-lab.dev/dave/cylogger"
|
|
"github.com/bmatcuk/doublestar/v4"
|
|
lua "github.com/yuin/gopher-lua"
|
|
)
|
|
|
|
const meiliEndpoint = "https://meili.site.quack-lab.dev/"
|
|
const meiliIndex = "chatlog"
|
|
|
|
var debug *bool
|
|
|
|
func main() {
|
|
root := flag.String("root", ".", "Root workdir")
|
|
debug = flag.Bool("d", false, "Debug")
|
|
flag.Parse()
|
|
logger.InitFlag()
|
|
if *debug {
|
|
logger.SetLevel(logger.LevelDebug)
|
|
}
|
|
|
|
err := Init()
|
|
if err != nil {
|
|
logger.Error("Failed to initialize Meilisearch: %v", err)
|
|
return
|
|
}
|
|
|
|
logger.Info("Root: %q", *root)
|
|
cleanedRoot := strings.Replace(*root, "~", os.Getenv("HOME"), 1)
|
|
cleanedRoot, err = filepath.Abs(cleanedRoot)
|
|
if err != nil {
|
|
logger.Error("error getting absolute path: %v", err)
|
|
return
|
|
}
|
|
cleanedRoot = filepath.Clean(cleanedRoot)
|
|
cleanedRoot = strings.TrimSuffix(cleanedRoot, "/")
|
|
|
|
logger.Info("Looking for Heimdall.lua in %q", cleanedRoot)
|
|
matches, err := doublestar.Glob(os.DirFS(cleanedRoot), "**/Heimdall.lua")
|
|
if err != nil {
|
|
logger.Error("error matching Heimdall.lua: %v", err)
|
|
return
|
|
}
|
|
logger.Info("Found %d Heimdall.lua files.", len(matches))
|
|
if len(matches) == 0 {
|
|
logger.Info("No Heimdall.lua files found. Exiting.")
|
|
return
|
|
}
|
|
for i, match := range matches {
|
|
matches[i] = filepath.Join(cleanedRoot, match)
|
|
}
|
|
|
|
luaStates := loadLuaStates(matches)
|
|
chatMessages := loadChatMessages(luaStates)
|
|
|
|
// Save messages to Meilisearch
|
|
if err := AddMessages(chatMessages); err != nil {
|
|
logger.Error("Failed to save messages: %v", err)
|
|
return
|
|
}
|
|
logger.Info("Successfully saved %d messages", len(chatMessages))
|
|
}
|
|
|
|
func loadLuaStates(matches []string) *sync.Map {
|
|
wg := sync.WaitGroup{}
|
|
fileLuaStates := &sync.Map{}
|
|
for _, match := range matches {
|
|
wg.Add(1)
|
|
go func(path string) {
|
|
defer wg.Done()
|
|
log := logger.Default.WithPrefix(path)
|
|
L := lua.NewState()
|
|
|
|
filestat, err := os.Stat(path)
|
|
if err != nil {
|
|
log.Error("error getting file stats: %v", err)
|
|
return
|
|
}
|
|
log.Info("File size: %.2f MB", float64(filestat.Size())/1024/1024)
|
|
|
|
log.Info("Running Lua file")
|
|
if err := L.DoFile(path); err != nil {
|
|
log.Error("error executing Lua file %q: %v", path, err)
|
|
return
|
|
}
|
|
log.Info("Lua file loaded")
|
|
fileLuaStates.Store(path, L)
|
|
}(match)
|
|
}
|
|
wg.Wait()
|
|
return fileLuaStates
|
|
}
|
|
|
|
func loadChatMessages(luaStates *sync.Map) []ChatMessage {
|
|
var messages []ChatMessage
|
|
wg := sync.WaitGroup{}
|
|
messageChan := make(chan []ChatMessage, 100) // Buffer for concurrent processing
|
|
|
|
luaStates.Range(func(path, state any) bool {
|
|
wg.Add(1)
|
|
go func(path string, state *lua.LState) {
|
|
defer wg.Done()
|
|
log := logger.Default.WithPrefix(path)
|
|
fileMessages := loadStateChatMessages(state, log)
|
|
messageChan <- fileMessages
|
|
}(path.(string), state.(*lua.LState))
|
|
return true
|
|
})
|
|
|
|
// Close channel when all goroutines are done
|
|
go func() {
|
|
wg.Wait()
|
|
close(messageChan)
|
|
}()
|
|
|
|
// Collect all messages
|
|
for fileMessages := range messageChan {
|
|
messages = append(messages, fileMessages...)
|
|
}
|
|
|
|
return messages
|
|
}
|
|
|
|
func loadStateChatMessages(L *lua.LState, log *logger.Logger) []ChatMessage {
|
|
log.Info("Getting Heimdall_Chat")
|
|
heimdallChat := L.GetGlobal("Heimdall_Chat")
|
|
if heimdallChat.Type() == lua.LTNil {
|
|
log.Warning("Heimdall_Chat not found. Skipping file.")
|
|
return nil
|
|
}
|
|
|
|
chatTable, ok := heimdallChat.(*lua.LTable)
|
|
if !ok {
|
|
log.Warning("Heimdall_Chat is not a table. Skipping file.")
|
|
return nil
|
|
}
|
|
|
|
var messages []ChatMessage
|
|
chatTable.ForEach(func(_, value lua.LValue) {
|
|
chatStr := value.String()
|
|
// Remove quotes and trailing comma if present
|
|
chatStr = strings.Trim(chatStr, "\", ")
|
|
|
|
// Parse the chat message
|
|
message, err := parseChatMessage(chatStr)
|
|
if err != nil {
|
|
log.Warning("Invalid chat format: %s", chatStr)
|
|
return
|
|
}
|
|
messages = append(messages, message)
|
|
})
|
|
|
|
log.Info("Loaded %d chat messages", len(messages))
|
|
return messages
|
|
}
|
|
|
|
func parseChatMessage(chatStr string) (ChatMessage, error) {
|
|
// Split by pipe - we expect 6 parts (5 pipes)
|
|
parts := strings.Split(chatStr, "|")
|
|
if len(parts) != 6 {
|
|
return ChatMessage{}, fmt.Errorf("invalid message format: %s", chatStr)
|
|
}
|
|
|
|
timestamp := parts[0]
|
|
event := parts[1]
|
|
sender := parts[2]
|
|
msg := parts[3]
|
|
language := parts[4]
|
|
channel := parts[5]
|
|
|
|
return ChatMessage{
|
|
MessageHash: GenerateMessageHash(timestamp, event, sender, msg, language, channel),
|
|
Timestamp: timestamp,
|
|
Event: event,
|
|
Sender: sender,
|
|
Msg: msg,
|
|
Language: language,
|
|
Channel: channel,
|
|
}, nil
|
|
}
|