BigChef/main.go

package main

import (
	"flag"
	"fmt"
	"os"
	"sort"
	"sync"
	"time"

	"cook/processor"
	"cook/utils"

	"github.com/go-git/go-git/v5"
	"gopkg.in/yaml.v3"

	logger "git.site.quack-lab.dev/dave/cylogger"
)

type GlobalStats struct {
	TotalMatches            int
	TotalModifications      int
	ProcessedFiles          int
	FailedFiles             int
	ModificationsPerCommand sync.Map
}

var (
	repo     *git.Repository
	worktree *git.Worktree
	stats    GlobalStats = GlobalStats{
		ModificationsPerCommand: sync.Map{},
	}
)

func main() {
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "Usage: %s [options] <pattern> <lua_expression> <...files_or_globs>\n", os.Args[0])
		fmt.Fprintf(os.Stderr, "\nOptions:\n")
		fmt.Fprintf(os.Stderr, "  -git\n")
		fmt.Fprintf(os.Stderr, "        Use git to manage files\n")
		fmt.Fprintf(os.Stderr, "  -reset\n")
		fmt.Fprintf(os.Stderr, "        Reset files to their original state\n")
		fmt.Fprintf(os.Stderr, "  -loglevel string\n")
		fmt.Fprintf(os.Stderr, "        Set logging level: ERROR, WARNING, INFO, DEBUG, TRACE (default \"INFO\")\n")
		fmt.Fprintf(os.Stderr, "\nExamples:\n")
		fmt.Fprintf(os.Stderr, "  Regex mode (default):\n")
		fmt.Fprintf(os.Stderr, "    %s \"<value>(\\d+)</value>\" \"*1.5\" data.xml\n", os.Args[0])
		fmt.Fprintf(os.Stderr, "\nNote: v1, v2, etc. are used to refer to capture groups as numbers.\n")
		fmt.Fprintf(os.Stderr, "      s1, s2, etc. are used to refer to capture groups as strings.\n")
		fmt.Fprintf(os.Stderr, "      Helper functions: num(str) converts string to number, str(num) converts number to string\n")
		fmt.Fprintf(os.Stderr, "      is_number(str) checks if a string is numeric\n")
		fmt.Fprintf(os.Stderr, "      If expression starts with an operator like *, /, +, -, =, etc., v1 is automatically prepended\n")
		fmt.Fprintf(os.Stderr, "      You can use any valid Lua code, including if statements, loops, etc.\n")
		fmt.Fprintf(os.Stderr, "      Glob patterns are supported for file selection (*.xml, data/**.xml, etc.)\n")
	}
	// TODO: Fix bed shitting when doing *.yml in barotrauma directory
	flag.Parse()
	args := flag.Args()

	logger.InitFlag()
	logger.Info("Initializing with log level: %s", logger.GetLevel().String())

	// The plan is:
	// Load all commands
	commands, err := utils.LoadCommands(args)
	if err != nil || len(commands) == 0 {
		logger.Error("Failed to load commands: %v", err)
		CreateExampleConfig()
		flag.Usage()
		return
	}

	if *utils.Filter != "" {
		logger.Info("Filtering commands by name: %s", *utils.Filter)
		commands = utils.FilterCommands(commands, *utils.Filter)
		logger.Info("Filtered %d commands", len(commands))
	}

	// Then aggregate all the globs and deduplicate them
	globs := utils.AggregateGlobs(commands)
	logger.Debug("Aggregated %d globs before deduplication", utils.CountGlobsBeforeDedup(commands))

	for _, command := range commands {
		logger.Trace("Command: %s", command.Name)
		logger.Trace("Regex: %s", command.Regex)
		logger.Trace("Files: %v", command.Files)
		logger.Trace("Lua: %s", command.Lua)
		logger.Trace("Git: %t", command.Git)
		logger.Trace("Reset: %t", command.Reset)
		logger.Trace("Isolate: %t", command.Isolate)
		logger.Trace("LogLevel: %s", command.LogLevel)
	}

	// Resolve all the files for all the globs
	logger.Info("Found %d unique file patterns", len(globs))
	files, err := utils.ExpandGLobs(globs)
	if err != nil {
		logger.Error("Failed to expand file patterns: %v", err)
		return
	}
	logger.Info("Found %d files to process", len(files))

	// Somehow connect files to commands via globs..
	// For each file check every glob of every command
	// Maybe memoize this part
	// That way we know what commands affect what files
	associations, err := utils.AssociateFilesWithCommands(files, commands)
	if err != nil {
		logger.Error("Failed to associate files with commands: %v", err)
		return
	}

	// Then for each file run all commands associated with the file
	workers := make(chan struct{}, *utils.ParallelFiles)
	wg := sync.WaitGroup{}

	// Add performance tracking
	startTime := time.Now()
	var fileMutex sync.Mutex

	// Create a map to store loggers for each command
	commandLoggers := make(map[string]*logger.Logger)
	for _, command := range commands {
		// Create a named logger for each command
		cmdName := command.Name
		if cmdName == "" {
			// If no name is provided, use a short version of the regex pattern
			if len(command.Regex) > 20 {
				cmdName = command.Regex[:17] + "..."
			} else {
				cmdName = command.Regex
			}
		}

		// Parse the log level for this specific command
		cmdLogLevel := logger.ParseLevel(command.LogLevel)

		// Create a logger with the command name as a field
		commandLoggers[command.Name] = logger.WithField("command", cmdName)
		commandLoggers[command.Name].SetLevel(cmdLogLevel)

		logger.Debug("Created logger for command %q with log level %s", cmdName, cmdLogLevel.String())
	}

	for file, association := range associations {
		workers <- struct{}{}
		wg.Add(1)
		logger.SafeGoWithArgs(func(args ...interface{}) {
			defer func() { <-workers }()
			defer wg.Done()

			// Track per-file processing time
			fileStartTime := time.Now()

			fileData, err := os.ReadFile(file)
			if err != nil {
				logger.Error("Failed to read file %q: %v", file, err)
				return
			}
			fileDataStr := string(fileData)

			fileDataStr, err = RunIsolateCommands(association, file, fileDataStr, &fileMutex)
			if err != nil {
				logger.Error("Failed to run isolate commands for file %q: %v", file, err)
				return
			}

			fileDataStr, err = RunOtherCommands(file, fileDataStr, association, &fileMutex, commandLoggers)
			if err != nil {
				logger.Error("Failed to run other commands for file %q: %v", file, err)
				return
			}

			err = os.WriteFile(file, []byte(fileDataStr), 0644)
			if err != nil {
				logger.Error("Failed to write file %q: %v", file, err)
				return
			}

			logger.Debug("File %q processed in %v", file, time.Since(fileStartTime))
		}, file, commands)
	}
	wg.Wait()

	processingTime := time.Since(startTime)
	logger.Info("Processing completed in %v", processingTime)
	if stats.ProcessedFiles > 0 {
		logger.Info("Average time per file: %v", processingTime/time.Duration(stats.ProcessedFiles))
	}

	// TODO: Also give each command its own logger, maybe prefix it with something... Maybe give commands a name?
	// Do that with logger.WithField("loglevel", level.String())
	// Since each command also has its own log level
	// TODO: Maybe even figure out how to run individual commands...?
	// TODO: What to do with git? Figure it out ....

	// if *gitFlag {
	// 	logger.Info("Git integration enabled, setting up git repository")
	// 	err := setupGit()
	// 	if err != nil {
	// 		logger.Error("Failed to setup git: %v", err)
	// 		fmt.Fprintf(os.Stderr, "Error setting up git: %v\n", err)
	// 		return
	// 	}
	// }

	// logger.Debug("Expanding file patterns")
	// files, err := expandFilePatterns(filePatterns)
	// if err != nil {
	// 	logger.Error("Failed to expand file patterns: %v", err)
	// 	fmt.Fprintf(os.Stderr, "Error expanding file patterns: %v\n", err)
	// 	return
	// }

	// if *gitFlag {
	// 	logger.Info("Cleaning up git files before processing")
	// 	err := cleanupGitFiles(files)
	// 	if err != nil {
	// 		logger.Error("Failed to cleanup git files: %v", err)
	// 		fmt.Fprintf(os.Stderr, "Error cleaning up git files: %v\n", err)
	// 		return
	// 	}
	// }
	// if *resetFlag {
	// 	logger.Info("Files reset to their original state, nothing more to do")
	// 	log.Printf("Files reset to their original state, nothing more to do")
	// 	return
	// }

	// Print summary
	if stats.TotalModifications == 0 {
		logger.Warning("No modifications were made in any files")
	} else {
		logger.Info("Operation complete! Modified %d values in %d/%d files",
			stats.TotalModifications, stats.ProcessedFiles, stats.ProcessedFiles+stats.FailedFiles)
		sortedCommands := []string{}
		stats.ModificationsPerCommand.Range(func(key, value interface{}) bool {
			sortedCommands = append(sortedCommands, key.(string))
			return true
		})
		sort.Strings(sortedCommands)

		for _, command := range sortedCommands {
			count, _ := stats.ModificationsPerCommand.Load(command)
			if count.(int) > 0 {
				logger.Info("\tCommand %q made %d modifications", command, count)
			} else {
				logger.Warning("\tCommand %q made no modifications", command)
			}
		}
	}
}

func CreateExampleConfig() {
	commands := []utils.ModifyCommand{
		{
			Name:     "DoubleNumericValues",
			Regex:    "<value>(\\d+)</value>",
			Lua:      "v1 * 2",
			Files:    []string{"data/*.xml"},
			LogLevel: "INFO",
		},
		{
			Name:     "UpdatePrices",
			Regex:    "price=\"(\\d+)\"",
			Lua:      "if num(v1) < 100 then return v1 * 1.5 else return v1 end",
			Files:    []string{"items/*.xml", "shop/*.xml"},
			Git:      true,
			LogLevel: "DEBUG",
		},
		{
			Name:     "IsolatedTagUpdate",
			Regex:    "<tag>(.*?)</tag>",
			Lua:      "string.upper(s1)",
			Files:    []string{"config.xml"},
			Isolate:  true,
			NoDedup:  true,
			LogLevel: "TRACE",
		},
	}

	data, err := yaml.Marshal(commands)
	if err != nil {
		logger.Error("Failed to marshal example config: %v", err)
		return
	}

	err = os.WriteFile("example_cook.yml", data, 0644)
	if err != nil {
		logger.Error("Failed to write example_cook.yml: %v", err)
		return
	}

	logger.Info("Wrote example_cook.yml")
}

func RunOtherCommands(file string, fileDataStr string, association utils.FileCommandAssociation, fileMutex *sync.Mutex, commandLoggers map[string]*logger.Logger) (string, error) {
	// Aggregate all the modifications and execute them
	modifications := []utils.ReplaceCommand{}
	for _, command := range association.Commands {
		// Use command-specific logger if available, otherwise fall back to default logger
		cmdLogger := logger.Default
		if cmdLog, ok := commandLoggers[command.Name]; ok {
			cmdLogger = cmdLog
		}

		cmdLogger.Info("Processing file %q with command %q", file, command.Regex)
		newModifications, err := processor.ProcessRegex(fileDataStr, command, file)
		if err != nil {
			return fileDataStr, fmt.Errorf("failed to process file %q with command %q: %w", file, command.Regex, err)
		}
		modifications = append(modifications, newModifications...)
		// It is not guranteed that all the commands will be executed...
		// TODO: Make this better
		// We'd have to pass the map to executemodifications or something...
		count, ok := stats.ModificationsPerCommand.Load(command.Name)
		if !ok {
			count = 0
		}
		stats.ModificationsPerCommand.Store(command.Name, count.(int)+len(newModifications))

		cmdLogger.Debug("Command %q generated %d modifications", command.Name, len(newModifications))
	}

	if len(modifications) == 0 {
		logger.Info("No modifications found for file %q", file)
		return fileDataStr, nil
	}

	// Sort commands in reverse order for safe replacements
	var count int
	fileDataStr, count = utils.ExecuteModifications(modifications, fileDataStr)

	fileMutex.Lock()
	stats.ProcessedFiles++
	stats.TotalModifications += count
	fileMutex.Unlock()

	logger.Info("Executed %d modifications for file %q", count, file)
	return fileDataStr, nil
}

func RunIsolateCommands(association utils.FileCommandAssociation, file string, fileDataStr string, fileMutex *sync.Mutex) (string, error) {
	for _, isolateCommand := range association.IsolateCommands {
		logger.Info("Processing file %q with isolate command %q", file, isolateCommand.Regex)
		modifications, err := processor.ProcessRegex(fileDataStr, isolateCommand, file)
		if err != nil {
			return fileDataStr, fmt.Errorf("failed to process file %q with isolate command %q: %w", file, isolateCommand.Regex, err)
		}

		if len(modifications) == 0 {
			logger.Warning("No modifications found for file %q", file)
			return fileDataStr, nil
		}

		var count int
		fileDataStr, count = utils.ExecuteModifications(modifications, fileDataStr)

		fileMutex.Lock()
		stats.ProcessedFiles++
		stats.TotalModifications += count
		fileMutex.Unlock()

		logger.Info("Executed %d isolate modifications for file %q", count, file)
	}
	return fileDataStr, nil
}