package fs_test

import (
	"bytes"
	"os"
	"path/filepath"
	"slices"
	"sync"
	"testing"

	"galaxy/game/internal/repo/fs"
	"galaxy/util"

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

type sampleData struct {
	data []byte
}

func (sd *sampleData) UnmarshalBinary(data []byte) error {
	sd.data = slices.Clone(data)
	return nil
}

func (sd sampleData) MarshalBinary() (data []byte, err error) {
	return sd.data, nil
}

func TestNewFileStorageSuccess(t *testing.T) {
	root, cleanup := util.CreateWorkDir(t)
	defer cleanup()
	_, err := fs.NewFileStorage(root)
	assert.NoError(t, err)
}

func TestExist(t *testing.T) {
	root, cleanup := util.CreateWorkDir(t)
	defer cleanup()

	fileName := "some-file.ext"
	if err := os.WriteFile(filepath.Join(root, fileName), []byte{1, 2, 3, 4}, os.ModePerm); err != nil {
		t.Fatal(err)
	}

	fs, err := fs.NewFileStorage(root)
	assert.NoError(t, err, "create file storage")

	exist, err := fs.Exists(fileName)
	assert.NoError(t, err)
	assert.True(t, exist)

	exist, err = fs.Exists("random/path")
	assert.NoError(t, err)
	assert.False(t, exist)
}

func TestWrite(t *testing.T) {
	root, cleanup := util.CreateWorkDir(t)
	defer cleanup()

	fs, err := fs.NewFileStorage(root)
	assert.NoError(t, err, "create file storage: %s", err)

	dirName := "some-dir"
	if err := os.Mkdir(filepath.Join(root, dirName), os.ModePerm); err != nil {
		t.Fatal(err)
	}

	for _, tc := range []struct {
		path string
		err  string
	}{
		{path: "file-1.ext"},
		{path: "/dir/file-2.ext"},
		{path: "dir/subdir/file-3.ext"},
		{path: dirName, err: "file exists"},
		{path: "/" + dirName, err: "file exists"},
	} {
		t.Run(tc.path, func(t *testing.T) {
			sd := &sampleData{[]byte{0, 1, 2, 3}}
			err = fs.Write(tc.path, sd)
			if tc.err == "" {
				assert.NoError(t, err)
				assert.FileExists(t, filepath.Join(root, tc.path), "the written file should exist")
			} else {
				assert.ErrorContains(t, err, tc.err)
			}
		})
	}
}

func TestWriteLeavesNoTempLeftovers(t *testing.T) {
	root, cleanup := util.CreateWorkDir(t)
	defer cleanup()

	s, err := fs.NewFileStorage(root)
	assert.NoError(t, err)

	assert.NoError(t, s.Write("state.bin", &sampleData{[]byte{1, 2, 3}}))

	entries, err := os.ReadDir(root)
	assert.NoError(t, err)
	assert.Len(t, entries, 1, "a successful write must leave only the target file, no temporaries")
	assert.Equal(t, "state.bin", entries[0].Name())
}

func TestRead(t *testing.T) {
	root, cleanup := util.CreateWorkDir(t)
	defer cleanup()

	sd := new(sampleData)

	fs, err := fs.NewFileStorage(root)
	assert.NoError(t, err, "create file storage: %s", err)

	dirName := "some-dir"
	if err := os.Mkdir(filepath.Join(root, dirName), os.ModePerm); err != nil {
		t.Fatal(err)
	}

	fileName := "some-file.ext"
	if err := os.WriteFile(filepath.Join(root, fileName), []byte{1, 2, 3, 4}, os.ModePerm); err != nil {
		t.Fatal(err)
	}

	for _, tc := range []struct {
		path string
		err  string
	}{
		{path: fileName},
		{path: "/" + fileName},
		{path: "dir/subdir/file-3.ext", err: "no such file"},
		{path: dirName, err: "is a directory"},
	} {
		t.Run(tc.path, func(t *testing.T) {
			err = fs.Read(tc.path, sd)
			if tc.err == "" {
				assert.NoError(t, err)
			} else {
				assert.ErrorContains(t, err, tc.err)
			}
		})
	}
}

// TestReadAtomicUnderConcurrentWrites is the regression that guards the
// lock-free contract: with Write swapping files in via a single rename, a
// concurrent Read must always observe one previously written payload in full —
// never a torn mix and never a missing file. The two payloads differ in length
// so any partial read is detectable.
func TestReadAtomicUnderConcurrentWrites(t *testing.T) {
	root, cleanup := util.CreateWorkDir(t)
	defer cleanup()

	s, err := fs.NewFileStorage(root)
	assert.NoError(t, err)

	const path = "state.bin"
	payloads := [][]byte{
		bytes.Repeat([]byte{0xAA}, 4096),
		bytes.Repeat([]byte{0xBB}, 8192),
	}
	assert.NoError(t, s.Write(path, &sampleData{slices.Clone(payloads[0])}))

	stop := make(chan struct{})
	var writers sync.WaitGroup
	for w := range 4 {
		writers.Go(func() {
			for {
				select {
				case <-stop:
					return
				default:
					_ = s.Write(path, &sampleData{slices.Clone(payloads[w%len(payloads)])})
				}
			}
		})
	}

	var readers sync.WaitGroup
	for range 8 {
		readers.Go(func() {
			for range 1000 {
				sd := new(sampleData)
				if err := s.Read(path, sd); err != nil {
					t.Errorf("read during concurrent write failed: %v", err)
					return
				}
				if !knownPayload(sd.data, payloads) {
					t.Errorf("read observed a torn payload (len=%d)", len(sd.data))
					return
				}
			}
		})
	}
	readers.Wait()
	close(stop)
	writers.Wait()
}

func knownPayload(got []byte, want [][]byte) bool {
	for _, w := range want {
		if bytes.Equal(got, w) {
			return true
		}
	}
	return false
}

func TestNewFileStorageErrorNotExists(t *testing.T) {
	_, err := fs.NewFileStorage(filepath.Join(os.TempDir(), "non-existent-dir"))
	assert.Error(t, err)
}

func TestNewFileStorageErrorNotADirectory(t *testing.T) {
	f, err := os.CreateTemp("", "fs-test-file")
	if err != nil {
		t.Fatal(err)
	}
	if err := f.Close(); err != nil {
		t.Fatal(err)
	}
	_, err = fs.NewFileStorage(f.Name())
	assert.Error(t, err)
	if err := os.Remove(f.Name()); err != nil {
		t.Fatal(err)
	}
}

func TestNewFileStorageErrorNoAccess(t *testing.T) {
	_, err := fs.NewFileStorage("/some/random/dir")
	assert.Error(t, err)
}