wire.go

package tlog

import (
	"unicode/utf8"
	"unsafe"

	"nikand.dev/go/hacked/low"
	"tlog.app/go/loc"

	"tlog.app/go/tlog/tlwire"
)

type (
	RawMessage []byte

	Modify []byte

	Timestamp int64

	Tag  string
	Tags []Tag

	FormatNext string

	format struct {
		Fmt  string
		Args []interface{}
	}
)

const KeyAuto = ""

var (
	Hidden        = RawMessage{byte(tlwire.Special | tlwire.Hidden)}
	None          = RawMessage{byte(tlwire.Special | tlwire.None)}
	Nil           = RawMessage{byte(tlwire.Special | tlwire.Nil)}
	Break         = RawMessage{byte(tlwire.Special | tlwire.Break)}
	NextAsHex     = Modify{byte(tlwire.Semantic | tlwire.Hex)}
	NextAsMessage = Modify{byte(tlwire.Semantic | WireMessage)}
	NextAsType    = FormatNext("%T")
)

// Wire semantic tags.
const (
	WireLabel = tlwire.SemanticTlogBase + iota
	WireID
	WireMessage
	WireEventKind
	WireLogLevel

	WireTag
	_
	_
	_
	_

	SemanticCommunityBase = tlwire.SemanticTlogBase + 10
)

func AppendLabels(e *tlwire.Encoder, b []byte, kvs []interface{}) []byte {
	const tag = tlwire.Semantic | WireLabel

	var d tlwire.LowDecoder

	w := len(b)
	b = append(b, low.Spaces[:len(kvs)/2+1]...)
	r := len(b)

	b = AppendKVs(e, b, kvs)

	for r < len(b) {
		end := d.Skip(b, r)

		w += copy(b[w:], b[r:end])
		r = end

		end = d.Skip(b, r)

		if b[r] != byte(tag) {
			b[w] = byte(tag)
			w++
		}

		w += copy(b[w:], b[r:end])
		r = end
	}

	return b[:w]
}

func NextIs(semantic int) Modify {
	return Modify(tlwire.LowEncoder{}.AppendTag(nil, tlwire.Semantic, semantic))
}

func RawTag(tag tlwire.Tag, sub int) RawMessage {
	return RawMessage(tlwire.LowEncoder{}.AppendTag(nil, tag, sub))
}

func Special(value int) RawMessage {
	return RawMessage(tlwire.LowEncoder{}.AppendTag(nil, tlwire.Special, value))
}

func AppendKVs(e *tlwire.Encoder, b []byte, kvs []interface{}) []byte {
	return appendKVs0(e, b, kvs)
}

//go:linkname appendKVs0 tlog.app/go/tlog.appendKVs
//go:noescape
func appendKVs0(e *tlwire.Encoder, b []byte, kvs []interface{}) []byte

func init() { // prevent deadcode warnings
	appendKVs(nil, nil, nil)
}

func appendKVs(e *tlwire.Encoder, b []byte, kvs []interface{}) []byte {
	for i := 0; i < len(kvs); {
		var k string

		switch el := kvs[i].(type) {
		case string:
			k = el

			if k == KeyAuto {
				k = autoKey(kvs[i:])
			}

			i++
		case tlwire.TlogAppender:
			b = el.TlogAppend(b)
			i++
			continue
		default:
			k = "MISSING_KEY"
		}

		b = e.AppendString(b, k)

	value:
		if i == len(kvs) {
			b = append(b, byte(tlwire.Special|tlwire.Undefined))
			break
		}

		switch v := kvs[i].(type) {
		case int:
			b = e.AppendInt(b, v)
		case string:
			b = e.AppendString(b, v)
		case []byte:
			b = e.AppendBytes(b, v)
		case RawMessage:
			b = append(b, v...)
		case Modify:
			b = append(b, v...)
			i++

			goto value
		case FormatNext:
			i++
			if i == len(kvs) {
				b = append(b, byte(tlwire.Special|tlwire.Undefined))
				break
			}

			b = e.AppendFormatf(b, string(v), kvs[i])
		default:
			b = e.AppendValue(b, v)
		}

		i++
	}

	return b
}

func autoKey(kvs []any) (k string) {
	if len(kvs) == 1 {
		return "MISSING_VALUE"
	}

	if m, ok := kvs[1].(Modify); ok && string(m) == string(NextAsMessage) {
		return KeyMessage
	}

	switch kvs[1].(type) {
	case ID:
		k = KeySpan
	case LogLevel:
		k = KeyLogLevel
	case EventKind:
		k = KeyEventKind
	case loc.PC:
		k = KeyCaller
	case loc.PCs:
		k = KeyCaller
	case Tag, Tags:
		k = KeyTag
	default:
		k = "UNSUPPORTED_AUTO_KEY"
	}

	return
}

func (ek EventKind) String() string {
	return string(ek)
}

func (id ID) TlogAppend(b []byte) []byte {
	var e tlwire.LowEncoder
	b = append(b, byte(tlwire.Semantic|WireID))
	return e.AppendBytes(b, id[:])
}

func (id *ID) TlogParse(p []byte, i int) int {
	if p[i] != byte(tlwire.Semantic|WireID) {
		panic("not an id")
	}

	i++

	if p[i] != byte(tlwire.Bytes|16) {
		panic("not an id")
	}

	i++

	i += copy((*id)[:], p[i:])

	return i
}

func (ek EventKind) TlogAppend(b []byte) []byte {
	var e tlwire.LowEncoder
	b = append(b, byte(tlwire.Semantic|WireEventKind))
	return e.AppendString(b, string(ek))
}

func (ek *EventKind) TlogParse(p []byte, i int) int {
	var d tlwire.LowDecoder

	if p[i] != byte(tlwire.Semantic|WireEventKind) {
		panic("not an event type")
	}

	i++

	v, i := d.Bytes(p, i)

	r, w := utf8.DecodeRune(v)
	if w == utf8.RuneError || w != len(v) {
		panic("bad rune")
	}

	*ek = EventKind(r)

	return i
}

func (l LogLevel) TlogAppend(b []byte) []byte {
	var e tlwire.LowEncoder
	b = append(b, byte(tlwire.Semantic|WireLogLevel))
	return e.AppendInt(b, int(l))
}

func (l *LogLevel) TlogParse(p []byte, i int) int {
	var d tlwire.LowDecoder

	if p[i] != byte(tlwire.Semantic|WireLogLevel) {
		panic("not a log level")
	}
	i++

	v, i := d.Signed(p, i)

	*l = LogLevel(v)

	return i
}

func (r RawMessage) TlogAppend(b []byte) []byte {
	return append(b, r...)
}

func (r *RawMessage) TlogParse(p []byte, st int) (i int) {
	var d tlwire.LowDecoder
	i = d.Skip(p, st)
	*r = append((*r)[:0], p[st:i]...)
	return i
}

func (t Tag) TlogAppend(b []byte) []byte {
	var e tlwire.Encoder
	b = e.AppendSemantic(b, WireTag)
	b = e.AppendString(b, string(t))
	return b
}

func (ts Tags) TlogAppend(b []byte) []byte {
	if len(ts) == 0 {
		return b
	}

	var e tlwire.Encoder
	b = e.AppendSemantic(b, WireTag)
	b = e.AppendArray(b, len(ts))

	for _, t := range ts {
		b = e.AppendString(b, string(t))
	}

	return b
}

func IterTags(p []byte, st int, f func(Tag)) int {
	var d tlwire.Decoder
	var b []byte

	if p[st] != byte(tlwire.Semantic|WireTag) {
		panic("not a tag")
	}
	st++

	tag, sub, i := d.Tag(p, st)
	if tag == tlwire.String {
		b, i = d.Bytes(p, st)

		f(Tag(unsafe.String(unsafe.SliceData(b), len(b))))

		return i
	}

	for el := 0; sub == -1 || el < int(sub); el++ {
		if sub == -1 && d.Break(p, &i) {
			break
		}
		if d.TagOnly(p, i) != tlwire.String {
			panic("not a tag")
		}

		b, i = d.Bytes(p, i)

		f(Tag(unsafe.String(unsafe.SliceData(b), len(b))))
	}

	return i
}