package s3

import (
	cryptorand "crypto/rand"
	"errors"
	"io"
	"os"
	"testing"
	"time"

	"github.com/matryer/is"
	"github.com/spf13/afero"
)

var (
	testdata = []byte("testdata")
)

func TestFsListBuckets(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	var err error
	buckets, err := testListBuckets(afs.Fs.(*Fs))
	is.NoErr(err)
	is.Equal(len(buckets), 1)
}

func TestFsMkdir(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	err := afs.Mkdir("test", 0o644)
	is.Equal(err, ErrUnsupported)
}

func TestFsMkdirAll(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	err := afs.MkdirAll("test1/test2", 0o644)
	is.Equal(err, ErrUnsupported)
}

func TestFsChmod(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	err := afs.Chmod("test", 0o644)
	is.Equal(err, ErrUnsupported)
}

func TestFsChown(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	err := afs.Chown("test", 1000, 1000)
	is.Equal(err, ErrUnsupported)
}

func TestFsChtimes(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	var err error
	now := time.Now()
	err = afs.Chtimes("test", now, now)
	is.Equal(err, ErrUnsupported)
}

func TestFsWriteFile(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	err := afs.WriteFile("dir/file.txt", testdata, 0)
	is.NoErr(err)
}

func TestFsWriteError(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	f, err := afs.Fs.Create("dir/file.txt")
	is.NoErr(err)
	_, err = f.Write(testdata)
	is.NoErr(err)
	err = f.(*File).CloseWriterWithError(errors.New("disk died"))
	is.NoErr(err)
	_, err = afs.Stat("dir/file.txt")
	is.Equal(err, os.ErrNotExist)
}

func TestFsWrite17MB(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	f, err := afs.Fs.Create("dir/file.txt")
	is.NoErr(err)
	r := io.LimitReader(cryptorand.Reader, 17*(1<<20))
	_, err = io.Copy(f, r)
	is.NoErr(err)
	err = f.Close()
	is.NoErr(err)
	info, err := afs.Stat("dir/file.txt")
	is.NoErr(err)
	is.Equal(info.Size(), int64(17*(1<<20)))
}

func TestFsStat(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	var err error
	err = afs.WriteFile("dir/file.txt", testdata, 0)
	is.NoErr(err)
	info, err := afs.Stat("dir/file.txt")
	is.NoErr(err)
	is.Equal(info.Name(), "file.txt")
	is.Equal(info.Size(), int64(8))
}

func TestFsStatNoExist(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	var err error
	_, err = afs.Stat("dir/non-existent")
	is.Equal(err, afero.ErrFileNotFound)
}

func TestFsReadFile(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	var err error
	err = afs.WriteFile("dir/file.txt", testdata, 0)
	is.NoErr(err)
	b, err := afs.ReadFile("dir/file.txt")
	is.NoErr(err)
	is.Equal(b, testdata)
}

func TestFsReadNoExist(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	var err error
	_, err = afs.ReadFile("non-existent")
	is.Equal(err, afero.ErrFileNotFound)
}

func TestFsRemove(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	var err error
	err = afs.WriteFile("dir/file.txt", testdata, 0)
	is.NoErr(err)

	_, err = afs.ReadFile("dir/file.txt")
	is.NoErr(err)

	err = afs.Remove("dir/file.txt")
	is.NoErr(err)

	_, err = afs.ReadFile("dir/file.txt")
	is.Equal(err, afero.ErrFileNotFound)
}

func TestFsRemoveNoExist(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	var err error
	_, err = afs.ReadFile("non-existent")
	is.Equal(err, afero.ErrFileNotFound)

	err = afs.Remove("non-existent")
	is.NoErr(err)
}

func TestFsRemoveAll(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	var err error
	err = afs.WriteFile("dir/file1", testdata, 0)
	is.NoErr(err)
	err = afs.WriteFile("dir/file2", testdata, 0)
	is.NoErr(err)
	err = afs.WriteFile("persist/file0", testdata, 0)
	is.NoErr(err)
	err = afs.RemoveAll("dir/")
	is.NoErr(err)
	_, err = afs.Stat("persist/file0")
	is.NoErr(err)
	err = afs.RemoveAll("persist/")
	is.NoErr(err)
}

func TestFsRename(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	var err error
	err = afs.WriteFile("dir/file", testdata, 0)
	is.NoErr(err)
	err = afs.Rename("dir/file", "dir/file2")
	is.NoErr(err)
	_, err = afs.Stat("dir/file2")
	is.NoErr(err)
	_, err = afs.Stat("dir/file")
	is.Equal(err, os.ErrNotExist)
	err = afs.Remove("dir/file2")
	is.NoErr(err)
}

func TestFsReadDir(t *testing.T) {
	is := is.New(t)
	afs, cleanup := newTestAfs()
	defer cleanup()

	var err error
	err = afs.WriteFile("dir/file1", []byte(""), 0)
	is.NoErr(err)
	err = afs.WriteFile("dir/file2", []byte(""), 0)
	is.NoErr(err)
	err = afs.WriteFile("dir/subdir/file3", []byte(""), 0)
	is.NoErr(err)
	defer afs.RemoveAll("/")

	infos, err := afs.ReadDir("dir/")
	is.NoErr(err)
	is.Equal(len(infos), 3)
	is.Equal(infos[0].Name(), "file1")
	is.Equal(infos[1].Name(), "file2")
	is.Equal(infos[2].IsDir(), true)
	is.Equal(infos[2].Name(), "subdir/")

	f, err := afs.Open("dir/")
	is.NoErr(err)
	names, err := f.Readdirnames(-1)
	is.NoErr(err)
	is.Equal(names, []string{"subdir/"})
}

func testListBuckets(fs *Fs) ([]string, error) {
	ctx, cancel := fs.contextWithTimeout()
	defer cancel()
	bucketInfos, err := fs.client.ListBuckets(ctx)
	if err != nil {
		return nil, err
	}
	buckets := make([]string, 0, len(bucketInfos))
	for _, bi := range bucketInfos {
		buckets = append(buckets, bi.Name)
	}
	return buckets, nil
}