package local

import (
	"os"
	"path/filepath"
	"testing"

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

func TestNew_Good(t *testing.T) {
	testRoot := t.TempDir()

	// Test successful creation
	medium, err := New(testRoot)
	assert.NoError(t, err)
	assert.NotNil(t, medium)
	assert.Equal(t, testRoot, medium.root)

	// Verify the root directory exists
	info, err := os.Stat(testRoot)
	assert.NoError(t, err)
	assert.True(t, info.IsDir())

	// Test creating a new instance with an existing directory (should not error)
	medium2, err := New(testRoot)
	assert.NoError(t, err)
	assert.NotNil(t, medium2)
}

func TestPath_Good(t *testing.T) {
	testRoot := t.TempDir()
	medium := &Medium{root: testRoot}

	// Valid path
	validPath, err := medium.path("file.txt")
	assert.NoError(t, err)
	assert.Equal(t, filepath.Join(testRoot, "file.txt"), validPath)

	// Subdirectory path
	subDirPath, err := medium.path("dir/sub/file.txt")
	assert.NoError(t, err)
	assert.Equal(t, filepath.Join(testRoot, "dir", "sub", "file.txt"), subDirPath)
}

func TestPath_Bad(t *testing.T) {
	testRoot := t.TempDir()
	medium := &Medium{root: testRoot}

	// Path traversal attempt
	_, err := medium.path("../secret.txt")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "path traversal attempt detected")

	_, err = medium.path("dir/../../secret.txt")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "path traversal attempt detected")

	// Absolute path attempt
	_, err = medium.path("/etc/passwd")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "path traversal attempt detected")
}

func TestReadWrite_Good(t *testing.T) {
	testRoot, err := os.MkdirTemp("", "local_read_write_test")
	assert.NoError(t, err)
	defer os.RemoveAll(testRoot)

	medium, err := New(testRoot)
	assert.NoError(t, err)

	fileName := "testfile.txt"
	filePath := filepath.Join("subdir", fileName)
	content := "Hello, Gopher!\nThis is a test file."

	// Test Write
	err = medium.Write(filePath, content)
	assert.NoError(t, err)

	// Verify file content by reading directly from OS
	readContent, err := os.ReadFile(filepath.Join(testRoot, filePath))
	assert.NoError(t, err)
	assert.Equal(t, content, string(readContent))

	// Test Read
	readByMedium, err := medium.Read(filePath)
	assert.NoError(t, err)
	assert.Equal(t, content, readByMedium)

	// Test Read non-existent file
	_, err = medium.Read("nonexistent.txt")
	assert.Error(t, err)
	assert.True(t, os.IsNotExist(err))

	// Test Write to a path with traversal attempt
	writeErr := medium.Write("../badfile.txt", "malicious content")
	assert.Error(t, writeErr)
	assert.Contains(t, writeErr.Error(), "path traversal attempt detected")
}

func TestEnsureDir_Good(t *testing.T) {
	testRoot, err := os.MkdirTemp("", "local_ensure_dir_test")
	assert.NoError(t, err)
	defer os.RemoveAll(testRoot)

	medium, err := New(testRoot)
	assert.NoError(t, err)

	dirName := "newdir/subdir"
	dirPath := filepath.Join(testRoot, dirName)

	// Test creating a new directory
	err = medium.EnsureDir(dirName)
	assert.NoError(t, err)
	info, err := os.Stat(dirPath)
	assert.NoError(t, err)
	assert.True(t, info.IsDir())

	// Test ensuring an existing directory (should not error)
	err = medium.EnsureDir(dirName)
	assert.NoError(t, err)

	// Test ensuring a directory with path traversal attempt
	err = medium.EnsureDir("../bad_dir")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "path traversal attempt detected")
}

func TestIsFile_Good(t *testing.T) {
	testRoot, err := os.MkdirTemp("", "local_is_file_test")
	assert.NoError(t, err)
	defer os.RemoveAll(testRoot)

	medium, err := New(testRoot)
	assert.NoError(t, err)

	// Create a test file
	fileName := "existing_file.txt"
	filePath := filepath.Join(testRoot, fileName)
	err = os.WriteFile(filePath, []byte("content"), 0644)
	assert.NoError(t, err)

	// Create a test directory
	dirName := "existing_dir"
	dirPath := filepath.Join(testRoot, dirName)
	err = os.Mkdir(dirPath, 0755)
	assert.NoError(t, err)

	// Test with an existing file
	assert.True(t, medium.IsFile(fileName))

	// Test with a non-existent file
	assert.False(t, medium.IsFile("nonexistent_file.txt"))

	// Test with a directory
	assert.False(t, medium.IsFile(dirName))

	// Test with path traversal attempt
	assert.False(t, medium.IsFile("../bad_file.txt"))
}

func TestFileGetFileSet_Good(t *testing.T) {
	testRoot, err := os.MkdirTemp("", "local_fileget_fileset_test")
	assert.NoError(t, err)
	defer os.RemoveAll(testRoot)

	medium, err := New(testRoot)
	assert.NoError(t, err)

	fileName := "data.txt"
	content := "Hello, FileGet/FileSet!"

	// Test FileSet
	err = medium.FileSet(fileName, content)
	assert.NoError(t, err)

	// Verify file was written
	readContent, err := os.ReadFile(filepath.Join(testRoot, fileName))
	assert.NoError(t, err)
	assert.Equal(t, content, string(readContent))

	// Test FileGet
	gotContent, err := medium.FileGet(fileName)
	assert.NoError(t, err)
	assert.Equal(t, content, gotContent)

	// Test FileGet on non-existent file
	_, err = medium.FileGet("nonexistent.txt")
	assert.Error(t, err)

	// Test FileSet with path traversal attempt
	err = medium.FileSet("../bad.txt", "malicious")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "path traversal attempt detected")

	// Test FileGet with path traversal attempt
	_, err = medium.FileGet("../bad.txt")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "path traversal attempt detected")
}

func TestDelete_Good(t *testing.T) {
	testRoot, err := os.MkdirTemp("", "local_delete_test")
	assert.NoError(t, err)
	defer os.RemoveAll(testRoot)

	medium, err := New(testRoot)
	assert.NoError(t, err)

	// Create and delete a file
	err = medium.Write("file.txt", "content")
	assert.NoError(t, err)
	assert.True(t, medium.IsFile("file.txt"))

	err = medium.Delete("file.txt")
	assert.NoError(t, err)
	assert.False(t, medium.IsFile("file.txt"))

	// Create and delete an empty directory
	err = medium.EnsureDir("emptydir")
	assert.NoError(t, err)
	err = medium.Delete("emptydir")
	assert.NoError(t, err)
	assert.False(t, medium.IsDir("emptydir"))
}

func TestDelete_Bad_NotEmpty(t *testing.T) {
	testRoot, err := os.MkdirTemp("", "local_delete_notempty_test")
	assert.NoError(t, err)
	defer os.RemoveAll(testRoot)

	medium, err := New(testRoot)
	assert.NoError(t, err)

	// Create a directory with a file
	err = medium.Write("mydir/file.txt", "content")
	assert.NoError(t, err)

	// Try to delete non-empty directory
	err = medium.Delete("mydir")
	assert.Error(t, err)
}

func TestDeleteAll_Good(t *testing.T) {
	testRoot, err := os.MkdirTemp("", "local_deleteall_test")
	assert.NoError(t, err)
	defer os.RemoveAll(testRoot)

	medium, err := New(testRoot)
	assert.NoError(t, err)

	// Create nested structure
	err = medium.Write("mydir/file1.txt", "content1")
	assert.NoError(t, err)
	err = medium.Write("mydir/subdir/file2.txt", "content2")
	assert.NoError(t, err)

	// Delete all
	err = medium.DeleteAll("mydir")
	assert.NoError(t, err)
	assert.False(t, medium.Exists("mydir"))
	assert.False(t, medium.Exists("mydir/file1.txt"))
	assert.False(t, medium.Exists("mydir/subdir/file2.txt"))
}

func TestRename_Good(t *testing.T) {
	testRoot, err := os.MkdirTemp("", "local_rename_test")
	assert.NoError(t, err)
	defer os.RemoveAll(testRoot)

	medium, err := New(testRoot)
	assert.NoError(t, err)

	// Rename a file
	err = medium.Write("old.txt", "content")
	assert.NoError(t, err)
	err = medium.Rename("old.txt", "new.txt")
	assert.NoError(t, err)
	assert.False(t, medium.IsFile("old.txt"))
	assert.True(t, medium.IsFile("new.txt"))

	content, err := medium.Read("new.txt")
	assert.NoError(t, err)
	assert.Equal(t, "content", content)
}

func TestRename_Bad_Traversal(t *testing.T) {
	testRoot, err := os.MkdirTemp("", "local_rename_traversal_test")
	assert.NoError(t, err)
	defer os.RemoveAll(testRoot)

	medium, err := New(testRoot)
	assert.NoError(t, err)

	err = medium.Write("file.txt", "content")
	assert.NoError(t, err)

	err = medium.Rename("file.txt", "../escaped.txt")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "path traversal")
}

func TestList_Good(t *testing.T) {
	testRoot, err := os.MkdirTemp("", "local_list_test")
	assert.NoError(t, err)
	defer os.RemoveAll(testRoot)

	medium, err := New(testRoot)
	assert.NoError(t, err)

	// Create some files and directories
	err = medium.Write("file1.txt", "content1")
	assert.NoError(t, err)
	err = medium.Write("file2.txt", "content2")
	assert.NoError(t, err)
	err = medium.EnsureDir("subdir")
	assert.NoError(t, err)

	// List root
	entries, err := medium.List(".")
	assert.NoError(t, err)
	assert.Len(t, entries, 3)

	names := make(map[string]bool)
	for _, e := range entries {
		names[e.Name()] = true
	}
	assert.True(t, names["file1.txt"])
	assert.True(t, names["file2.txt"])
	assert.True(t, names["subdir"])
}

func TestStat_Good(t *testing.T) {
	testRoot, err := os.MkdirTemp("", "local_stat_test")
	assert.NoError(t, err)
	defer os.RemoveAll(testRoot)

	medium, err := New(testRoot)
	assert.NoError(t, err)

	// Stat a file
	err = medium.Write("file.txt", "hello world")
	assert.NoError(t, err)
	info, err := medium.Stat("file.txt")
	assert.NoError(t, err)
	assert.Equal(t, "file.txt", info.Name())
	assert.Equal(t, int64(11), info.Size())
	assert.False(t, info.IsDir())

	// Stat a directory
	err = medium.EnsureDir("mydir")
	assert.NoError(t, err)
	info, err = medium.Stat("mydir")
	assert.NoError(t, err)
	assert.Equal(t, "mydir", info.Name())
	assert.True(t, info.IsDir())
}

func TestExists_Good(t *testing.T) {
	testRoot, err := os.MkdirTemp("", "local_exists_test")
	assert.NoError(t, err)
	defer os.RemoveAll(testRoot)

	medium, err := New(testRoot)
	assert.NoError(t, err)

	assert.False(t, medium.Exists("nonexistent"))

	err = medium.Write("file.txt", "content")
	assert.NoError(t, err)
	assert.True(t, medium.Exists("file.txt"))

	err = medium.EnsureDir("mydir")
	assert.NoError(t, err)
	assert.True(t, medium.Exists("mydir"))
}

func TestIsDir_Good(t *testing.T) {
	testRoot, err := os.MkdirTemp("", "local_isdir_test")
	assert.NoError(t, err)
	defer os.RemoveAll(testRoot)

	medium, err := New(testRoot)
	assert.NoError(t, err)

	err = medium.Write("file.txt", "content")
	assert.NoError(t, err)
	assert.False(t, medium.IsDir("file.txt"))

	err = medium.EnsureDir("mydir")
	assert.NoError(t, err)
	assert.True(t, medium.IsDir("mydir"))

	assert.False(t, medium.IsDir("nonexistent"))
}