commands_test.go

package main

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

func TestFilteredFiles(t *testing.T) {
	app := &App{
		files: []FileItem{
			{Name: "main.go", Path: "/tmp/main.go"},
			{Name: "README.md", Path: "/tmp/README.md"},
			{Name: "config.yaml", Path: "/tmp/config.yaml"},
			{Name: "main_test.go", Path: "/tmp/main_test.go"},
		},
	}

	// No filter — returns all files
	app.filterQuery = ""
	result := app.filteredFiles()
	if len(result) != 4 {
		t.Errorf("expected 4 files with no filter, got %d", len(result))
	}

	// Case-insensitive substring match
	app.filterQuery = "main"
	result = app.filteredFiles()
	if len(result) != 2 {
		t.Errorf("expected 2 files matching 'main', got %d", len(result))
	}

	// Case insensitive
	app.filterQuery = "README"
	result = app.filteredFiles()
	if len(result) != 1 {
		t.Errorf("expected 1 file matching 'README', got %d", len(result))
	}

	app.filterQuery = "readme"
	result = app.filteredFiles()
	if len(result) != 1 {
		t.Errorf("expected 1 file matching 'readme' (case insensitive), got %d", len(result))
	}

	// No match
	app.filterQuery = "xyz"
	result = app.filteredFiles()
	if len(result) != 0 {
		t.Errorf("expected 0 files matching 'xyz', got %d", len(result))
	}

	// Extension match
	app.filterQuery = ".go"
	result = app.filteredFiles()
	if len(result) != 2 {
		t.Errorf("expected 2 files matching '.go', got %d", len(result))
	}

	// Empty files list
	app.files = []FileItem{}
	app.filterQuery = "test"
	result = app.filteredFiles()
	if len(result) != 0 {
		t.Errorf("expected 0 files from empty list, got %d", len(result))
	}
}

func TestCurrentFile(t *testing.T) {
	app := &App{
		files: []FileItem{
			{Name: "a.txt", Path: "/tmp/a.txt"},
			{Name: "b.txt", Path: "/tmp/b.txt"},
		},
		cursor: 0,
	}

	// Valid cursor
	item, ok := app.currentFile()
	if !ok || item.Name != "a.txt" {
		t.Errorf("expected a.txt, got %s (ok=%v)", item.Name, ok)
	}

	// Move cursor
	app.cursor = 1
	item, ok = app.currentFile()
	if !ok || item.Name != "b.txt" {
		t.Errorf("expected b.txt, got %s (ok=%v)", item.Name, ok)
	}

	// Out of range
	app.cursor = 5
	_, ok = app.currentFile()
	if ok {
		t.Error("expected false for out-of-range cursor")
	}

	// Negative cursor
	app.cursor = -1
	_, ok = app.currentFile()
	if ok {
		t.Error("expected false for negative cursor")
	}
}

func TestCurrentFileWithFilter(t *testing.T) {
	app := &App{
		files: []FileItem{
			{Name: "main.go", Path: "/tmp/main.go"},
			{Name: "README.md", Path: "/tmp/README.md"},
			{Name: "main_test.go", Path: "/tmp/main_test.go"},
		},
		filterQuery: "main",
		cursor:      0,
	}

	item, ok := app.currentFile()
	if !ok || item.Name != "main.go" {
		t.Errorf("expected main.go, got %s", item.Name)
	}

	app.cursor = 1
	item, ok = app.currentFile()
	if !ok || item.Name != "main_test.go" {
		t.Errorf("expected main_test.go, got %s", item.Name)
	}

	// Cursor beyond filtered results
	app.cursor = 2
	_, ok = app.currentFile()
	if ok {
		t.Error("expected false for cursor beyond filtered results")
	}
}

func TestCopyFile(t *testing.T) {
	dir := t.TempDir()
	src := filepath.Join(dir, "source.txt")
	dst := filepath.Join(dir, "dest.txt")

	content := []byte("hello traverse")
	if err := os.WriteFile(src, content, 0644); err != nil {
		t.Fatal(err)
	}

	if err := copyFile(src, dst); err != nil {
		t.Fatal(err)
	}

	got, err := os.ReadFile(dst)
	if err != nil {
		t.Fatal(err)
	}
	if string(got) != string(content) {
		t.Errorf("expected %q, got %q", content, got)
	}
}

func TestCopyFileNonExistent(t *testing.T) {
	dir := t.TempDir()
	src := filepath.Join(dir, "nonexistent.txt")
	dst := filepath.Join(dir, "dest.txt")

	err := copyFile(src, dst)
	if err == nil {
		t.Error("expected error when copying non-existent file")
	}
}

func TestCopyFileSelfCopy(t *testing.T) {
	dir := t.TempDir()
	src := filepath.Join(dir, "file.txt")

	content := []byte("hello traverse")
	if err := os.WriteFile(src, content, 0644); err != nil {
		t.Fatal(err)
	}

	// Self-copy should fail
	err := copyFile(src, src)
	if err == nil {
		t.Error("expected error when copying file to itself")
	}
}

func TestGetSelectedFiles(t *testing.T) {
	app := &App{
		files: []FileItem{
			{Name: "a.txt", Path: "/tmp/a.txt"},
			{Name: "b.txt", Path: "/tmp/b.txt"},
			{Name: "c.txt", Path: "/tmp/c.txt"},
		},
		selected: map[int]bool{0: true, 2: true},
		cursor:   1,
	}

	// With selection
	files := app.getSelectedFiles()
	if len(files) != 2 {
		t.Errorf("expected 2 selected files, got %d", len(files))
	}

	// Without selection
	app.selected = map[int]bool{}
	files = app.getSelectedFiles()
	if len(files) != 1 {
		t.Errorf("expected 1 file (cursor), got %d", len(files))
	}
	if files[0] != "/tmp/b.txt" {
		t.Errorf("expected /tmp/b.txt, got %s", files[0])
	}

	// Empty files
	app.files = []FileItem{}
	app.selected = map[int]bool{}
	app.cursor = 0
	files = app.getSelectedFiles()
	if len(files) != 0 {
		t.Errorf("expected 0 files from empty list, got %d", len(files))
	}
}

func TestGetSelectedFilesWithFilter(t *testing.T) {
	app := &App{
		files: []FileItem{
			{Name: "main.go", Path: "/tmp/main.go"},
			{Name: "README.md", Path: "/tmp/README.md"},
			{Name: "main_test.go", Path: "/tmp/main_test.go"},
		},
		filterQuery: "main",
		selected:    map[int]bool{0: true},
		cursor:      0,
	}

	files := app.getSelectedFiles()
	if len(files) != 1 {
		t.Errorf("expected 1 selected file, got %d", len(files))
	}
	if files[0] != "/tmp/main.go" {
		t.Errorf("expected /tmp/main.go, got %s", files[0])
	}
}

func TestGitRepoRelPath(t *testing.T) {
	// Test with nil git service
	app := &App{}
	result := app.gitRepoRelPath("/tmp/test.txt")
	if result != "" {
		t.Errorf("expected empty string for nil git service, got %q", result)
	}
}

func TestCopyFiles(t *testing.T) {
	dir := t.TempDir()

	// Create test files
	file1 := filepath.Join(dir, "file1.txt")
	file2 := filepath.Join(dir, "file2.txt")
	os.WriteFile(file1, []byte("content1"), 0644)
	os.WriteFile(file2, []byte("content2"), 0644)

	app := &App{
		files: []FileItem{
			{Name: "file1.txt", Path: file1},
			{Name: "file2.txt", Path: file2},
		},
		selected: map[int]bool{0: true, 1: true},
	}

	// Test copy
	model, _ := app.copyFiles(false)
	if model != app {
		t.Error("copyFiles should return same app")
	}
	if len(app.clipboardFiles) != 2 {
		t.Errorf("copyFiles: expected 2 clipboard files, got %d", len(app.clipboardFiles))
	}
	if app.clipboardIsCut {
		t.Error("copyFiles: clipboardIsCut should be false")
	}

	// Test cut
	app.selected = map[int]bool{0: true}
	model, _ = app.copyFiles(true)
	if !app.clipboardIsCut {
		t.Error("copyFiles(true): clipboardIsCut should be true")
	}
}

func TestCopyFilesEmpty(t *testing.T) {
	app := &App{
		files:    []FileItem{},
		selected: map[int]bool{},
	}

	_, _ = app.copyFiles(false)
	if len(app.clipboardFiles) != 0 {
		t.Errorf("copyFiles with no selection: expected 0 clipboard files, got %d", len(app.clipboardFiles))
	}
}

func TestDoCreateFile(t *testing.T) {
	dir := t.TempDir()
	app := &App{
		cwd: dir,
	}

	// Create a new file
	fileName := "newfile.txt"
	_, cmd := app.doCreateFile(fileName)

	// Execute the command to get the result
	msg := cmd()

	result, ok := msg.(CreateResultMsg)
	if !ok {
		t.Fatalf("expected CreateResultMsg, got %T", msg)
	}
	if result.err != nil {
		t.Errorf("doCreateFile: unexpected error: %v", result.err)
	}
	if result.name != fileName {
		t.Errorf("doCreateFile: name = %q, want %q", result.name, fileName)
	}

	// Verify file was created
	path := filepath.Join(dir, fileName)
	if _, err := os.Stat(path); os.IsNotExist(err) {
		t.Error("doCreateFile: file was not created")
	}
}

func TestDoCreateFileOverwrite(t *testing.T) {
	dir := t.TempDir()
	fileName := "existing.txt"
	path := filepath.Join(dir, fileName)
	os.WriteFile(path, []byte("original content"), 0644)

	app := &App{
		cwd: dir,
	}

	// Try to create a file that already exists
	_, _ = app.doCreateFile(fileName)

	// Should set confirmAction instead of creating
	if app.confirmAction != "create-overwrite" {
		t.Errorf("doCreateFile overwrite: confirmAction = %q, want %q", app.confirmAction, "create-overwrite")
	}

	// Original file should be unchanged
	content, _ := os.ReadFile(path)
	if string(content) != "original content" {
		t.Error("doCreateFile overwrite: original file was modified")
	}
}

func TestDoCreateDir(t *testing.T) {
	dir := t.TempDir()
	app := &App{
		cwd: dir,
	}

	// Create a new directory
	dirName := "newdir"
	_, cmd := app.doCreateDir(dirName)

	// Execute the command to get the result
	msg := cmd()

	result, ok := msg.(CreateResultMsg)
	if !ok {
		t.Fatalf("expected CreateResultMsg, got %T", msg)
	}
	if result.err != nil {
		t.Errorf("doCreateDir: unexpected error: %v", result.err)
	}
	if result.name != dirName+"/" {
		t.Errorf("doCreateDir: name = %q, want %q", result.name, dirName+"/")
	}

	// Verify directory was created
	path := filepath.Join(dir, dirName)
	info, err := os.Stat(path)
	if os.IsNotExist(err) {
		t.Error("doCreateDir: directory was not created")
	} else if !info.IsDir() {
		t.Error("doCreateDir: created path is not a directory")
	}
}

func TestDoRename(t *testing.T) {
	dir := t.TempDir()
	oldName := "old.txt"
	newName := "new.txt"
	oldPath := filepath.Join(dir, oldName)
	os.WriteFile(oldPath, []byte("content"), 0644)

	app := &App{
		files: []FileItem{
			{Name: oldName, Path: oldPath},
		},
		cursor: 0,
		cwd:    dir,
	}

	// Rename the file
	_, cmd := app.doRename(newName)

	// Execute the command to get the result
	msg := cmd()

	result, ok := msg.(RenameResultMsg)
	if !ok {
		t.Fatalf("expected RenameResultMsg, got %T", msg)
	}
	if result.err != nil {
		t.Errorf("doRename: unexpected error: %v", result.err)
	}
	if result.newName != newName {
		t.Errorf("doRename: newName = %q, want %q", result.newName, newName)
	}

	// Verify file was renamed
	newPath := filepath.Join(dir, newName)
	if _, err := os.Stat(newPath); os.IsNotExist(err) {
		t.Error("doRename: new file does not exist")
	}
	if _, err := os.Stat(oldPath); !os.IsNotExist(err) {
		t.Error("doRename: old file still exists")
	}
}

func TestDoRenamePathTraversal(t *testing.T) {
	dir := t.TempDir()
	oldName := "old.txt"
	oldPath := filepath.Join(dir, oldName)
	os.WriteFile(oldPath, []byte("content"), 0644)

	app := &App{
		files: []FileItem{
			{Name: oldName, Path: oldPath},
		},
		cursor: 0,
		cwd:    dir,
	}

	// Try path traversal — should be rejected
	badNames := []string{"../evil", "..\\evil", "sub/dir", "sub\\dir", "..", "."}
	for _, name := range badNames {
		app.message = ""
		app.messageIsError = false
		model, _ := app.doRename(name)
		if model != app {
			t.Errorf("doRename(%q): should return same app", name)
		}
		if !app.messageIsError {
			t.Errorf("doRename(%q): should set error message", name)
		}
	}

	// Verify original file is unchanged
	if _, err := os.Stat(oldPath); err != nil {
		t.Error("original file should still exist")
	}
}

func TestDoRenameOverwrite(t *testing.T) {
	dir := t.TempDir()
	oldName := "old.txt"
	newName := "existing.txt"
	oldPath := filepath.Join(dir, oldName)
	newPath := filepath.Join(dir, newName)
	os.WriteFile(oldPath, []byte("old content"), 0644)
	os.WriteFile(newPath, []byte("existing content"), 0644)

	app := &App{
		files: []FileItem{
			{Name: oldName, Path: oldPath},
		},
		cursor: 0,
		cwd:    dir,
	}

	// Rename to existing file — should set confirmAction
	model, _ := app.doRename(newName)
	if model != app {
		t.Error("doRename overwrite should return same app")
	}
	if app.confirmAction != "rename-overwrite" {
		t.Errorf("confirmAction = %q, want %q", app.confirmAction, "rename-overwrite")
	}

	// Original file should be unchanged
	content, _ := os.ReadFile(newPath)
	if string(content) != "existing content" {
		t.Error("existing file should not be overwritten without confirmation")
	}
}

func TestIsValidFilename(t *testing.T) {
	tests := []struct {
		name  string
		valid bool
	}{
		{"hello.txt", true},
		{"file name.txt", true},
		{"日本語.txt", true},
		{"", false},
		{".", false},
		{"..", false},
		{"../evil", false},
		{"..\\evil", false},
		{"sub/dir", false},
		{"sub\\dir", false},
		{"C:\\Windows", false},
	}
	for _, tt := range tests {
		got := isValidFilename(tt.name)
		if got != tt.valid {
			t.Errorf("isValidFilename(%q) = %v, want %v", tt.name, got, tt.valid)
		}
	}
}

func TestAddBookmark(t *testing.T) {
	cfg := DefaultConfig()
	app := &App{
		cwd:    "/tmp/test",
		config: cfg,
	}

	// Add bookmark
	model, _ := app.addBookmark()
	if model != app {
		t.Error("addBookmark should return same app")
	}
	if len(app.config.Bookmarks) != 1 {
		t.Errorf("addBookmark: expected 1 bookmark, got %d", len(app.config.Bookmarks))
	}
	if app.config.Bookmarks[0] != "/tmp/test" {
		t.Errorf("addBookmark: bookmark = %q, want %q", app.config.Bookmarks[0], "/tmp/test")
	}

	// Add same bookmark again (should not duplicate)
	model, _ = app.addBookmark()
	if len(app.config.Bookmarks) != 1 {
		t.Errorf("addBookmark duplicate: expected 1 bookmark, got %d", len(app.config.Bookmarks))
	}
}

func TestRemoveBookmark(t *testing.T) {
	cfg := DefaultConfig()
	cfg.Bookmarks = []string{"/tmp/test1", "/tmp/test2"}
	app := &App{
		cwd:    "/tmp/test1",
		config: cfg,
	}

	// Remove bookmark
	model, _ := app.removeBookmark()
	if model != app {
		t.Error("removeBookmark should return same app")
	}
	if len(app.config.Bookmarks) != 1 {
		t.Errorf("removeBookmark: expected 1 bookmark, got %d", len(app.config.Bookmarks))
	}
	if app.config.Bookmarks[0] != "/tmp/test2" {
		t.Errorf("removeBookmark: remaining bookmark = %q, want %q", app.config.Bookmarks[0], "/tmp/test2")
	}

	// Remove non-existent bookmark
	app.cwd = "/tmp/test3"
	model, _ = app.removeBookmark()
	if len(app.config.Bookmarks) != 1 {
		t.Errorf("removeBookmark non-existent: expected 1 bookmark, got %d", len(app.config.Bookmarks))
	}
}

func TestShowBookmarks(t *testing.T) {
	cfg := DefaultConfig()
	cfg.Bookmarks = []string{"/tmp/test1", "/tmp/test2"}
	app := &App{
		config: cfg,
	}

	// Show bookmarks
	model, _ := app.showBookmarks()
	if model != app {
		t.Error("showBookmarks should return same app")
	}
	if !app.bookmarkMode {
		t.Error("showBookmarks: bookmarkMode should be true")
	}
	if app.bookmarkIndex != 0 {
		t.Errorf("showBookmarks: bookmarkIndex = %d, want 0", app.bookmarkIndex)
	}

	// Show bookmarks when empty
	cfg.Bookmarks = []string{}
	app.config = cfg
	app.bookmarkMode = false
	model, _ = app.showBookmarks()
	if app.bookmarkMode {
		t.Error("showBookmarks empty: bookmarkMode should be false")
	}
}

func TestPasteFiles(t *testing.T) {
	dir := t.TempDir()

	// Create source file
	srcFile := filepath.Join(dir, "source.txt")
	os.WriteFile(srcFile, []byte("content"), 0644)

	// Create destination directory
	dstDir := filepath.Join(dir, "dest")
	os.Mkdir(dstDir, 0755)

	app := &App{
		clipboardFiles: []string{srcFile},
		clipboardIsCut: false,
		cwd:            dstDir,
	}

	// Paste files
	model, cmd := app.pasteFiles()
	if model != app {
		t.Error("pasteFiles should return same app")
	}

	// Execute the command to perform the actual copy
	msg := cmd()
	result, ok := msg.(PasteResultMsg)
	if !ok {
		t.Fatalf("expected PasteResultMsg, got %T", msg)
	}
	if result.err != nil {
		t.Errorf("pasteFiles: unexpected error: %v", result.err)
	}
	if result.count != 1 {
		t.Errorf("pasteFiles: count = %d, want 1", result.count)
	}

	// Verify file was copied
	dstFile := filepath.Join(dstDir, "source.txt")
	if _, err := os.Stat(dstFile); os.IsNotExist(err) {
		t.Error("pasteFiles: destination file was not created")
	}

	// Verify content
	content, err := os.ReadFile(dstFile)
	if err != nil {
		t.Fatalf("pasteFiles: error reading destination: %v", err)
	}
	if string(content) != "content" {
		t.Errorf("pasteFiles: content = %q, want %q", string(content), "content")
	}
}

func TestPasteFilesEmpty(t *testing.T) {
	app := &App{
		clipboardFiles: []string{},
		cwd:            "/tmp",
	}

	model, _ := app.pasteFiles()
	if model != app {
		t.Error("pasteFiles empty should return same app")
	}
}

func TestDeleteFiles(t *testing.T) {
	dir := t.TempDir()
	file := filepath.Join(dir, "file.txt")
	os.WriteFile(file, []byte("content"), 0644)

	app := &App{
		files: []FileItem{
			{Name: "file.txt", Path: file},
		},
		selected: map[int]bool{},
		cursor:   0,
	}

	// Delete files (should set confirmAction)
	model, _ := app.deleteFiles()
	if model != app {
		t.Error("deleteFiles should return same app")
	}
	if app.confirmAction != "delete" {
		t.Errorf("deleteFiles: confirmAction = %q, want %q", app.confirmAction, "delete")
	}
}

func TestDeleteFilesEmpty(t *testing.T) {
	app := &App{
		files:    []FileItem{},
		selected: map[int]bool{},
		cursor:   0,
	}

	model, _ := app.deleteFiles()
	if model != app {
		t.Error("deleteFiles empty should return same app")
	}
	if app.confirmAction != "" {
		t.Errorf("deleteFiles empty: confirmAction = %q, want empty", app.confirmAction)
	}
}

func TestUndoDelete(t *testing.T) {
	dir := t.TempDir()
	file := filepath.Join(dir, "file.txt")
	os.WriteFile(file, []byte("content"), 0644)

	app := &App{
		undoStack: []Operation{},
		undoLimit: 10,
	}

	// Simulate delete
	ensureUndoDir()
	backupPath := filepath.Join(undoDir(), "file.txt")
	os.Rename(file, backupPath)
	app.undoStack = append(app.undoStack, Operation{
		Type:    "delete",
		Backups: []string{backupPath},
		Paths:   []string{file},
	})

	// Verify file is deleted
	if _, err := os.Stat(file); !os.IsNotExist(err) {
		t.Error("file should be deleted")
	}

	// Undo
	model, _ := app.undoLastOperation()
	if model != app {
		t.Error("undoLastOperation should return same app")
	}

	// Verify file is restored
	if _, err := os.Stat(file); err != nil {
		t.Error("file should be restored after undo")
	}

	// Verify undo stack is empty
	if len(app.undoStack) != 0 {
		t.Errorf("undoStack should be empty, got %d", len(app.undoStack))
	}
}

func TestUndoRename(t *testing.T) {
	dir := t.TempDir()
	oldPath := filepath.Join(dir, "old.txt")
	newPath := filepath.Join(dir, "new.txt")
	os.WriteFile(oldPath, []byte("content"), 0644)

	app := &App{
		undoStack: []Operation{},
		undoLimit: 10,
	}

	// Simulate rename
	os.Rename(oldPath, newPath)
	app.undoStack = append(app.undoStack, Operation{
		Type:    "rename",
		Path:    newPath,
		OldPath: oldPath,
	})

	// Verify rename
	if _, err := os.Stat(newPath); err != nil {
		t.Error("new file should exist")
	}

	// Undo
	model, _ := app.undoLastOperation()
	if model != app {
		t.Error("undoLastOperation should return same app")
	}

	// Verify restore
	if _, err := os.Stat(oldPath); err != nil {
		t.Error("old file should exist after undo")
	}

	// Verify undo stack is empty
	if len(app.undoStack) != 0 {
		t.Errorf("undoStack should be empty, got %d", len(app.undoStack))
	}
}

func TestUndoEmpty(t *testing.T) {
	app := &App{
		undoStack: []Operation{},
		undoLimit: 10,
	}

	model, _ := app.undoLastOperation()
	if model != app {
		t.Error("undoLastOperation with empty stack should return same app")
	}
	if app.message != "Nothing to undo" {
		t.Errorf("message = %q, want %q", app.message, "Nothing to undo")
	}
}

func TestUndoStackLimit(t *testing.T) {
	dir := t.TempDir()
	app := &App{
		undoStack: []Operation{},
		undoLimit: 3,
	}

	// Add 4 operations
	for i := 0; i < 4; i++ {
		file := filepath.Join(dir, fmt.Sprintf("file%d.txt", i))
		os.WriteFile(file, []byte("content"), 0644)

		ensureUndoDir()
		backupPath := filepath.Join(undoDir(), fmt.Sprintf("file%d.txt", i))
		os.Rename(file, backupPath)

		app.undoStack = append(app.undoStack, Operation{
			Type:    "delete",
			Backups: []string{backupPath},
			Paths:   []string{file},
		})

		// Limit stack size
		if len(app.undoStack) > app.undoLimit {
			old := app.undoStack[0]
			for _, b := range old.Backups {
				os.Remove(b)
			}
			app.undoStack = app.undoStack[1:]
		}
	}

	// Verify stack size is limited
	if len(app.undoStack) != 3 {
		t.Errorf("undoStack should have 3 items, got %d", len(app.undoStack))
	}
}

func TestUndoDir(t *testing.T) {
	dir := undoDir()
	if dir == "" {
		t.Error("undoDir should not be empty")
	}

	// Test ensureUndoDir
	err := ensureUndoDir()
	if err != nil {
		t.Errorf("ensureUndoDir error: %v", err)
	}

	// Test cleanUndoDir
	cleanUndoDir()
	if _, err := os.Stat(dir); !os.IsNotExist(err) {
		t.Error("cleanUndoDir should remove the directory")
	}
}

func TestUndoBatchDelete(t *testing.T) {
	dir := t.TempDir()
	file1 := filepath.Join(dir, "file1.txt")
	file2 := filepath.Join(dir, "file2.txt")
	os.WriteFile(file1, []byte("content1"), 0644)
	os.WriteFile(file2, []byte("content2"), 0644)

	app := &App{
		undoStack: []Operation{},
		undoLimit: 10,
	}

	// Simulate batch delete (both files in one operation)
	ensureUndoDir()
	backup1 := filepath.Join(undoDir(), "file1.txt")
	backup2 := filepath.Join(undoDir(), "file2.txt")
	os.Rename(file1, backup1)
	os.Rename(file2, backup2)
	app.undoStack = append(app.undoStack, Operation{
		Type:    "delete",
		Backups: []string{backup1, backup2},
		Paths:   []string{file1, file2},
	})

	// Verify files are deleted
	if _, err := os.Stat(file1); !os.IsNotExist(err) {
		t.Error("file1 should be deleted")
	}
	if _, err := os.Stat(file2); !os.IsNotExist(err) {
		t.Error("file2 should be deleted")
	}

	// Undo once — should restore both files
	model, _ := app.undoLastOperation()
	if model != app {
		t.Error("undoLastOperation should return same app")
	}

	if _, err := os.Stat(file1); err != nil {
		t.Error("file1 should be restored after undo")
	}
	if _, err := os.Stat(file2); err != nil {
		t.Error("file2 should be restored after undo")
	}

	// Verify undo stack is empty
	if len(app.undoStack) != 0 {
		t.Errorf("undoStack should be empty, got %d", len(app.undoStack))
	}
}

func TestMoveFile(t *testing.T) {
	dir := t.TempDir()
	src := filepath.Join(dir, "source.txt")
	dst := filepath.Join(dir, "dest.txt")
	os.WriteFile(src, []byte("hello"), 0644)

	if err := moveFile(src, dst); err != nil {
		t.Fatalf("moveFile failed: %v", err)
	}

	// Source should be gone
	if _, err := os.Stat(src); !os.IsNotExist(err) {
		t.Error("source should not exist after moveFile")
	}

	// Dest should exist with correct content
	content, err := os.ReadFile(dst)
	if err != nil {
		t.Fatal(err)
	}
	if string(content) != "hello" {
		t.Errorf("content = %q, want %q", string(content), "hello")
	}
}

func TestMoveFileDirectory(t *testing.T) {
	dir := t.TempDir()
	srcDir := filepath.Join(dir, "srcdir")
	dstDir := filepath.Join(dir, "dstdir")
	os.Mkdir(srcDir, 0755)
	os.WriteFile(filepath.Join(srcDir, "a.txt"), []byte("aaa"), 0644)
	os.WriteFile(filepath.Join(srcDir, "b.txt"), []byte("bbb"), 0644)

	if err := moveFile(srcDir, dstDir); err != nil {
		t.Fatalf("moveFile directory failed: %v", err)
	}

	// Source dir should be gone
	if _, err := os.Stat(srcDir); !os.IsNotExist(err) {
		t.Error("source dir should not exist after moveFile")
	}

	// Dest dir should exist with both files
	contentA, err := os.ReadFile(filepath.Join(dstDir, "a.txt"))
	if err != nil {
		t.Fatal(err)
	}
	if string(contentA) != "aaa" {
		t.Errorf("a.txt content = %q, want %q", string(contentA), "aaa")
	}

	contentB, err := os.ReadFile(filepath.Join(dstDir, "b.txt"))
	if err != nil {
		t.Fatal(err)
	}
	if string(contentB) != "bbb" {
		t.Errorf("b.txt content = %q, want %q", string(contentB), "bbb")
	}
}

func TestMoveFileNonExistent(t *testing.T) {
	dir := t.TempDir()
	src := filepath.Join(dir, "nonexistent.txt")
	dst := filepath.Join(dir, "dest.txt")

	err := moveFile(src, dst)
	if err == nil {
		t.Error("moveFile on non-existent file should fail")
	}
}