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

// +build !build_with_native_toolchain

package pkgfs

import (
	"fmt"
	"testing"
	"time"

	"go.fuchsia.dev/fuchsia/src/lib/thinfs/fs"
)

var (
	entries = []string{
		"1111111111111111111111111111111111111111111111111111111111111111",
		"2222222222222222222222222222222222222222222222222222222222222222",
		"3333333333333333333333333333333333333333333333333333333333333333",
		"4444444444444444444444444444444444444444444444444444444444444444",
		"5555555555555555555555555555555555555555555555555555555555555555",
		"6666666666666666666666666666666666666666666666666666666666666666",
	}

	file = []byte(
		`1111111111111111111111111111111111111111111111111111111111111111
2222222222222222222222222222222222222222222222222222222222222222
3333333333333333333333333333333333333333333333333333333333333333
4444444444444444444444444444444444444444444444444444444444444444
5555555555555555555555555555555555555555555555555555555555555555
6666666666666666666666666666666666666666666666666666666666666666
`)
)

// TestWholeFileRead creates a buffer that is size of the expected file output
// and tries to read this from the file in one call.
func TestWholeFileRead(t *testing.T) {
	// read the whole file
	if lineSize != int64(len(entries[0])+1) {
		t.Fatal("test setup error: entries length doesn't match expected line size")
	}

	bufSize := len(file)
	buf := make([]byte, bufSize)

	vf := newTestValidationFile(entries)
	r, err := vf.Read(buf, 0, fs.WhenceFromCurrent)
	if err != nil {
		t.Fatalf("read failed: %s", err)
	}
	if r != len(file) {
		t.Fatalf("unexpected read length, expected %d, got %d", bufSize, r)
	}

	if err = compareBuffers(file, buf, 0, t); err != nil {
		t.Fatalf("%s", err)
	}

	r, err = vf.Read(buf[:1], 0, fs.WhenceFromCurrent)
	if err != fs.ErrEOF {
		t.Fatalf("EOF expected, instead found: %s", err)
	}
	if r != 0 {
		t.Fatalf("file read beyond end of file reported length %d", r)
	}
}

// TestOverRead creates a buffer larger than the whole file and passes that
// buffer into the read call.
func TestOverRead(t *testing.T) {
	// try to read more than the whole file
	if lineSize != int64(len(entries[0])+1) {
		t.Fatal("test setup error: entries length doesn't match expected line size")
	}

	bufSize := len(file) * 2
	buf := make([]byte, bufSize)

	vf := newTestValidationFile(entries)
	r, err := vf.Read(buf, 0, fs.WhenceFromCurrent)
	if err != fs.ErrEOF {
		t.Fatalf("EOF expected, instead found: %s", err)
	}
	if r != len(file) {
		t.Fatalf("unexpected read length, expected %d, got %d", bufSize, r)
	}

	if err = compareBuffers(file, buf[:len(file)], 0, t); err != nil {
		t.Fatalf("%s", err)
	}
}

// TestMultipleRead tries to read the first half of the file in one call and
// the remainder in the second call.
func TestMultipleRead(t *testing.T) {
	if lineSize != int64(len(entries[0])+1) {
		t.Fatal("test setup error: entries length doesn't match expected line size")
	}

	// read half the file and then the next half
	bufSize := len(file)
	buf := make([]byte, bufSize)

	vf := newTestValidationFile(entries)
	firstHalf := len(buf) / 2
	r, err := vf.Read(buf[0:firstHalf], 0, fs.WhenceFromCurrent)
	if r != firstHalf {
		t.Fatalf("unexpected read length reading first half of file, expected %d, got %d", firstHalf, r)
	}

	if err = compareBuffers(file[:firstHalf], buf[:firstHalf], 0, t); err != nil {
		t.Fatalf("%s", err)
	}

	remaining := len(buf) - firstHalf
	r, err = vf.Read(buf[firstHalf:], 0, fs.WhenceFromCurrent)
	if r != remaining {
		t.Fatalf("unexpected read length reading first half of file, expected %d, got %d", remaining, r)
	}

	if err = compareBuffers(file[firstHalf:], buf[firstHalf:], firstHalf, t); err != nil {
		t.Fatalf("%s", err)
	}
}

// TestSeekToLineBoundary tests what happens if we first seek to the end of an
// entry, before the newline, and then read a line's worth of bytes.
func TestSeekToLineBounary(t *testing.T) {
	buf := make([]byte, lineSize)
	seekOffset := lineSize - 1

	vf := newTestValidationFile(entries)
	r, err := vf.Read(buf, seekOffset, fs.WhenceFromCurrent)
	if r != len(buf) {
		t.Fatalf("unexpected read length, expected %d got %d", len(buf), r)
	}

	if err = compareBuffers(file[seekOffset:], buf, int(seekOffset), t); err != nil {
		t.Fatalf("%s", err)
	}
}

// TestNewLineAdded tests what happens if we read a whole entry without the new
// line and then reads one more byte, which should be the new line
func TestNewLineAdded(t *testing.T) {
	// read 64 bytes, then read one more
	buf := make([]byte, lineSize)
	vf := newTestValidationFile(entries)
	firstRead := len(buf) - 1
	r, err := vf.Read(buf[0:firstRead], 0, fs.WhenceFromCurrent)

	if r != firstRead {
		t.Fatalf("unexpected read length reading first part of entry, expected %d, got %d",
			firstRead, r)
	}

	if err = compareBuffers(file[:firstRead], buf[:firstRead], 0, t); err != nil {
		t.Fatalf("%s", err)
	}

	r, err = vf.Read(buf[firstRead:], 0, fs.WhenceFromCurrent)
	if r != len(buf)-firstRead {
		t.Fatalf("unexpected read length reading second part of entry, expecting %d, got %d",
			len(buf)-firstRead, r)
	}

	if err = compareBuffers(file[firstRead:], buf[firstRead:], firstRead, t); err != nil {
		t.Fatalf("%s", err)
	}
}

// TestReadsAcrossEntries reads half an entry and then a full entry's worth of
// data.
func TestReadsAcrossEntries(t *testing.T) {
	// read half of an entry, read a full entry's worth

	if lineSize != int64(len(entries[0])+1) {
		t.Fatal("test setup error: entries length doesn't match expected line size")
	}

	buf := make([]byte, lineSize)
	vf := newTestValidationFile(entries)
	firstRead := len(buf) / 2
	r, err := vf.Read(buf[0:firstRead], 0, fs.WhenceFromCurrent)

	if r != firstRead {
		t.Fatalf("unexpected read length reading first half of entry, expected %d, got %d",
			firstRead, r)
	}

	if err = compareBuffers(file[:firstRead], buf[:firstRead], 0, t); err != nil {
		t.Fatalf("%s", err)
	}

	r, err = vf.Read(buf[firstRead:], 0, fs.WhenceFromCurrent)
	if r != len(buf)-firstRead {
		t.Fatalf("unexpected read length reading second half of entry, expecting %d, got %d",
			len(buf)-firstRead, r)
	}

	if err = compareBuffers(file[firstRead:], buf[firstRead:], firstRead, t); err != nil {
		t.Fatalf("%s", err)
	}
}

// TestBackwardSeek checks what happens if we read the whole file and then seek
// backward an entry and a half.
func TestBackwardSeek(t *testing.T) {
	if lineSize != int64(len(entries[0])+1) {
		t.Fatal("test setup error: entries length doesn't match expected line size")
	}
	bufSize := len(file)
	buf := make([]byte, bufSize)

	vf := newTestValidationFile(entries)
	r, err := vf.Read(buf, 0, fs.WhenceFromCurrent)
	if err != nil {
		t.Fatalf("read failed: %s", err)
	}
	if r != len(file) {
		t.Fatalf("unexpected read length, expected %d, got %d", bufSize, r)
	}

	if err = compareBuffers(file, buf[:len(file)], 0, t); err != nil {
		t.Fatalf("%s", err)
	}

	secondReadSz := lineSize * 3 / 2
	r, err = vf.Read(buf, 0-secondReadSz, fs.WhenceFromCurrent)
	if err != fs.ErrEOF {
		t.Fatalf("read expected EOF, but got: %s", err)
	}
	if int64(r) != secondReadSz {
		t.Fatalf("unexpected read length, expected %d, got %d", secondReadSz, r)
	}
	fileOffset := len(file) - int(secondReadSz)
	if err = compareBuffers(file[fileOffset:], buf[:secondReadSz], fileOffset, t); err != nil {
		t.Fatalf("%s", err)
	}
}

func newTestValidationFile(entries []string) *validationFile {
	return &validationFile{
		unsupportedFile: unsupportedFile("testing"),
		entries:         entries,
		statTime:        time.Now(),
	}
}

func compareBuffers(expect, actual []byte, off int, t *testing.T) error {
	var err error
	for i, b := range actual {
		if expect[i] != b {
			err = fmt.Errorf("buffers differ")
			t.Errorf("read file differs at index %d, expected %q, got %q", off+i, expect[i], b)
		}
	}
	return err
}