import okio.BufferedSource
import okio.ByteString.Companion.encodeUtf8
import okio.Options

class ServerSentEventReader(
  private val source: BufferedSource,
  private val callback: Callback,
) {
  private var lastId: String? = null

  interface Callback {
    fun onEvent(
      id: String?,
      type: String?,
      data: String,
    )

    fun onRetryChange(timeMs: Long)
  }

  /**

// respective 64 bit atomic instructions are not available
// on all platforms.
var lastID atomic.Uint32

// nextID returns a value increasing monotonically by 1 with
// each call, starting with 1. It may be called concurrently.
func nextID() uint64 { return uint64(lastID.Add(1)) }

// A TypeParam represents a type parameter type.
type TypeParam struct {

// respective 64 bit atomic instructions are not available
// on all platforms.
var lastID atomic.Uint32

// nextID returns a value increasing monotonically by 1 with
// each call, starting with 1. It may be called concurrently.
func nextID() uint64 { return uint64(lastID.Add(1)) }

// A TypeParam represents a type parameter type.
type TypeParam struct {

}

func TestCipherSuites(t *testing.T) {
	var lastID uint16
	for _, c := range CipherSuites() {
		if lastID > c.ID {
			t.Errorf("CipherSuites are not ordered by ID: got %#04x after %#04x", c.ID, lastID)
		} else {
			lastID = c.ID
		}

		if c.Insecure {
			t.Errorf("%#04x: Insecure CipherSuite returned by CipherSuites()", c.ID)
		}
	}
	lastID = 0
	for _, c := range InsecureCipherSuites() {

		t.Fatalf("find auto_increment_struct fail, err: %v", err)
	}

	ids := make([]int64, 0, len(rows))
	for _, row := range rows {
		ids = append(ids, row.ID)
	}
	lastID := ids[len(ids)-1]

	if err := DB.Where("id IN (?)", ids).Delete(&AutoIncrementStruct{}).Error; err != nil {
		t.Fatalf("delete auto_increment_struct fail, err: %v", err)
	}

	newRow := &AutoIncrementStruct{}

tail_maybe_long:
	CMP	$64, R1
	BHS	no_zva

tail63:
	ANDS	$48, R1, R3
	BEQ	last16
	CMPW	$32, R3
	BEQ	last48
	BLT	last32
	STP.P	(ZR, ZR), 16(R0)
last48:
	STP.P	(ZR, ZR), 16(R0)
last32:
	STP.P	(ZR, ZR), 16(R0)
	// The last store length is at most 16, so it is safe to use
	// stp to write last 16 bytes
last16:
	ANDS	$15, R1, R1
	CBZ	R1, last_end
	ADD	R1, R0, R0
	STP	(ZR, ZR), -16(R0)
last_end:

	}
	handleSweep := func(r Range) bool {
		return flags&UtilSweep != 0 && isGCSweep(r)
	}

	// Iterate through the trace, tracking mutator utilization.
	var lastEv *Event
	for i := range events {
		ev := &events[i]
		lastEv = ev

		// Process the event.
		switch ev.Kind() {
		case EventSync:
			seenSync = true
		case EventMetric:
			m := ev.Metric()
			if m.Name != "/sched/gomaxprocs:threads" {

	}
}

// InOrder checks if a-equal elements were not reordered.
func (d intPairs) inOrder() bool {
	lastA, lastB := -1, 0
	for i := 0; i < len(d); i++ {
		if lastA != d[i].a {
			lastA = d[i].a
			lastB = d[i].b
			continue
		}
		if d[i].b <= lastB {
			return false
		}
		lastB = d[i].b
	}
	return true
}

func TestStability(t *testing.T) {
	n, m := 100000, 1000

	for b.idx < len(batches) && len(batches[b.idx].data) == b.dataOff {
		b.idx++
		b.dataOff = 0
		b.lastTs = 0
	}
	// Have we reached the end of the batches?
	if b.idx == len(batches) {
		return false, nil
	}
	// Initialize lastTs if it hasn't been yet.
	if b.lastTs == 0 {
		b.lastTs = freq.mul(batches[b.idx].time)
	}
	// Read an event out.

var faketimeState struct {
	lock mutex

	// lastfaketime is the last faketime value written to fd 1 or 2.
	lastfaketime int64

	// lastfd is the fd to which lastfaketime was written.
	//
	// Subsequent writes to the same fd may use the same
	// timestamp, but the timestamp must increase if the fd
	// changes.
	lastfd uintptr
}

//go:linkname nanotime
//go:nosplit
func nanotime() int64 {