// The WAL branches the round-trip tests do not reach: Open's two path errors,
// the periodic fsync, the early stop of ForEach/ForEachFrom, and the error
// returns a closed segment produces. Rotation needs a 4GB segment
// (MaxSegSize is 1<<32) and is the one branch left to the integration store.
package wal

import (
	"bytes"
	"os"
	"testing"
)

func TestOpenFailsOnUnopenablePaths(t *testing.T) {
	dir, ok := walTmp(t)
	if !ok {
		return
	}
	defer os.RemoveAll(dir)

	// A regular file where the wal directory belongs.
	if err := os.WriteFile(dir|"/wal", []byte("not a directory"), 0644); err != nil {
		t.Fatal(err)
	}
	if w, oerr := Open(dir | "/wal"); oerr == nil {
		w.Close()
		t.Fatal("Open must fail when the wal path is a file")
	}

	// A segment that cannot be opened.
	dir2, ok2 := walTmp(t)
	if !ok2 {
		return
	}
	defer os.RemoveAll(dir2)
	if err := os.MkdirAll(dir2|"/seg-0000000000000000.dat", 0755); err != nil {
		t.Fatal(err)
	}
	if w, oerr := Open(dir2); oerr == nil {
		w.Close()
		t.Fatal("Open must fail when a segment cannot be opened")
	}
}

func TestAppendSyncsEveryNWrites(t *testing.T) {
	dir, ok := walTmp(t)
	if !ok {
		return
	}
	defer os.RemoveAll(dir)

	w, err := Open(dir)
	if err != nil {
		t.Fatal(err)
		return
	}
	defer w.Close()

	// Open sets syncEvery to 100; lowering it makes the periodic fsync branch
	// reachable without 100 appends per case.
	w.syncEvery = 2
	names := [][]byte{[]byte("a"), []byte("b"), []byte("c"), []byte("d")}
	var serials []uint64
	for _, n := range names {
		ser, aerr := w.Append(n)
		if aerr != nil {
			t.Fatal(aerr)
			return
		}
		serials = push(serials, ser)
	}
	for i, ser := range serials {
		got, rerr := w.Read(ser)
		if rerr != nil {
			t.Fatal(rerr)
			return
		}
		if !bytes.Equal(got, names[i]) {
			t.Fatalf("entry %d = %s", i, string(got))
		}
	}
}

func TestForEachStopsOnFalse(t *testing.T) {
	dir, ok := walTmp(t)
	if !ok {
		return
	}
	defer os.RemoveAll(dir)

	w, err := Open(dir)
	if err != nil {
		t.Fatal(err)
		return
	}
	defer w.Close()
	for _, n := range [][]byte{[]byte("one"), []byte("two"), []byte("three")} {
		if _, aerr := w.Append(n); aerr != nil {
			t.Fatal(aerr)
			return
		}
	}

	// A callback that refuses the first entry ends the walk after one call.
	calls := int32(0)
	stop := func(ser uint64, data []byte) bool {
		calls++
		return false
	}
	if ferr := w.ForEach(stop); ferr != nil {
		t.Fatal(ferr)
		return
	}
	if calls != 1 {
		t.Fatalf("ForEach called the callback %d times, want 1", calls)
	}

	// ForEachFrom stops the same way, from the entry after the start serial.
	calls2 := int32(0)
	stop2 := func(ser uint64, data []byte) bool {
		calls2++
		return false
	}
	fourth, aerr3 := w.Append([]byte("four"))
	if aerr3 != nil {
		t.Fatal(aerr3)
		return
	}
	if _, aerr4 := w.Append([]byte("five")); aerr4 != nil {
		t.Fatal(aerr4)
		return
	}
	if ferr3 := w.ForEachFrom(fourth, stop2); ferr3 != nil {
		t.Fatal(ferr3)
		return
	}
	if calls2 != 1 {
		t.Fatalf("ForEachFrom called the callback %d times, want 1", calls2)
	}
}