package stario

import (
	"bytes"
	"fmt"
	"io"
	"sync/atomic"
	"testing"
	"time"
)

func TestNewStarBufferRejectsZeroCapacity(t *testing.T) {
	buf, err := NewStarBuffer(0)
	if err != ErrStarBufferInvalidCapacity {
		t.Fatalf("unexpected error: %v", err)
	}
	if buf != nil {
		t.Fatal("expected nil buffer when capacity is invalid")
	}
}

func TestStarBufferEndWriteDrainsThenEOF(t *testing.T) {
	buf, err := NewStarBuffer(4)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := buf.Write([]byte("abcd")); err != nil {
		t.Fatal(err)
	}
	if err := buf.EndWrite(); err != nil {
		t.Fatal(err)
	}

	got := make([]byte, 4)
	n, err := buf.Read(got)
	if err != nil {
		t.Fatal(err)
	}
	if n != 4 || !bytes.Equal(got[:n], []byte("abcd")) {
		t.Fatalf("unexpected payload: n=%d data=%q", n, got[:n])
	}

	n, err = buf.Read(got)
	if n != 0 || err != io.EOF {
		t.Fatalf("expected EOF after draining buffer, got n=%d err=%v", n, err)
	}

	if _, err := buf.Write([]byte("x")); err != ErrStarBufferWriteClosed {
		t.Fatalf("unexpected write error after EndWrite: %v", err)
	}
}

func TestStarBufferCloseAllowsDrain(t *testing.T) {
	buf, err := NewStarBuffer(4)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := buf.Write([]byte("ab")); err != nil {
		t.Fatal(err)
	}
	if err := buf.Close(); err != nil {
		t.Fatal(err)
	}

	got := make([]byte, 2)
	n, err := buf.Read(got)
	if err != nil {
		t.Fatal(err)
	}
	if n != 2 || !bytes.Equal(got[:n], []byte("ab")) {
		t.Fatalf("unexpected payload after close: n=%d data=%q", n, got[:n])
	}

	n, err = buf.Read(got)
	if n != 0 || err != io.EOF {
		t.Fatalf("expected EOF after draining closed buffer, got n=%d err=%v", n, err)
	}

	if _, err := buf.Write([]byte("x")); err != ErrStarBufferClosed {
		t.Fatalf("unexpected write error after Close: %v", err)
	}
}

func Test_Circle(t *testing.T) {
	buf, err := NewStarBuffer(2048)
	if err != nil {
		t.Fatal(err)
	}
	go func() {
		for {
			//fmt.Println("write start")
			buf.Write([]byte("中华人民共和国\n"))
			//fmt.Println("write success")
			time.Sleep(time.Millisecond * 50)
		}
	}()
	cpp := ""
	go func() {
		time.Sleep(time.Second * 3)
		for {
			cache := make([]byte, 64)
			ints, err := buf.Read(cache)
			if err != nil {
				fmt.Println("read error", err)
				return
			}
			if ints != 0 {
				cpp += string(cache[:ints])
			}
		}
	}()
	time.Sleep(time.Second * 13)
	fmt.Println(cpp)
}

func Test_Circle_Speed(t *testing.T) {
	buf, err := NewStarBuffer(1048976)
	if err != nil {
		t.Fatal(err)
	}
	count := uint64(0)
	for i := 1; i <= 10; i++ {
		go func() {
			for {
				buf.putByte('a')
			}
		}()
	}
	for i := 1; i <= 10; i++ {
		go func() {
			for {
				_, err := buf.getByte()
				if err == nil {
					atomic.AddUint64(&count, 1)
				}
			}
		}()
	}
	time.Sleep(time.Second * 10)
	fmt.Println(count)
}

func Test_Circle_Speed2(t *testing.T) {
	buf, err := NewStarBuffer(8192)
	if err != nil {
		t.Fatal(err)
	}
	count := uint64(0)
	for i := 1; i <= 10; i++ {
		go func() {
			for {
				buf.Write([]byte("hello world b612 hello world b612 b612 b612 b612 b612 b612"))
			}
		}()
	}
	for i := 1; i <= 10; i++ {
		go func() {
			for {
				mybuf := make([]byte, 1024)
				j, err := buf.Read(mybuf)
				if err == nil {
					atomic.AddUint64(&count, uint64(j))
				}
			}
		}()
	}
	time.Sleep(time.Second * 10)
	fmt.Println(float64(count) / 10 / 1024 / 1024)
}