// Command oakmark measures per-repo push (and clone) throughput of an oak

// server — the oak analogue of ForgeMark. It forks ForgeMark's measurement

// harness (concurrency sweep, warm-up exclusion, nearest-rank latency

// percentiles, ops/sec → ops/hour, JSON schema in stats.go — kept verbatim for

// comparability) and swaps the git-over-smart-HTTP transport for oak's own

// protocol via one of two backends:

//

//	-transport cli       shell out to the real `oak` binary (honest real-agent

//	                     floor; includes client chunking + process spin-up)

//	-transport protocol  drive the in-process oak-engine (Rust, on oakvcs-core);

//	                     the ForgeMark-comparable ceiling

//

// Strategies mirror ForgeMark: branch (headline single-repo push throughput),

// repo (horizontal across N repos), session (clone+checkpoint read/write mix;

// cli-only). Each agent owns its own branch (oak's flat model), so branch/repo

// pushes never lose a CAS race — we measure the server's per-repo throughput.

package main

import (

	"context"

	"flag"

	"fmt"

	"io"

	"os"

	"strconv"

	"strings"

	"sync"

	"time"

)

// engineStderr is where every protocol-transport oak-engine child sends its

// diagnostics. One shared sink keeps engine noise out of stdout (which carries

// the JSON protocol).

var engineStderr io.Writer = os.Stderr

type repoRef struct{ owner, name string }

func (r repoRef) String() string { return r.owner + "/" + r.name }

func main() {

	remote := flag.String("remote", "http://127.0.0.1:8080", "oak server base URL (e.g. https://oak.space or a local `oak serve`)")

	transportKind := flag.String("transport", "cli", "push backend: cli | protocol")

	oakBin := flag.String("oak-bin", "oak", "path to the oak binary (cli transport + repo seeding)")

	engineBin := flag.String("engine-bin", "./oak-engine/target/release/oak-engine", "path to oak-engine (protocol transport)")

	tokenFile := flag.String("token-file", "", "file holding the oak.space bearer token; '-' for stdin. Falls back to $OAK_API_KEY")

	strategy := flag.String("strategy", "branch", "workload strategy: branch | repo | session")

	owner := flag.String("owner", "bench", "org/owner slug that owns the target repos (must exist on oak.space)")

	repoBase := flag.String("repo", "oakmark-tp", "target repo name (branch/session); base name for the repo strategy (repo-<n>)")

	repoCount := flag.Int("repo-count", 4, "number of repos for the repo strategy")

	concurrencyCSV := flag.String("concurrency", "1,8,32", "comma-separated agent counts to sweep")

	duration := flag.Duration("duration", 30*time.Second, "measurement window per concurrency level")

	warmup := flag.Duration("warmup", 5*time.Second, "discarded warm-up window per level")

	filesMin := flag.Int("files-min", 1, "min files per changeset")

	filesMax := flag.Int("files-max", 10, "max files per changeset")

	fileSize := flag.Int("file-size", 2048, "bytes per file")

	sessionCommits := flag.Int("session-commits", 5, "checkpoint pushes per session (session strategy)")

	cloneDepth := flag.Int("clone-depth", 1, "clone depth for the session read (0 = full history, else shallow)")

	branchPrefix := flag.String("branch-prefix", "", "branch name prefix (default: oakmark-<runid>)")

	out := flag.String("out", "", "write JSON results to this path (default: stdout only)")

	reportOut := flag.String("report", "", "write a markdown throughput report to this path")

	doSeed := flag.Bool("seed", true, "create/seed the target repos before the sweep")

	flag.Parse()

	runID := fmt.Sprintf("run%d", time.Now().Unix())

	prefix := *branchPrefix

	if prefix == "" {

		prefix = "oakmark-" + runID

	}

	token := loadToken(*tokenFile)

	if *strategy == "session" && *transportKind == "protocol" {

		fatalf("%v", errNoSession)

	}

	if *strategy != "branch" && *strategy != "repo" && *strategy != "session" {

		fatalf("unknown -strategy %q (want branch|repo|session)", *strategy)

	}

	if *transportKind != "cli" && *transportKind != "protocol" {

		fatalf("unknown -transport %q (want cli|protocol)", *transportKind)

	}

	repos := repoList(*owner, *repoBase, *strategy, *repoCount)

	levels, err := parseLevels(*concurrencyCSV)

	if err != nil {

		fatalf("bad -concurrency: %v", err)

	}

	cfg := &commitConfig{filesMin: *filesMin, filesMax: *filesMax, fileSize: *fileSize}

	commitFiles := fmt.Sprintf("%d-%d x %dB", cfg.filesMin, cfg.filesMax, cfg.fileSize)

	var sess *sessionConfig

	if *strategy == "session" {

		sess = &sessionConfig{commits: *sessionCommits, cloneDepth: *cloneDepth}

	}

	fmt.Fprintf(os.Stderr, "oakmark: remote=%s transport=%s strategy=%s repos=%d changeset=%q window=%s warmup=%s\n",

		*remote, *transportKind, *strategy, len(repos), commitFiles, *duration, *warmup)

	if *doSeed {

		for _, r := range repos {

			if err := seedRepo(*oakBin, *remote, r); err != nil {

				fatalf("seed %s: %v", r, err)

			}

		}

		fmt.Fprintf(os.Stderr, "oakmark: seeded %d repo(s)\n", len(repos))

	}

	runCfg := &runConfig{

		transport: *transportKind, oakBin: *oakBin, engineBin: *engineBin,

		remote: *remote, token: token, prefix: prefix, cfg: cfg, sess: sess,

		cloneDepth: *cloneDepth, repos: repos,

	}

	results := make([]levelResult, 0, len(levels))

	for _, level := range levels {

		fmt.Fprintf(os.Stderr, "oakmark: level c=%d …\n", level)

		samples := runLevel(runCfg, level, *warmup, *duration)

		r := summarize(samples, level, *strategy, len(repos), 1, *warmup, *duration, commitFiles)

		results = append(results, r)

		printLevel(r)

	}

	emitJSON(results, *out, runID, *remote, *transportKind)

	report := renderReport(results, runID, *remote, *transportKind, *strategy)

	if *reportOut != "" {

		if err := os.WriteFile(*reportOut, []byte(report), 0o644); err != nil {

			fmt.Fprintf(os.Stderr, "oakmark: write report: %v\n", err)

		} else {

			fmt.Fprintf(os.Stderr, "oakmark: report → %s\n", *reportOut)

		}

	}

	fmt.Print(report)

}

// runConfig is the immutable per-run setup a level needs to build agents.

type runConfig struct {

	transport  string

	oakBin     string

	engineBin  string

	remote     string

	token      string

	prefix     string

	cfg        *commitConfig

	sess       *sessionConfig

	cloneDepth int

	repos      []repoRef

}

// runLevel runs `level` concurrent agents for warmup+window and returns every

// sample. Agents are assigned round-robin across repos (the repo strategy

// spreads load; branch/session use a single repo). Each owns branch

// <prefix>-a<i>.

func runLevel(rc *runConfig, level int, warmup, window time.Duration) []sample {

	ctx, cancel := context.WithTimeout(context.Background(), warmup+window)

	defer cancel()

	agents := make([]*agent, level)

	for i := range level {

		repo := rc.repos[i%len(rc.repos)]

		branch := fmt.Sprintf("%s-a%d", rc.prefix, i)

		tr := buildTransport(rc, repo, i, branch)

		agents[i] = newAgent(i, rc.cfg, rc.sess, tr)

	}

	start := time.Now()

	var wg sync.WaitGroup

	for _, a := range agents {

		wg.Add(1)

		go func(a *agent) { defer wg.Done(); a.run(ctx, start) }(a)

	}

	wg.Wait()

	var all []sample

	for _, a := range agents {

		all = append(all, a.samples...)

	}

	return all

}

func buildTransport(rc *runConfig, repo repoRef, id int, branch string) Transport {

	if rc.transport == "protocol" {

		author := fmt.Sprintf("agent-%d", id)

		return newProtocolTransport(rc.engineBin, rc.remote, repo.owner, repo.name, rc.token, author, branch)

	}

	return newCLITransport(rc.oakBin, rc.remote, repo.owner, repo.name, id, branch, rc.cloneDepth)

}

// repoList builds the target repo set. branch/session use one repo; repo

// spreads across repo-<0..n-1>.

func repoList(owner, base, strategy string, count int) []repoRef {

	if strategy == "repo" {

		if count < 1 {

			count = 1

		}

		repos := make([]repoRef, count)

		for i := range count {

			repos[i] = repoRef{owner: owner, name: fmt.Sprintf("%s-%d", base, i)}

		}

		return repos

	}

	return []repoRef{{owner: owner, name: base}}

}

func parseLevels(csv string) ([]int, error) {

	parts := strings.Split(csv, ",")

	levels := make([]int, 0, len(parts))

	for _, p := range parts {

		p = strings.TrimSpace(p)

		if p == "" {

			continue

		}

		n, err := strconv.Atoi(p)

		if err != nil || n < 1 {

			return nil, fmt.Errorf("%q is not a positive integer", p)

		}

		levels = append(levels, n)

	}

	if len(levels) == 0 {

		return nil, fmt.Errorf("no levels")

	}

	return levels, nil

}

// loadToken resolves the bearer token: -token-file (or '-' for stdin), else

// $OAK_API_KEY, else "" (anonymous — fine for an open loopback `oak serve`).

func loadToken(tokenFile string) string {

	if tokenFile == "-" {

		b, _ := io.ReadAll(os.Stdin)

		return strings.TrimSpace(string(b))

	}

	if tokenFile != "" {

		b, err := os.ReadFile(tokenFile)

		if err != nil {

			fatalf("read token file %s: %v", tokenFile, err)

		}

		return strings.TrimSpace(string(b))

	}

	return strings.TrimSpace(os.Getenv("OAK_API_KEY"))

}

// seedRepo creates the target repo on the server so agents can clone it: a

// fresh `oak init` + `oak commit` + `oak push --repo owner/name`. Idempotent —

// a second seed of an existing repo just re-links and pushes a new branch.

func seedRepo(oakBin, remote string, repo repoRef) error {

	dir, err := os.MkdirTemp("", "oakmark-seed-")

	if err != nil {

		return err

	}

	defer os.RemoveAll(dir)

	env := append(os.Environ(), "OAK_REMOTE="+remote)

	runOak := func(d string, args ...string) error {

		return runCmd(oakBin, d, env, args...)

	}

	if err := runOak(dir, "init", "."); err != nil {

		return fmt.Errorf("init: %w", err)

	}

	if err := os.WriteFile(dir+"/README.md", []byte("oakmark seed for "+repo.String()+"\n"), 0o644); err != nil {

		return err

	}

	if err := runOak(dir, "commit", "--quiet"); err != nil {

		return fmt.Errorf("commit: %w", err)

	}

	if err := runOak(dir, "push", "--repo", repo.String(), "-r", remote); err != nil {

		return fmt.Errorf("push: %w", err)

	}

	return nil

}

func fatalf(format string, args ...any) {

	fmt.Fprintf(os.Stderr, "oakmark: "+format+"\n", args...)

	os.Exit(1)

}