package storage

import (
	"context"
	"fmt"
	"sync/atomic"
	"testing"

	"github.com/metazla/meta-core/internal/claim"
)

// benchRecord is a 40-field signed record, the shape gateway hits persist.
func benchRecord(b *testing.B, c *Client, i int) []claim.Claim {
	t := &testing.T{}
	id := signer(t, byte(1+i%7))
	cid := fmt.Sprintf("bafkbench%012d", i)
	out := make([]claim.Claim, 0, 40)
	for f := 0; f < 40; f++ {
		out = append(out, vote(t, id, cid, fmt.Sprintf("field%02d", f), fmt.Sprintf("value-%d-%d", i, f), 1000))
	}
	return out
}

// BenchmarkConcurrentClaimWrites measures new 40-claim records, 16 writers.
func BenchmarkConcurrentClaimWrites(b *testing.B) {
	c := openClient(&testing.T{}, b.TempDir())
	defer c.Close()
	recs := make([][]claim.Claim, b.N)
	for i := range recs {
		recs[i] = benchRecord(b, c, i)
	}
	b.ResetTimer()
	b.SetParallelism(16)
	var next int64
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			i := int(atomicAdd(&next) - 1)
			if _, err := c.WriteClaims(context.Background(), recs[i]); err != nil {
				b.Error(err)
			}
		}
	})
}

// BenchmarkRepersistUnchangedClaims measures the 94% case: the same signed
// claims again (skip-identical before verification).
func BenchmarkRepersistUnchangedClaims(b *testing.B) {
	c := openClient(&testing.T{}, b.TempDir())
	defer c.Close()
	const distinct = 200
	recs := make([][]claim.Claim, distinct)
	for i := range recs {
		recs[i] = benchRecord(b, c, i)
		if _, err := c.WriteClaims(context.Background(), recs[i]); err != nil {
			b.Fatal(err)
		}
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		if _, err := c.WriteClaims(context.Background(), recs[i%distinct]); err != nil {
			b.Fatal(err)
		}
	}
}

func atomicAdd(p *int64) int64 { return atomic.AddInt64(p, 1) }