package wrap

import (
	"context"
	"mayhem-party/src/device/input/parse"
	"os"
	"syscall"
	"testing"
	"time"
)

func TestRefresh(t *testing.T) {
	b := byte('a')
	generator := func() Wrap {
		b += byte(1)
		return dummyParser{Char: b}
	}
	ch := make(chan os.Signal, 1)
	defer close(ch)
	refresh := NewRefreshWith(context.Background(), generator, ch)
	defer refresh.Close()

	assertIts := func(t *testing.T, b byte) {
		for i := 0; i < 10; i++ {
			some := false
			for j, button := range refresh.Read() {
				some = true
				if button.Char != b {
					t.Error(i, j, b, button)
				}
			}
			if !some {
				t.Error("empty read")
			}
		}
	}

	t.Run("called once on init", func(t *testing.T) {
		assertIts(t, byte('b'))
	})
	ch <- syscall.SIGUSR1
	time.Sleep(time.Millisecond * 450)
	t.Run("called once on signal", func(t *testing.T) {
		assertIts(t, byte('c'))
	})
}

func TestRefreshDoesntCloseSources(t *testing.T) {
	src := &telemetrySrc{}
	newParsers := 0
	newParser := func() Wrap {
		newParsers += 1
		return parse.NewPlaintext(src)
	}
	ctx, can := context.WithCancel(context.Background())
	defer can()
	refresh := NewRefresh(ctx, newParser)
	if newParsers != 1 {
		t.Error(newParsers)
	}

	for i := 0; i < 5; i++ {
		refresh.Read()
	}
	if want := (telemetrySrc{reads: 5}); *src != want {
		t.Errorf("%+v", *src)
	} else if newParsers != 1 {
		t.Error(newParsers)
	}

	for i := 0; i < 5; i++ {
		ChSigUsr1 <- syscall.SIGINT
	}
	time.Sleep(time.Millisecond * 250)
	if want := (telemetrySrc{reads: 5}); *src != want {
		t.Errorf("want %+v, got %+v", want, *src)
	} else if newParsers != 6 {
		t.Error(newParsers)
	}
}

type telemetrySrc struct {
	closes int
	reads  int
}

func (src *telemetrySrc) Close() {
	src.closes += 1
}

func (src *telemetrySrc) Read() []byte {
	src.reads += 1
	return []byte("foo")
}