// Copyright 2011 The LevelDB-Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Taken from: https://code.google.com/p/leveldb-go/source/browse/leveldb/record/record_test.go?r=df1fa28f7f3be6c3935548169002309c12967135
// License, authors and contributors informations can be found at bellow URLs respectively:
// 	https://code.google.com/p/leveldb-go/source/browse/LICENSE
//	https://code.google.com/p/leveldb-go/source/browse/AUTHORS
//  https://code.google.com/p/leveldb-go/source/browse/CONTRIBUTORS

package journal

import (
	"bytes"
	"encoding/binary"
	"fmt"
	"io"
	"io/ioutil"
	"math/rand"
	"strings"
	"testing"

	"github.com/stretchr/testify/require"
)

type dropper struct {
	t *testing.T
}

func (d dropper) Drop(err error) {
	d.t.Log(err)
}

func short(s string) string {
	if len(s) < 64 {
		return s
	}
	return fmt.Sprintf("%s...(skipping %d bytes)...%s", s[:20], len(s)-40, s[len(s)-20:])
}

// big returns a string of length n, composed of repetitions of partial.
func big(partial string, n int) string {
	return strings.Repeat(partial, n/len(partial)+1)[:n]
}

func TestEmpty(t *testing.T) {
	buf := new(bytes.Buffer)
	r := NewReader(buf, dropper{t}, true, true)
	if _, err := r.Next(); err != io.EOF {
		t.Fatalf("got %v, want %v", err, io.EOF)
	}
}

func testGenerator(t *testing.T, reset func(), gen func() (string, bool)) {
	buf := new(bytes.Buffer)

	reset()
	w := NewWriter(buf)
	for {
		s, ok := gen()
		if !ok {
			break
		}
		ww, err := w.Next()
		if err != nil {
			t.Fatal(err)
		}
		if _, err := ww.Write([]byte(s)); err != nil {
			t.Fatal(err)
		}
	}
	if err := w.Close(); err != nil {
		t.Fatal(err)
	}

	reset()
	r := NewReader(buf, dropper{t}, true, true)
	for {
		s, ok := gen()
		if !ok {
			break
		}
		rr, err := r.Next()
		if err != nil {
			t.Fatal(err)
		}
		x, err := ioutil.ReadAll(rr)
		if err != nil {
			t.Fatal(err)
		}
		if string(x) != s {
			t.Fatalf("got %q, want %q", short(string(x)), short(s))
		}
	}
	if _, err := r.Next(); err != io.EOF {
		t.Fatalf("got %v, want %v", err, io.EOF)
	}
}

func testLiterals(t *testing.T, s []string) {
	var i int
	reset := func() {
		i = 0
	}
	gen := func() (string, bool) {
		if i == len(s) {
			return "", false
		}
		i++
		return s[i-1], true
	}
	testGenerator(t, reset, gen)
}

func TestMany(t *testing.T) {
	const n = 1e5
	var i int
	reset := func() {
		i = 0
	}
	gen := func() (string, bool) {
		if i == n {
			return "", false
		}
		i++
		return fmt.Sprintf("%d.", i-1), true
	}
	testGenerator(t, reset, gen)
}

func TestRandom(t *testing.T) {
	const n = 1e2
	var (
		i int
		r *rand.Rand
	)
	reset := func() {
		i, r = 0, rand.New(rand.NewSource(0))
	}
	gen := func() (string, bool) {
		if i == n {
			return "", false
		}
		i++
		return strings.Repeat(string(uint8(i)), r.Intn(2*blockSize+16)), true
	}
	testGenerator(t, reset, gen)
}

func TestBasic(t *testing.T) {
	testLiterals(t, []string{
		strings.Repeat("a", 1000),
		strings.Repeat("b", 97270),
		strings.Repeat("c", 8000),
	})
}

func TestBoundary(t *testing.T) {
	for i := blockSize - 16; i < blockSize+16; i++ {
		s0 := big("abcd", i)
		for j := blockSize - 16; j < blockSize+16; j++ {
			s1 := big("ABCDE", j)
			testLiterals(t, []string{s0, s1})
			testLiterals(t, []string{s0, "", s1})
			testLiterals(t, []string{s0, "x", s1})
		}
	}
}

func TestFlush(t *testing.T) {
	buf := new(bytes.Buffer)
	w := NewWriter(buf)
	// Write a couple of records. Everything should still be held
	// in the record.Writer buffer, so that buf.Len should be 0.
	w0, _ := w.Next()
	if _, err := w0.Write([]byte("0")); err != nil {
		t.Fatal(err)
	}
	w1, _ := w.Next()
	if _, err := w1.Write([]byte("11")); err != nil {
		t.Fatal(err)
	}
	if got, want := buf.Len(), 0; got != want {
		t.Fatalf("buffer length #0: got %d want %d", got, want)
	}
	// Flush the record.Writer buffer, which should yield 17 bytes.
	// 17 = 2*7 + 1 + 2, which is two headers and 1 + 2 payload bytes.
	if err := w.Flush(); err != nil {
		t.Fatal(err)
	}
	if got, want := buf.Len(), 17; got != want {
		t.Fatalf("buffer length #1: got %d want %d", got, want)
	}
	// Do another write, one that isn't large enough to complete the block.
	// The write should not have flowed through to buf.
	w2, _ := w.Next()
	if _, err := w2.Write(bytes.Repeat([]byte("2"), 10000)); err != nil {
		t.Fatal(err)
	}
	if got, want := buf.Len(), 17; got != want {
		t.Fatalf("buffer length #2: got %d want %d", got, want)
	}
	// Flushing should get us up to 10024 bytes written.
	// 10024 = 17 + 7 + 10000.
	if err := w.Flush(); err != nil {
		t.Fatal(err)
	}
	if got, want := buf.Len(), 10024; got != want {
		t.Fatalf("buffer length #3: got %d want %d", got, want)
	}
	// Do a bigger write, one that completes the current block.
	// We should now have 32768 bytes (a complete block), without
	// an explicit flush.
	w3, _ := w.Next()
	if _, err := w3.Write(bytes.Repeat([]byte("3"), 40000)); err != nil {
		t.Fatal(err)
	}
	if got, want := buf.Len(), 32768; got != want {
		t.Fatalf("buffer length #4: got %d want %d", got, want)
	}
	// Flushing should get us up to 50038 bytes written.
	// 50038 = 10024 + 2*7 + 40000. There are two headers because
	// the one record was split into two chunks.
	if err := w.Flush(); err != nil {
		t.Fatal(err)
	}
	if got, want := buf.Len(), 50038; got != want {
		t.Fatalf("buffer length #5: got %d want %d", got, want)
	}
	// Check that reading those records give the right lengths.
	r := NewReader(buf, dropper{t}, true, true)
	wants := []int64{1, 2, 10000, 40000}
	for i, want := range wants {
		rr, _ := r.Next()
		n, err := io.Copy(ioutil.Discard, rr)
		if err != nil {
			t.Fatalf("read #%d: %v", i, err)
		}
		if n != want {
			t.Fatalf("read #%d: got %d bytes want %d", i, n, want)
		}
	}
}

func TestNonExhaustiveRead(t *testing.T) {
	const n = 100
	buf := new(bytes.Buffer)
	p := make([]byte, 10)
	rnd := rand.New(rand.NewSource(1))

	w := NewWriter(buf)
	for i := 0; i < n; i++ {
		length := len(p) + rnd.Intn(3*blockSize)
		s := string(uint8(i)) + "123456789abcdefgh"
		ww, _ := w.Next()
		if _, err := ww.Write([]byte(big(s, length))); err != nil {
			t.Fatal(err)
		}
	}
	if err := w.Close(); err != nil {
		t.Fatal(err)
	}

	r := NewReader(buf, dropper{t}, true, true)
	for i := 0; i < n; i++ {
		rr, _ := r.Next()
		_, err := io.ReadFull(rr, p)
		if err != nil {
			t.Fatal(err)
		}
		want := string(uint8(i)) + "123456789"
		if got := string(p); got != want {
			t.Fatalf("read #%d: got %q want %q", i, got, want)
		}
	}
}

func TestStaleReader(t *testing.T) {
	buf := new(bytes.Buffer)

	w := NewWriter(buf)
	w0, err := w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := w0.Write([]byte("0")); err != nil {
		t.Fatal(err)
	}
	w1, err := w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := w1.Write([]byte("11")); err != nil {
		t.Fatal(err)
	}
	if err := w.Close(); err != nil {
		t.Fatal(err)
	}

	r := NewReader(buf, dropper{t}, true, true)
	r0, err := r.Next()
	if err != nil {
		t.Fatal(err)
	}
	r1, err := r.Next()
	if err != nil {
		t.Fatal(err)
	}
	p := make([]byte, 1)
	if _, err := r0.Read(p); err == nil || !strings.Contains(err.Error(), "stale") {
		t.Fatalf("stale read #0: unexpected error: %v", err)
	}
	if _, err := r1.Read(p); err != nil {
		t.Fatalf("fresh read #1: got %v want nil error", err)
	}
	if p[0] != '1' {
		t.Fatalf("fresh read #1: byte contents: got '%c' want '1'", p[0])
	}
}

func TestStaleWriter(t *testing.T) {
	buf := new(bytes.Buffer)

	w := NewWriter(buf)
	w0, err := w.Next()
	if err != nil {
		t.Fatal(err)
	}
	w1, err := w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := w0.Write([]byte("0")); err == nil || !strings.Contains(err.Error(), "stale") {
		t.Fatalf("stale write #0: unexpected error: %v", err)
	}
	if _, err := w1.Write([]byte("11")); err != nil {
		t.Fatalf("fresh write #1: got %v want nil error", err)
	}
	if err := w.Flush(); err != nil {
		t.Fatalf("flush: %v", err)
	}
	if _, err := w1.Write([]byte("0")); err == nil || !strings.Contains(err.Error(), "stale") {
		t.Fatalf("stale write #1: unexpected error: %v", err)
	}
}

func TestSize(t *testing.T) {
	var buf bytes.Buffer
	zeroes := make([]byte, 8<<10)
	w := NewWriter(&buf)
	for i := 0; i < 100; i++ {
		writer, err := w.Next()
		require.NoError(t, err)

		for j := 0; j < rand.Intn(10); j++ {
			n := rand.Intn(len(zeroes))
			_, err = writer.Write(zeroes[:n])
			require.NoError(t, err)
		}

		require.NoError(t, w.Flush())
		if buf.Len() != int(w.Size()) {
			t.Fatalf("expected %d, but found %d", buf.Len(), w.Size())
		}
	}
	require.NoError(t, w.Close())
}

func TestCorrupt_MissingLastBlock(t *testing.T) {
	buf := new(bytes.Buffer)

	w := NewWriter(buf)

	// First record.
	ww, err := w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize-1024)); err != nil {
		t.Fatalf("write #0: unexpected error: %v", err)
	}

	// Second record.
	ww, err = w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize-headerSize)); err != nil {
		t.Fatalf("write #1: unexpected error: %v", err)
	}

	if err := w.Close(); err != nil {
		t.Fatal(err)
	}

	// Cut the last block.
	b := buf.Bytes()[:blockSize]
	r := NewReader(bytes.NewReader(b), dropper{t}, false, true)

	// First read.
	rr, err := r.Next()
	if err != nil {
		t.Fatal(err)
	}
	n, err := io.Copy(ioutil.Discard, rr)
	if err != nil {
		t.Fatalf("read #0: %v", err)
	}
	if n != blockSize-1024 {
		t.Fatalf("read #0: got %d bytes want %d", n, blockSize-1024)
	}

	// Second read.
	rr, err = r.Next()
	if err != nil {
		t.Fatal(err)
	}
	_, err = io.Copy(ioutil.Discard, rr)
	if err != io.ErrUnexpectedEOF {
		t.Fatalf("read #1: unexpected error: %v", err)
	}

	if _, err := r.Next(); err != io.EOF {
		t.Fatalf("last next: unexpected error: %v", err)
	}
}

func TestCorrupt_CorruptedFirstBlock(t *testing.T) {
	buf := new(bytes.Buffer)

	w := NewWriter(buf)

	// First record.
	ww, err := w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize/2)); err != nil {
		t.Fatalf("write #0: unexpected error: %v", err)
	}

	// Second record.
	ww, err = w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize-headerSize)); err != nil {
		t.Fatalf("write #1: unexpected error: %v", err)
	}

	// Third record.
	ww, err = w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), (blockSize-headerSize)+1)); err != nil {
		t.Fatalf("write #2: unexpected error: %v", err)
	}

	// Fourth record.
	ww, err = w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), (blockSize-headerSize)+2)); err != nil {
		t.Fatalf("write #3: unexpected error: %v", err)
	}

	if err := w.Close(); err != nil {
		t.Fatal(err)
	}

	b := buf.Bytes()
	// Corrupting block #0.
	for i := 0; i < 1024; i++ {
		b[i] = '1'
	}

	r := NewReader(bytes.NewReader(b), dropper{t}, false, true)

	// First read (third record).
	rr, err := r.Next()
	if err != nil {
		t.Fatal(err)
	}
	n, err := io.Copy(ioutil.Discard, rr)
	if err != nil {
		t.Fatalf("read #0: %v", err)
	}
	if want := int64(blockSize-headerSize) + 1; n != want {
		t.Fatalf("read #0: got %d bytes want %d", n, want)
	}

	// Second read (fourth record).
	rr, err = r.Next()
	if err != nil {
		t.Fatal(err)
	}
	n, err = io.Copy(ioutil.Discard, rr)
	if err != nil {
		t.Fatalf("read #1: %v", err)
	}
	if want := int64(blockSize-headerSize) + 2; n != want {
		t.Fatalf("read #1: got %d bytes want %d", n, want)
	}

	if _, err := r.Next(); err != io.EOF {
		t.Fatalf("last next: unexpected error: %v", err)
	}
}

func TestCorrupt_CorruptedMiddleBlock(t *testing.T) {
	buf := new(bytes.Buffer)

	w := NewWriter(buf)

	// First record.
	ww, err := w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize/2)); err != nil {
		t.Fatalf("write #0: unexpected error: %v", err)
	}

	// Second record.
	ww, err = w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize-headerSize)); err != nil {
		t.Fatalf("write #1: unexpected error: %v", err)
	}

	// Third record.
	ww, err = w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), (blockSize-headerSize)+1)); err != nil {
		t.Fatalf("write #2: unexpected error: %v", err)
	}

	// Fourth record.
	ww, err = w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), (blockSize-headerSize)+2)); err != nil {
		t.Fatalf("write #3: unexpected error: %v", err)
	}

	if err := w.Close(); err != nil {
		t.Fatal(err)
	}

	b := buf.Bytes()
	// Corrupting block #1.
	for i := 0; i < 1024; i++ {
		b[blockSize+i] = '1'
	}

	r := NewReader(bytes.NewReader(b), dropper{t}, false, true)

	// First read (first record).
	rr, err := r.Next()
	if err != nil {
		t.Fatal(err)
	}
	n, err := io.Copy(ioutil.Discard, rr)
	if err != nil {
		t.Fatalf("read #0: %v", err)
	}
	if want := int64(blockSize / 2); n != want {
		t.Fatalf("read #0: got %d bytes want %d", n, want)
	}

	// Second read (second record).
	rr, err = r.Next()
	if err != nil {
		t.Fatal(err)
	}
	_, err = io.Copy(ioutil.Discard, rr)
	if err != io.ErrUnexpectedEOF {
		t.Fatalf("read #1: unexpected error: %v", err)
	}

	// Third read (fourth record).
	rr, err = r.Next()
	if err != nil {
		t.Fatal(err)
	}
	n, err = io.Copy(ioutil.Discard, rr)
	if err != nil {
		t.Fatalf("read #2: %v", err)
	}
	if want := int64(blockSize-headerSize) + 2; n != want {
		t.Fatalf("read #2: got %d bytes want %d", n, want)
	}

	if _, err := r.Next(); err != io.EOF {
		t.Fatalf("last next: unexpected error: %v", err)
	}
}

func TestCorrupt_CorruptedLastBlock(t *testing.T) {
	buf := new(bytes.Buffer)

	w := NewWriter(buf)

	// First record.
	ww, err := w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize/2)); err != nil {
		t.Fatalf("write #0: unexpected error: %v", err)
	}

	// Second record.
	ww, err = w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize-headerSize)); err != nil {
		t.Fatalf("write #1: unexpected error: %v", err)
	}

	// Third record.
	ww, err = w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), (blockSize-headerSize)+1)); err != nil {
		t.Fatalf("write #2: unexpected error: %v", err)
	}

	// Fourth record.
	ww, err = w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), (blockSize-headerSize)+2)); err != nil {
		t.Fatalf("write #3: unexpected error: %v", err)
	}

	if err := w.Close(); err != nil {
		t.Fatal(err)
	}

	b := buf.Bytes()
	// Corrupting block #3.
	for i := len(b) - 1; i > len(b)-1024; i-- {
		b[i] = '1'
	}

	r := NewReader(bytes.NewReader(b), dropper{t}, false, true)

	// First read (first record).
	rr, err := r.Next()
	if err != nil {
		t.Fatal(err)
	}
	n, err := io.Copy(ioutil.Discard, rr)
	if err != nil {
		t.Fatalf("read #0: %v", err)
	}
	if want := int64(blockSize / 2); n != want {
		t.Fatalf("read #0: got %d bytes want %d", n, want)
	}

	// Second read (second record).
	rr, err = r.Next()
	if err != nil {
		t.Fatal(err)
	}
	n, err = io.Copy(ioutil.Discard, rr)
	if err != nil {
		t.Fatalf("read #1: %v", err)
	}
	if want := int64(blockSize - headerSize); n != want {
		t.Fatalf("read #1: got %d bytes want %d", n, want)
	}

	// Third read (third record).
	rr, err = r.Next()
	if err != nil {
		t.Fatal(err)
	}
	n, err = io.Copy(ioutil.Discard, rr)
	if err != nil {
		t.Fatalf("read #2: %v", err)
	}
	if want := int64(blockSize-headerSize) + 1; n != want {
		t.Fatalf("read #2: got %d bytes want %d", n, want)
	}

	// Fourth read (fourth record).
	rr, err = r.Next()
	if err != nil {
		t.Fatal(err)
	}
	_, err = io.Copy(ioutil.Discard, rr)
	if err != io.ErrUnexpectedEOF {
		t.Fatalf("read #3: unexpected error: %v", err)
	}

	if _, err := r.Next(); err != io.EOF {
		t.Fatalf("last next: unexpected error: %v", err)
	}
}

func TestCorrupt_FirstChuckLengthOverflow(t *testing.T) {
	buf := new(bytes.Buffer)

	w := NewWriter(buf)

	// First record.
	ww, err := w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize/2)); err != nil {
		t.Fatalf("write #0: unexpected error: %v", err)
	}

	// Second record.
	ww, err = w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize-headerSize)); err != nil {
		t.Fatalf("write #1: unexpected error: %v", err)
	}

	// Third record.
	ww, err = w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), (blockSize-headerSize)+1)); err != nil {
		t.Fatalf("write #2: unexpected error: %v", err)
	}

	if err := w.Close(); err != nil {
		t.Fatal(err)
	}

	b := buf.Bytes()
	// Corrupting record #1.
	x := blockSize
	binary.LittleEndian.PutUint16(b[x+4:], 0xffff)

	r := NewReader(bytes.NewReader(b), dropper{t}, false, true)

	// First read (first record).
	rr, err := r.Next()
	if err != nil {
		t.Fatal(err)
	}
	n, err := io.Copy(ioutil.Discard, rr)
	if err != nil {
		t.Fatalf("read #0: %v", err)
	}
	if want := int64(blockSize / 2); n != want {
		t.Fatalf("read #0: got %d bytes want %d", n, want)
	}

	// Second read (second record).
	rr, err = r.Next()
	if err != nil {
		t.Fatal(err)
	}
	_, err = io.Copy(ioutil.Discard, rr)
	if err != io.ErrUnexpectedEOF {
		t.Fatalf("read #1: unexpected error: %v", err)
	}

	if _, err := r.Next(); err != io.EOF {
		t.Fatalf("last next: unexpected error: %v", err)
	}
}

func TestCorrupt_MiddleChuckLengthOverflow(t *testing.T) {
	buf := new(bytes.Buffer)

	w := NewWriter(buf)

	// First record.
	ww, err := w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize/2)); err != nil {
		t.Fatalf("write #0: unexpected error: %v", err)
	}

	// Second record.
	ww, err = w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), blockSize-headerSize)); err != nil {
		t.Fatalf("write #1: unexpected error: %v", err)
	}

	// Third record.
	ww, err = w.Next()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := ww.Write(bytes.Repeat([]byte("0"), (blockSize-headerSize)+1)); err != nil {
		t.Fatalf("write #2: unexpected error: %v", err)
	}

	if err := w.Close(); err != nil {
		t.Fatal(err)
	}

	b := buf.Bytes()
	// Corrupting record #1.
	x := blockSize/2 + headerSize
	binary.LittleEndian.PutUint16(b[x+4:], 0xffff)

	r := NewReader(bytes.NewReader(b), dropper{t}, false, true)

	// First read (first record).
	rr, err := r.Next()
	if err != nil {
		t.Fatal(err)
	}
	n, err := io.Copy(ioutil.Discard, rr)
	if err != nil {
		t.Fatalf("read #0: %v", err)
	}
	if want := int64(blockSize / 2); n != want {
		t.Fatalf("read #0: got %d bytes want %d", n, want)
	}

	// Second read (third record).
	rr, err = r.Next()
	if err != nil {
		t.Fatal(err)
	}
	n, err = io.Copy(ioutil.Discard, rr)
	if err != nil {
		t.Fatalf("read #1: %v", err)
	}
	if want := int64(blockSize-headerSize) + 1; n != want {
		t.Fatalf("read #1: got %d bytes want %d", n, want)
	}

	if _, err := r.Next(); err != io.EOF {
		t.Fatalf("last next: unexpected error: %v", err)
	}
}
