package main

import (

	"context"

	"fmt"

	"math/rand"

	"regexp"

	"time"

)

// agent is one synthetic writer. It drives a Transport (cli or protocol) to

// push a stream of small changesets to its own branch on its assigned repo.

// Each agent owns its own branch (oak's flat model — every branch parents onto

// main and has an independent head), so in branch/repo strategies its pushes

// never lose a CAS race; what we measure is the server's per-repo push

// throughput, not client retry. This mirrors ForgeMark's agent, with the

// go-git calls replaced by the Transport seam.

type agent struct {

	id   int

	cfg  *commitConfig

	sess *sessionConfig // non-nil → "session" strategy (clone+push loop)

	tr   Transport

	samples []sample

}

func newAgent(id int, cfg *commitConfig, sess *sessionConfig, tr Transport) *agent {

	return &agent{id: id, cfg: cfg, sess: sess, tr: tr}

}

// run pushes changesets in a tight loop until ctx is cancelled, recording one

// sample per attempt. start anchors sample offsets so the caller drops the

// warm-up window afterwards. Identical control flow to ForgeMark's agent.run.

func (a *agent) run(ctx context.Context, start time.Time) {

	defer a.tr.Close()

	if a.sess != nil {

		a.runSessions(ctx, start)

		return

	}

	rng := rand.New(rand.NewSource(int64(a.id)*1_000_003 + 1)) //nolint:gosec // synthetic load, not security-sensitive

	if err := a.tr.Init(ctx); err != nil {

		// A setup failure takes this agent out of the level; record it so one

		// bad agent is visible rather than silently absent.

		a.samples = append(a.samples, sample{offset: time.Since(start), res: outcomeErr, msg: fmt.Sprintf("init: %v", err)})

		return

	}

	for ctx.Err() == nil {

		files := generateFiles(rng, a.cfg)

		t0 := time.Now()

		err := a.tr.Push(ctx, files)

		dur := time.Since(t0)

		// Drop the attempt that lost the ctx-cancellation race: it's a truncated

		// measurement, not real latency.

		if ctx.Err() != nil {

			break

		}

		o := classifyOak(err)

		a.samples = append(a.samples, sample{offset: t0.Sub(start), dur: dur, res: o, msg: errMsg(o, err)})

	}

}

// runSessions is the session-strategy loop: shallow-clone the base repo (the

// measured read), push `commits` checkpoints to a fresh ephemeral branch (the

// measured writes), then abandon it. Clone latency is op==clone, push latency

// op==push, so they summarize separately. Mirrors ForgeMark's runSessions.

func (a *agent) runSessions(ctx context.Context, start time.Time) {

	rng := rand.New(rand.NewSource(int64(a.id)*1_000_003 + 1)) //nolint:gosec // synthetic load

	for session := 0; ctx.Err() == nil; session++ {

		t0 := time.Now()

		err := a.tr.CloneSession(ctx)

		if ctx.Err() != nil {

			return

		}

		res := readOutcome(err)

		a.samples = append(a.samples, sample{offset: t0.Sub(start), dur: time.Since(t0), res: res, op: opClone, msg: errMsg(res, err)})

		if err != nil {

			continue // clone failed — next session retries

		}

		pushed := false

		for k := 0; k < a.sess.commits && ctx.Err() == nil; k++ {

			files := generateFiles(rng, a.cfg)

			t1 := time.Now()

			perr := a.tr.PushCheckpoint(ctx, session, files)

			if perr == nil {

				pushed = true

			}

			if ctx.Err() != nil {

				break // window closed mid-push: stop, but still clean up

			}

			o := classifyOak(perr)

			a.samples = append(a.samples, sample{offset: t1.Sub(start), dur: time.Since(t1), res: o, op: opPush, msg: errMsg(o, perr)})

		}

		if pushed {

			a.tr.CleanupSession(session) // best-effort, unmeasured

		}

	}

}

// maxErrMsgLen caps a retained error message so a long URL can't crowd the

// signal out of the window.

const maxErrMsgLen = 200

// reURL/reRef collapse the volatile substrings that vary by node/repo/agent

// (server URL, branch ref) so identical failures group together in the results.

var (

	reURL = regexp.MustCompile(`https?://\S+`)

	reRef = regexp.MustCompile(`refs?/\S+|oakmark-\S+`)

)

// normalizeErr turns a raw error message into a stable grouping key: collapse

// this run's volatile URLs/branch refs, then truncate. Order matters —

// truncating first could cut a status code that follows a long URL. Same

// contract as ForgeMark's normalizeErr (consumed by stats.go errGroups).

func normalizeErr(msg string) string {

	if msg == "" {

		return "(no message)"

	}

	msg = reURL.ReplaceAllString(msg, "<url>")

	msg = reRef.ReplaceAllString(msg, "<ref>")

	if len(msg) > maxErrMsgLen {

		msg = msg[:maxErrMsgLen]

	}

	return msg

}