lines_test.go

package lines_test

import (
	"bytes"
	"errors"
	"fmt"
	"io"
	"log"
	"regexp"
	"strings"
	"testing"
	"time"

	_ "embed"

	"mz.attahri.com/code/lines"
)

// memFile implements [io.ReadWriteSeeker]
// using a []byte buffer.
type memFile struct {
	buf    []byte
	offset int64
}

// Truncate implements lines.ReWritable.
func (m *memFile) Truncate(n int64) error {
	if n < 0 || n > int64(len(m.buf)) {
		return errors.New("n must be 0 < n < len(m.buf)")
	}
	m.buf = m.buf[:n]
	return nil
}

// Read implements [io.Reader].
func (m *memFile) Read(p []byte) (n int, err error) {
	size := int64(len(m.buf))
	if m.offset >= size {
		err = io.EOF
		return
	}

	end := m.offset + int64(len(p))
	if end > size {
		end = size
	}

	n = copy(p, m.buf[m.offset:end])
	m.offset += int64(n)
	if m.offset >= size {
		err = io.EOF
	}
	return
}

// Seek implements [io.Seeker].
func (m *memFile) Seek(offset int64, whence int) (int64, error) {
	size := int64(len(m.buf))

	switch whence {
	case io.SeekEnd:
		m.offset = size - offset
	case io.SeekCurrent:
		m.offset += offset
	case io.SeekStart:
		m.offset = offset
	default:
		return 0, fmt.Errorf("invalid whence value: %v", whence)
	}

	if m.offset < 0 {
		m.offset = 0
	} else if m.offset > size {
		m.offset = size
	}

	return m.offset, nil
}

// Write implements [io.Writer].
func (m *memFile) Write(p []byte) (n int, err error) {
	if l, c := int64(len(m.buf)), (m.offset)+int64(len(p)); c > l {
		m.buf = append(m.buf, make([]byte, c-l)...)
	}

	var (
		a = m.offset
		b = m.offset + int64(len(p))
	)
	n = copy(m.buf[a:b], p)
	if n != len(p) {
		err = io.ErrShortWrite
		return
	}
	m.offset += int64(n)
	return
}

func newMemFile(src []byte) *memFile {
	b := make([]byte, len(src))
	copy(b, src)
	return &memFile{buf: b}
}

//go:embed test/file.txt
var fixtureRO []byte

//go:embed test/file.txt
var fixtureRW []byte

var fixtureLineCount = bytes.Count(fixtureRO, []byte("\n")) + 1

func TestContains(t *testing.T) {
	tests := map[string]bool{
		"GSV0U2DXCV9VLI3D,2009-09-05,Joellen,Lam,kristyn-sellers-reinhart612@unnecessary.com": true,
		"something": false,
		"else":      false,
		"7K8Y6XHA93Z7R1EV,2008-11-30,Glen,Kolb,kelli25969@yahoo.com": true,
	}

	for str, wanted := range tests {
		got, err := lines.Contains(lines.All(bytes.NewBuffer(fixtureRO)), str)
		if err != nil {
			t.Fatal(err)
		}
		if got != wanted {
			t.Fatalf("wanted: %v, got: %v", wanted, got)
		}
	}
}

func TestCount(t *testing.T) {
	count, err := lines.Count(lines.All(bytes.NewBuffer(fixtureRO)), "GSV0U2DXCV9VLI3D,2009-09-05,Joellen,Lam,kristyn-sellers-reinhart612@unnecessary.com")
	if err != nil {
		t.Fatal(err)
	}
	const wanted = 1
	if count != wanted {
		t.Fatalf("wanted: %d, got: %d", wanted, count)
	}
}

func TestCountFunc(t *testing.T) {
	count, err := lines.CountFunc(lines.All(bytes.NewBuffer(fixtureRO)), func(line string) bool { return true })
	if err != nil {
		t.Fatal(err)
	}
	if count != fixtureLineCount {
		t.Fatalf("wanted: %d, got: %d", fixtureLineCount, count)
	}
}

func TestIndex(t *testing.T) {
	tests := map[string]int{
		"7K8Y6XHA93Z7R1EV,2008-11-30,Glen,Kolb,kelli25969@yahoo.com":                          1,
		"GSV0U2DXCV9VLI3D,2009-09-05,Joellen,Lam,kristyn-sellers-reinhart612@unnecessary.com": 22,
		"hello": 0,
		"world": 0,
	}

	for str, wanted := range tests {
		got, err := lines.Index(lines.All(bytes.NewBuffer(fixtureRO)), str)
		if err != nil {
			t.Fatal(err)
		}
		if got != wanted {
			t.Fatal("Wanted:", wanted, "Got:", got)
		}
	}
}

func TestAppend(t *testing.T) {
	b := newMemFile(fixtureRW)

	count, err := lines.CountFunc(lines.All(b), func(line string) bool { return true })
	if err != nil {
		t.Fatal(err)
	}

	if _, err := b.Seek(0, io.SeekEnd); err != nil {
		t.Fatal(err)
	}

	line := time.Now().String()
	if _, err := lines.Append(b, line); err != nil {
		t.Fatal(err)
	}

	if _, err := b.Seek(0, io.SeekStart); err != nil {
		t.Fatal(err)
	}

	l, lineno, err := lines.ContainsFunc(lines.All(b), func(a string) bool { return a == line })
	if err != nil {
		t.Fatal(err)
	}
	if l != line {
		t.Log(l)
		t.Log(line)
		t.Fatal("expected content to match", l, line)
	}
	if lineno != (count + 1) {
		t.Fatalf("line not appended at the bottom. Wanted: %d, Got: %d", count+1, lineno)
	}
}

func TestHead(t *testing.T) {
	var head []string
	for line, err := range lines.Head(bytes.NewBuffer(fixtureRO), 10) {
		if err != nil {
			t.Fatal(err)
		}
		head = append(head, line.String())
	}
	if len(head) != 10 {
		t.Fatal("Line count mismatch")
	}

	// n <= 0 returns no lines
	head = nil
	for line, err := range lines.Head(bytes.NewBuffer(fixtureRO), 0) {
		if err != nil {
			t.Fatal(err)
		}
		head = append(head, line.String())
	}
	if len(head) != 0 {
		t.Fatal("Expected empty result for n=0")
	}
}

func TestTail(t *testing.T) {
	all := make([]string, 0, fixtureLineCount)
	for line, err := range lines.Backward(bytes.NewReader(fixtureRO)) {
		if err != nil {
			t.Fatal(err)
		}
		all = append(all, line.String())
	}

	var tail []string
	for line, err := range lines.Tail(bytes.NewReader(fixtureRO), 10) {
		if err != nil {
			t.Fatal(err)
		}
		tail = append(tail, line.String())
	}
	for i, l := range tail {
		if l != all[i] {
			t.Fatal("lines are not matching")
		}
	}
}

// The following example finds lines that
// match a specific regexp rule.
func ExampleContainsFunc() {
	rule := regexp.MustCompile(`^[a-z]+\[\d+\]$`)
	src := strings.NewReader("")

	line, _, err := lines.ContainsFunc(lines.All(src), rule.MatchString)
	if err != nil {
		log.Fatal(err)
	}

	log.Printf("Found it: %#v", line)
}

func TestLineRead(t *testing.T) {
	content := []byte("hello world")
	line := &lines.Line{Content: content, Number: 1}

	// Read in chunks
	buf := make([]byte, 5)
	n, err := line.Read(buf)
	if err != nil {
		t.Fatal(err)
	}
	if n != 5 || string(buf) != "hello" {
		t.Fatalf("first read: expected 'hello', got %q", buf[:n])
	}

	n, err = line.Read(buf)
	if err != nil {
		t.Fatal(err)
	}
	if n != 5 || string(buf) != " worl" {
		t.Fatalf("second read: expected ' worl', got %q", buf[:n])
	}

	n, err = line.Read(buf)
	if err != nil {
		t.Fatal(err)
	}
	if n != 1 || string(buf[:n]) != "d" {
		t.Fatalf("third read: expected 'd', got %q", buf[:n])
	}

	// Next read should return EOF
	_, err = line.Read(buf)
	if err != io.EOF {
		t.Fatalf("expected EOF, got %v", err)
	}
}

func TestLineReadAt(t *testing.T) {
	content := []byte("hello world")
	line := &lines.Line{Content: content, Number: 1}

	buf := make([]byte, 5)

	// Read from offset 0
	n, err := line.ReadAt(buf, 0)
	if err != nil {
		t.Fatal(err)
	}
	if n != 5 || string(buf) != "hello" {
		t.Fatalf("expected 'hello', got %q", buf[:n])
	}

	// Read from offset 6 - "world" is exactly 5 bytes, so no EOF
	n, err = line.ReadAt(buf, 6)
	if err != nil {
		t.Fatalf("expected nil error, got %v", err)
	}
	if string(buf[:n]) != "world" {
		t.Fatalf("expected 'world', got %q", buf[:n])
	}

	// Read from offset 8 - only 3 bytes left, should return EOF
	n, err = line.ReadAt(buf, 8)
	if err != io.EOF {
		t.Fatalf("expected EOF for short read, got %v", err)
	}
	if n != 3 || string(buf[:n]) != "rld" {
		t.Fatalf("expected 'rld', got %q", buf[:n])
	}

	// Read past end
	_, err = line.ReadAt(buf, 100)
	if err != io.EOF {
		t.Fatalf("expected EOF, got %v", err)
	}
}

func TestLineWriteTo(t *testing.T) {
	content := []byte("hello world")
	line := &lines.Line{Content: content, Number: 1}

	var buf bytes.Buffer
	n, err := line.WriteTo(&buf)
	if err != nil {
		t.Fatal(err)
	}
	if n != int64(len(content)) {
		t.Fatalf("expected %d bytes written, got %d", len(content), n)
	}
	if buf.String() != "hello world" {
		t.Fatalf("expected 'hello world', got %q", buf.String())
	}
}

func TestEmptyFile(t *testing.T) {
	// Empty input
	r := bytes.NewReader([]byte{})

	count := 0
	for _, err := range lines.All(r) {
		if err != nil {
			t.Fatal(err)
		}
		count++
	}
	if count != 0 {
		t.Fatalf("expected 0 lines from empty file, got %d", count)
	}

	// Backward on empty input
	r.Reset([]byte{})
	count = 0
	for _, err := range lines.Backward(r) {
		if err != nil {
			t.Fatal(err)
		}
		count++
	}
	if count != 0 {
		t.Fatalf("expected 0 lines from empty file (backward), got %d", count)
	}

	// Contains on empty input
	r.Reset([]byte{})
	found, err := lines.Contains(lines.All(r), "anything")
	if err != nil {
		t.Fatal(err)
	}
	if found {
		t.Fatal("expected not found in empty file")
	}
}

func TestSingleLine(t *testing.T) {
	// Single line without newline
	data := []byte("hello world")
	r := bytes.NewReader(data)

	var collected []string
	for line, err := range lines.All(r) {
		if err != nil {
			t.Fatal(err)
		}
		collected = append(collected, line.String())
		if line.Number != 1 {
			t.Fatalf("expected line number 1, got %d", line.Number)
		}
	}
	if len(collected) != 1 {
		t.Fatalf("expected 1 line, got %d", len(collected))
	}
	if collected[0] != "hello world" {
		t.Fatalf("expected 'hello world', got %q", collected[0])
	}

	// Single line with newline
	data = []byte("hello world\n")
	r.Reset(data)
	collected = nil
	for line, err := range lines.All(r) {
		if err != nil {
			t.Fatal(err)
		}
		collected = append(collected, line.String())
	}
	if len(collected) != 1 {
		t.Fatalf("expected 1 line, got %d", len(collected))
	}

	// Backward on single line
	r.Reset([]byte("single line"))
	collected = nil
	for line, err := range lines.Backward(r) {
		if err != nil {
			t.Fatal(err)
		}
		collected = append(collected, line.String())
	}
	if len(collected) != 1 {
		t.Fatalf("expected 1 line from backward, got %d", len(collected))
	}
	if collected[0] != "single line" {
		t.Fatalf("expected 'single line', got %q", collected[0])
	}
}

func TestCRLFLineEndings(t *testing.T) {
	data := []byte("line1\r\nline2\r\nline3")
	r := bytes.NewReader(data)

	var collected []string
	for line, err := range lines.All(r) {
		if err != nil {
			t.Fatal(err)
		}
		collected = append(collected, line.String())
	}

	if len(collected) != 3 {
		t.Fatalf("expected 3 lines, got %d", len(collected))
	}

	expected := []string{"line1", "line2", "line3"}
	for i, exp := range expected {
		if collected[i] != exp {
			t.Fatalf("line %d: expected %q, got %q", i+1, exp, collected[i])
		}
	}
}

func TestHeadMoreThanAvailable(t *testing.T) {
	data := []byte("line1\nline2\nline3")
	r := bytes.NewReader(data)

	count := 0
	for _, err := range lines.Head(r, 100) {
		if err != nil {
			t.Fatal(err)
		}
		count++
	}
	if count != 3 {
		t.Fatalf("expected 3 lines when requesting 100 from 3-line file, got %d", count)
	}
}

func TestTailMoreThanAvailable(t *testing.T) {
	data := []byte("line1\nline2\nline3")
	r := bytes.NewReader(data)

	count := 0
	for _, err := range lines.Tail(r, 100) {
		if err != nil {
			t.Fatal(err)
		}
		count++
	}
	if count != 3 {
		t.Fatalf("expected 3 lines when requesting 100 from 3-line file, got %d", count)
	}
}

func TestGetOutOfRange(t *testing.T) {
	data := []byte("line1\nline2\nline3")
	r := bytes.NewReader(data)

	// Line 0 should return nil
	line, err := lines.Get(lines.All(r), 0)
	if err != nil {
		t.Fatal(err)
	}
	if line != nil {
		t.Fatal("expected nil for line 0")
	}

	// Line beyond range
	r.Reset(data)
	line, err = lines.Get(lines.All(r), 100)
	if err != nil {
		t.Fatal(err)
	}
	if line != nil {
		t.Fatal("expected nil for line 100")
	}
}

func TestLineEqual(t *testing.T) {
	l1 := &lines.Line{Content: []byte("hello"), Number: 1}
	l2 := &lines.Line{Content: []byte("hello"), Number: 1}
	l3 := &lines.Line{Content: []byte("hello"), Number: 2}
	l4 := &lines.Line{Content: []byte("world"), Number: 1}

	if !l1.Equal(l2) {
		t.Fatal("expected l1 == l2")
	}
	if l1.Equal(l3) {
		t.Fatal("expected l1 != l3 (different number)")
	}
	if l1.Equal(l4) {
		t.Fatal("expected l1 != l4 (different content)")
	}
}

func TestJoin(t *testing.T) {
	result := lines.Join("a", "b", "c")
	if result != "a\nb\nc" {
		t.Fatalf("expected 'a\\nb\\nc', got %q", result)
	}

	// Empty join
	result = lines.Join[string]()
	if result != "" {
		t.Fatalf("expected empty string, got %q", result)
	}

	// Single element
	result = lines.Join("single")
	if result != "single" {
		t.Fatalf("expected 'single', got %q", result)
	}
}

func TestFilterWithNoMatches(t *testing.T) {
	data := []byte("line1\nline2\nline3")
	r := bytes.NewReader(data)

	count := 0
	for _, err := range lines.Filter(lines.All(r), "nonexistent") {
		if err != nil {
			t.Fatal(err)
		}
		count++
	}
	if count != 0 {
		t.Fatalf("expected 0 matches, got %d", count)
	}
}

func TestMain(m *testing.M) {
	m.Run()
}