inline.go

package main

import (
	"bytes"
	_ "embed"
	"fmt"
	"regexp"
	"strings"
)

// Template markers
const (
	markerInlineBody = "// {{INLINE_BODY}}"
	markerPipeBefore = "// {{PIPE_BEFORE}}"
	markerPipeBody   = "// {{PIPE_BODY}}"
	markerPipeAfter  = "// {{PIPE_AFTER}}"
	markerBatchBody  = "// {{BATCH_BODY}}"
	markerFields     = "{{FIELDS_EXPR}}"
	markerParallelN  = "{{PARALLEL_N}}"
)

//go:embed script.go.template
var simpleTmpl []byte

//go:embed pipe.go.template
var pipeTmpl []byte

//go:embed batch.go.template
var batchTmpl []byte

//go:embed parallel.go.template
var parallelTmpl []byte

// InlineMode describes which template to use.
type InlineMode int

const (
	ModeSimple InlineMode = iota // no magic vars
	ModePipe                     // x/line/i/f referenced → per-line loop
	ModeBatch                    // only lines referenced → pre-load all, no loop
)

// pipeVars are magic variables that trigger per-line loop mode.
var pipeVarNames = []string{"x", "line", "i", "idx", "index", "f", "fields"}

// batchVarNames trigger batch mode (all lines at once).
var batchVarNames = []string{"lines"}

// DetectInlineMode inspects the code snippet for magic variable references.
func DetectInlineMode(code string) InlineMode {
	for _, v := range pipeVarNames {
		if containsIdent(code, v) {
			return ModePipe
		}
	}
	for _, v := range batchVarNames {
		if containsIdent(code, v) {
			return ModeBatch
		}
	}
	return ModeSimple
}

// containsIdent checks whether s contains identifier name as a whole word.
func containsIdent(s, name string) bool {
	pattern := `\b` + regexp.QuoteMeta(name) + `\b`
	matched, _ := regexp.MatchString(pattern, s)
	return matched
}

// InlineToScript converts a code snippet to a complete Go source file.
// It auto-detects the appropriate template based on magic variable usage.
// parallel > 0 activates concurrent loop mode (pipe only).
// regexPat, when non-empty, compiles a regex and exposes r/m/n/sub/suball in pipe mode.
func InlineToScript(code string, fieldSep string, parallel int, regexPat string) ([]byte, InlineMode, error) {
	mode := DetectInlineMode(code)
	// -r always implies pipe mode (m/n/sub/suball only exist in the loop context)
	if regexPat != "" && mode == ModeSimple {
		mode = ModePipe
	}
	code = wrapLastExpr(code)
	body := indentAsBlock(strings.TrimSpace(code), "\t")

	switch mode {
	case ModePipe:
		return buildPipeScript(body, fieldSep, parallel, regexPat), mode, nil
	case ModeBatch:
		return buildBatchScript(body), mode, nil
	default:
		return buildSimpleScript(body), mode, nil
	}
}

func buildParallelScript(body string, fieldSep string, n int, regexPat string) []byte {
	var fieldsExpr string
	if fieldSep == "" {
		fieldsExpr = "strings.Fields(x)"
	} else {
		fieldsExpr = `strings.Split(x, "` + fieldSep + `")`
	}

	before := ""
	if regexPat != "" {
		body = indentAsBlock(regexLoopPrefix("return"), "\t") + "\n" + body
		before = indentAsBlock(regexSetupBefore(regexPat), "\t")
	}

	out := parallelTmpl
	out = bytes.Replace(out, []byte(markerFields), []byte(fieldsExpr), 1)
	out = bytes.Replace(out, []byte(markerParallelN), []byte(fmt.Sprintf("%d", n)), 1)
	out = bytes.Replace(out, []byte(markerPipeBefore), []byte(before), 1)
	out = bytes.Replace(out, []byte(markerPipeBody), []byte(body), 1)
	return out
}

func buildSimpleScript(body string) []byte {
	return bytes.Replace(simpleTmpl, []byte(markerInlineBody), []byte(body), 1)
}

func buildBatchScript(body string) []byte {
	return bytes.Replace(batchTmpl, []byte(markerBatchBody), []byte(body), 1)
}

func buildPipeScript(body string, fieldSep string, parallel int, regexPat string) []byte {
	if parallel > 0 {
		return buildParallelScript(body, fieldSep, parallel, regexPat)
	}
	var fieldsExpr string
	if fieldSep == "" {
		fieldsExpr = "strings.Fields(x)"
	} else {
		fieldsExpr = `strings.Split(x, "` + fieldSep + `")`
	}

	before := ""
	if regexPat != "" {
		body = indentAsBlock(regexLoopPrefix("continue"), "\t") + "\n" + body
		before = indentAsBlock(regexSetupBefore(regexPat), "\t")
	}

	out := pipeTmpl
	out = bytes.Replace(out, []byte(markerFields), []byte(fieldsExpr), 1)
	out = bytes.Replace(out, []byte(markerPipeBefore), []byte(before), 1)
	out = bytes.Replace(out, []byte(markerPipeBody), []byte(body), 1)
	out = bytes.Replace(out, []byte(markerPipeAfter), []byte(""), 1)
	return out
}

// regexSetupBefore generates the code placed before the pipe loop when -r is used.
// It compiles the regex into r and defines sub/suball as closures over r.
func regexSetupBefore(pat string) string {
	return fmt.Sprintf(`r := regexp.MustCompile(%s)
sub := func(repl, s string) string {
	loc := r.FindStringSubmatchIndex(s)
	if loc == nil {
		return s
	}
	var dst []byte
	dst = r.ExpandString(dst, repl, s, loc)
	return s[:loc[0]] + string(dst) + s[loc[1]:]
}
suball := func(repl, s string) string { return r.ReplaceAllString(s, repl) }
_ = sub; _ = suball`, fmt.Sprintf("%q", pat))
}

// regexLoopPrefix generates the per-line setup injected at the top of the loop body.
// jumpStmt is "continue" for pipe mode and "return" for parallel mode.
func regexLoopPrefix(jumpStmt string) string {
	return `m := r.FindStringSubmatch(x)
if m == nil { ` + jumpStmt + ` }
n := map[string]string{}
for _i, _name := range r.SubexpNames() {
	if _name != "" && _i < len(m) {
		n[_name] = m[_i]
	}
}
_ = m; _ = n`
}

func indentAsBlock(s, prefix string) string {
	if s == "" {
		return ""
	}
	lines := strings.Split(s, "\n")
	for i, ln := range lines {
		if strings.TrimSpace(ln) == "" {
			lines[i] = ""
		} else {
			lines[i] = prefix + ln
		}
	}
	return strings.Join(lines, "\n")
}