package runtimebench

import (
	"bytes"
	"context"
	"hash/crc32"
	"sync"
	"sync/atomic"
	"testing"
)

var pool = sync.Pool{New: func() any { return new(bytes.Buffer) }}

func BenchmarkFrame(b *testing.B) {
	for _, reuse := range []bool{false, true} {
		name := "fresh"
		if reuse {
			name = "pool"
		}
		b.Run(name, func(b *testing.B) {
			payload := bytes.Repeat([]byte("a"), 4096)
			b.ReportAllocs()
			for b.Loop() {
				var buf *bytes.Buffer
				if reuse {
					buf = pool.Get().(*bytes.Buffer)
					buf.Reset()
				} else {
					buf = new(bytes.Buffer)
				}
				buf.WriteString("data: ")
				buf.Write(payload)
				if crc32.ChecksumIEEE(buf.Bytes()) == 0 {
					b.Fatal("checksum")
				}
				if reuse {
					pool.Put(buf)
				}
			}
		})
	}
}

// A single CAS linearizes one counter, not two tenants plus a global limit.
func claim(remaining *atomic.Int64) bool {
	for {
		n := remaining.Load()
		if n == 0 {
			return false
		}
		if remaining.CompareAndSwap(n, n-1) {
			return true
		}
	}
}
func TestConcurrentClaim(t *testing.T) {
	var free, won atomic.Int64
	free.Store(7)
	var wg sync.WaitGroup
	for range 100 {
		wg.Add(1)
		go func() {
			defer wg.Done()
			if claim(&free) {
				won.Add(1)
			}
		}()
	}
	wg.Wait()
	if won.Load() != 7 || free.Load() != 0 {
		t.Fatal("oversold")
	}
}
func TestBlockedProducerExits(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	q := make(chan int)
	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.Done()
		select {
		case q <- 1:
		case <-ctx.Done():
		}
	}()
	cancel()
	wg.Wait()
}