basegroup.zzzgo

package xop

import (
	"sync"
	"time"

	"github.com/xoplog/xop-go/trace"
	"github.com/xoplog/xop-go/xopat"
	"github.com/xoplog/xop-go/xopbase"
	"github.com/xoplog/xop-go/xopnum"
)

type baseLoggers []xopbase.Logger
type baseRequests struct {
	baseSpans
	baseRequests []xopbase.Request
}
type baseSpans []xopbase.Span
type lines []xopbase.Line
type prefilleds []xopbase.Prefilled
type prefillings []xopbase.Prefilling

var _ xopbase.Request = baseRequests{}
var _ xopbase.Span = baseSpans{}
var _ xopbase.Line = lines{}
var _ xopbase.Prefilled = prefilleds{}
var _ xopbase.Prefilling = prefillings{}

func (l baseLoggers) StartRequests(ctx context.Context, ts time.Time, span trace.Bundle, descriptionOrName string) (xopbase.Request, map[string]xopbase.Request) {
	if len(l) == 1 {
		req := l[0].Request(ctx, ts, span, descriptionOrName)
		return req, map[string]xopbase.Request{l[0].ID(): req}
	}
	m := make(map[string]xopbase.Request)
	r := baseRequests{
		baseSpans:    make(baseSpans, 0, len(l)),
		baseRequests: make([]xopbase.Request, 0, len(l)),
	}
	for _, logger := range l {
		id := logger.ID()
		if _, ok := m[id]; ok {
			// duplicate!
			continue
		}
		req := logger.Request(ctx, ts, span, descriptionOrName)
		r.baseRequests = append(r.baseRequests, req)
		r.baseSpans = append(r.baseSpans, req.(xopbase.Span))
		m[id] = req
	}
	return r, m
}

func (l baseLoggers) ReferencesKept() bool {
	for _, logger := range l {
		if logger.ReferencesKept() {
			return true
		}
	}
	return false
}

func (l baseLoggers) Buffered() bool {
	for _, logger := range l {
		if logger.Buffered() {
			return true
		}
	}
	return false
}

func (s baseRequests) SetErrorReporter(f func(error)) {
	for _, request := range s.baseRequests {
		request.SetErrorReporter(f)
	}
}

func (s baseRequests) Final() {
	for _, request := range s.baseRequests {
		go func() {
			request.Final()
		}()
	}
}

func (s baseRequests) Flush() {
	var wg sync.WaitGroup
	wg.Add(len(s.baseRequests))
	for _, request := range s.baseRequests {
		go func() {
			defer wg.Done()
			request.Flush()
		}()
	}
	wg.Wait()
}

func (s baseSpans) Span(ctx context.Context, t time.Time, span trace.Bundle, descriptionOrName string, spanSequenceCode string) xopbase.Span {
	baseSpans := make(baseSpans, len(s))
	for i, ele := range s {
		baseSpans[i] = ele.Span(ctx, t, span, descriptionOrName, spanSequenceCode)
	}
	return baseSpans
}

func (s baseSpans) Done(t time.Time, final bool) {
	for _, span := range s {
		span.Done(t, final)
	}
}

func (s baseSpans) ID() string {
	panic("this is not expected to be called")
}

func (s baseSpans) Boring(b bool) {
	for _, span := range s {
		span.Boring(b)
	}
}

func (s baseSpans) NoPrefill() xopbase.Prefilled {
	prefilled := make(prefilleds, len(s))
	for i, span := range s {
		prefilled[i] = span.NoPrefill()
	}
	return prefilled
}

func (s baseSpans) StartPrefill() xopbase.Prefilling {
	prefilling := make(prefillings, len(s))
	for i, span := range s {
		prefilling[i] = span.StartPrefill()
	}
	return prefilling
}

func (p prefillings) PrefillComplete(m string) xopbase.Prefilled {
	prefilled := make(prefilleds, len(p))
	for i, prefilling := range p {
		prefilled[i] = prefilling.PrefillComplete(m)
	}
	return prefilled
}

func (p prefilleds) Line(level xopnum.Level, t time.Time, pc []uintptr) xopbase.Line {
	lines := make(lines, len(p))
	for i, prefilled := range p {
		lines[i] = prefilled.Line(level, t, pc)
	}
	return lines
}

func (l lines) Template(m string) {
	for _, line := range l {
		line.Template(m)
	}
}

func (l lines) Msg(m string) {
	for _, line := range l {
		line.Msg(m)
	}
}

func (l lines) Static(m string) {
	for _, line := range l {
		line.Static(m)
	}
}

func (l lines) Enum(k *xopat.EnumAttribute, v xopat.Enum) {
	for _, line := range l {
		line.Enum(k, v)
	}
}

func (p prefillings) Enum(k *xopat.EnumAttribute, v xopat.Enum) {
	for _, prefilling := range p {
		prefilling.Enum(k, v)
	}
}

// MACRO BaseDataWithoutType
func (p prefillings) ZZZ(k string, v zzz) {
	for _, prefilling := range p {
		prefilling.ZZZ(k, v)
	}
}

// MACRO BaseDataWithType
func (p prefillings) ZZZ(k string, v zzz, dt xopbase.DataType) {
	for _, prefilling := range p {
		prefilling.ZZZ(k, v, dt)
	}
}

// MACRO BaseDataWithoutType
func (l lines) ZZZ(k string, v zzz) {
	for _, line := range l {
		line.ZZZ(k, v)
	}
}

// MACRO BaseDataWithType
func (l lines) ZZZ(k string, v zzz, dt xopbase.DataType) {
	for _, line := range l {
		line.ZZZ(k, v, dt)
	}
}

//MACRO BaseAttribute
func (s baseSpans) MetadataZZZ(k *xopat.ZZZAttribute, v zzz) {
	for _, span := range s {
		span.MetadataZZZ(k, v)
	}
}