package multireader

import (
	"bytes"
	"math/rand"
	"sync"
	"testing"
)

func TestMultiRead(t *testing.T) {
	t.Run("positive", func(t *testing.T) {
		_ = NewMultiReader(64)
	})
	t.Run("zero", func(t *testing.T) {
		_ = NewMultiReader(0)
	})
	t.Run("negative", func(t *testing.T) {
		_ = NewMultiReader(-64)
	})
}

func TestReadWrite(t *testing.T) {
	var (
		src  []byte
		dst1 []byte
		dst2 []byte
		dst3 []byte
		wg   *sync.WaitGroup
	)

	src = make([]byte, 20480)
	dst1 = make([]byte, 20480)
	dst2 = make([]byte, 20480)
	dst3 = make([]byte, 20480)

	n, err := rand.Read(src)
	if n < len(src) || err != nil {
		t.Fatalf("cannot initiate test data: %d; %v", n, err)
	}

	m := NewMultiReader(512)
	r1 := m.NewReader()
	r2 := m.NewReader()
	r3 := m.NewReader()
	wg = &sync.WaitGroup{}

	writeFunc := func(t *testing.T, m *MultiReader, data []byte, wg *sync.WaitGroup) {
		var (
			n  int
			dl int
			r  int
		)
		defer wg.Done()

		for n < len(data) {
			dl = rand.Intn(512)
			if n+512+dl > len(data) {
				r, _ = m.Write(data[n:])
			} else {
				r, _ = m.Write(data[n : n+512+dl])
			}
			n += r
		}
		_ = m.Close()
	}
	wg.Add(1)
	go writeFunc(t, m, src, wg)

	readFunc := func(t *testing.T, r *Reader, data []byte, wg *sync.WaitGroup) {
		var (
			offset int
			n      int
			err    error
		)
		defer wg.Done()

		offset = 0
		for {
			if offset+1024 < len(data) {
				n, err = r.Read(data[offset : offset+1024])
				if err != nil {
					t.Logf("reader got error: %v", err)
					break
				}
			} else {
				n, err = r.Read(data[offset:])
				if err != nil {
					t.Logf("reader got error: %v", err)
					break
				}

			}
			offset += n
		}
	}

	wg.Add(1)
	go readFunc(t, r1, dst1, wg)
	wg.Add(1)
	go readFunc(t, r2, dst2, wg)
	wg.Add(1)
	go readFunc(t, r3, dst3, wg)

	wg.Wait()
	if !bytes.Equal(src, dst1) {
		t.Error("src and dst1 mismatch")
	}
	if !bytes.Equal(src, dst2) {
		t.Error("src and dst2 mismatch")
	}
	if !bytes.Equal(src, dst3) {
		t.Error("src and dst3 mismatch")
	}
}