package docbuf

import (
	"io"
	"testing"
)

func SetupTestingBuffer(t *testing.T) ReadWriteSeekString{
	str := NewReadWriteSeekString()
	n, e := str.Write([]byte("test"))
	if n != 4 || e != nil {
		t.Fatalf("Failed to write to buffer: %e", e)
	}

	return str
}

// can it read
func TestRWSSRead(t *testing.T) {
	b := make([]byte, 4)
	buf := SetupTestingBuffer(t)
	c, err := buf.Seek(0, io.SeekStart)
	if err != nil || c != 0 {
		t.Fatalf("seek failed: %e", err)
	}

	n, err := buf.Read(b)
	if n != 4 || err != nil || string(b) != "test" {
		t.Fatalf("read failed: %e", err)
	}

	m, err := buf.Seek(-3, io.SeekEnd)
	if err != nil || m != 1 {
		t.Fatalf("seek failed: %e", err)
	}

	b = make([]byte, 4)
	l, err := buf.Read(b)
	if l != 3 || err != nil || string(b[:3]) != "est" {
		t.Fatalf("read failed: %e", err)
	}

	k, err := buf.Seek(0, io.SeekStart)
	if k != 0 || err != nil {
		t.Fatalf("seek failed: %e", err)
	}

	b = make([]byte, 3)
	j, err := buf.Read(b)
	if j != 3 || err != nil || string(b) != "tes" {
		t.Fatalf("read failed: %e", err)
	}

	b = make([]byte, 1)
	i, err := buf.Read(b)
	if i != 1 || err != nil || string(b) != "t" {
		t.Fatalf("read failed: %e", err)
	}
}

// can it write
func TestRWSSWrite(t *testing.T) {
	buf := SetupTestingBuffer(t)
	if buf.Contents() != "test" || buf.Cursor() != 4 {
		t.Fatalf("write failed: %s", buf.Contents())
	}

	m, err := buf.Write([]byte("test2"))
	if m != 5 ||
	   err != nil ||
	   buf.Contents() != "testtest2" ||
	   buf.Cursor() != 9 {
		t.Fatalf("write failed: %e", err)
	}

	n, err := buf.Seek(2, io.SeekStart)
	if n != 2 || err != nil {
		t.Fatalf("seek failed: %e", err)
	}

	o, err := buf.Write([]byte("one"))
	if o != 3 ||
	   err != nil ||
	   buf.Contents() != "teoneest2" ||
	   buf.Cursor() != 5 {
		t.Fatalf("write failed: %e", err)
	}

	p, err := buf.Seek(0, io.SeekEnd)
	if p != 9 || err != nil {
		t.Fatalf("seek (%d) failed: %e", p, err)
	}

	q, err := buf.Write([]byte("two"))
	if q != 3 || 
	   err != nil ||
	   buf.Contents() != "teoneest2two" ||
	   buf.Cursor() != 12 {
		t.Fatalf("write failed: %e", err)
	}
}

// if it seeks can it read from new position
// if it seeks can it write to new position
func TestRWSSSeek(t *testing.T) {
	buf := SetupTestingBuffer(t)

	if n, err := buf.Seek(0, io.SeekStart);
	   n != 0 ||
	   err != nil {
		t.Fatalf("seek failed: %e", err)
	}

	if n, err := buf.Seek(3, io.SeekStart);
	   n != 3 ||
	   err != nil {
		t.Fatalf("seek failed: %e", err)
	}

	if n, err := buf.Seek(-1, io.SeekStart);
	   n != 3 ||
	   err == nil ||
	   err.Error() != "seek index (-1) is negative" {
		t.Fatalf("seek should have failed but didnt: %e", err)
	}

	
	if n, err := buf.Seek(0, io.SeekCurrent);
	   n != 3 ||
	   err != nil {
		t.Fatalf("seek failed: %e", err)
	}

	if n, err := buf.Seek(-2, io.SeekEnd);
	   n != 2 ||
	   err != nil {
		t.Fatalf("seek failed: %e", err)
	}

	if n, err := buf.Seek(-1, io.SeekCurrent);
	   n != 1 ||
	   err != nil {
		t.Fatalf("seek failed: %e", err)
	}

	if n, err := buf.Seek(-2, io.SeekCurrent);
	   n != 1 ||
	   err == nil ||
	   err.Error() != "seek index (-1) is negative" {
		t.Fatalf("seek should have failed but didnt: %e", err)
	}

	if n, err := buf.Seek(-1, io.SeekEnd);
	   n != 3 ||
	   err != nil {
		t.Fatalf("seek failed: %e", err)
	}

	if n, err := buf.Seek(-5, io.SeekEnd);
	   n != 3 ||
	   err == nil ||
	   err.Error() != "seek index (-1) is negative" {
		t.Fatalf("seek should have failed but didnt: %e", err)
	}
}