package watcher

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

	"github.com/fsnotify/fsnotify"
)

func TestNew(t *testing.T) {
	t.Parallel()
	watcher, err := New()
	if err != nil {
		t.Fatalf("New() failed: %v", err)
	}
	defer watcher.Close()

	if watcher == nil {
		t.Error("New() returned nil watcher")
	}
}

func TestAddRecursive(t *testing.T) {
	t.Parallel()
	watcher, err := New()
	if err != nil {
		t.Fatalf("New() failed: %v", err)
	}
	defer watcher.Close()

	tempDir, err := os.MkdirTemp("", "watcher_test")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	subDir := filepath.Join(tempDir, "subdir")
	err = os.Mkdir(subDir, 0755)
	if err != nil {
		t.Fatalf("Failed to create subdir: %v", err)
	}

	err = watcher.AddRecursive(tempDir)
	if err != nil {
		t.Errorf("AddRecursive() failed: %v", err)
	}

	watchList := watcher.WatchList()
	if len(watchList) == 0 {
		t.Error("Expected directories to be added to watch list")
	}

	testFile := filepath.Join(tempDir, "test.txt")
	err = os.WriteFile(testFile, []byte("test"), 0644)
	if err != nil {
		t.Fatalf("Failed to create test file: %v", err)
	}

	err = watcher.AddRecursive(testFile)
	if err != nil {
		t.Errorf("AddRecursive() with file failed: %v", err)
	}
}

func TestAddRecursiveIgnoredDirs(t *testing.T) {
	t.Parallel()
	watcher, err := New()
	if err != nil {
		t.Fatalf("New() failed: %v", err)
	}
	defer watcher.Close()

	tempDir, err := os.MkdirTemp("", "watcher_test")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	// Create .git directory (should be ignored)
	gitDir := filepath.Join(tempDir, ".git")
	err = os.Mkdir(gitDir, 0755)
	if err != nil {
		t.Fatalf("Failed to create .git dir: %v", err)
	}

	// Create regular subdirectory
	subDir := filepath.Join(tempDir, "subdir")
	err = os.Mkdir(subDir, 0755)
	if err != nil {
		t.Fatalf("Failed to create subdir: %v", err)
	}

	err = watcher.AddRecursive(tempDir)
	if err != nil {
		t.Errorf("AddRecursive() failed: %v", err)
	}

	watchList := watcher.WatchList()
	for _, path := range watchList {
		if filepath.Base(path) == ".git" {
			t.Errorf("Expected .git directory to be ignored, but found in watch list: %s", path)
		}
	}
}

func TestAddRecursiveNonExistentPath(t *testing.T) {
	t.Parallel()
	watcher, err := New()
	if err != nil {
		t.Fatalf("New() failed: %v", err)
	}
	defer watcher.Close()

	err = watcher.AddRecursive("/non/existent/path")
	if err == nil {
		t.Error("Expected AddRecursive() to fail for non-existent path")
	}
}

func TestRemove(t *testing.T) {
	t.Parallel()
	watcher, err := New()
	if err != nil {
		t.Fatalf("New() failed: %v", err)
	}
	defer watcher.Close()

	tempDir, err := os.MkdirTemp("", "watcher_test")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	err = watcher.AddRecursive(tempDir)
	if err != nil {
		t.Fatalf("AddRecursive() failed: %v", err)
	}

	watchList := watcher.WatchList()
	if len(watchList) == 0 {
		t.Fatal("Expected directory to be in watch list")
	}

	err = watcher.Remove(tempDir)
	if err != nil {
		t.Errorf("Remove() failed: %v", err)
	}

	watchList = watcher.WatchList()
	for _, path := range watchList {
		if path == tempDir {
			t.Error("Expected directory to be removed from watch list")
		}
	}
}

func TestWatchList(t *testing.T) {
	t.Parallel()
	watcher, err := New()
	if err != nil {
		t.Fatalf("New() failed: %v", err)
	}
	defer watcher.Close()

	// Initially should be empty
	watchList := watcher.WatchList()
	if len(watchList) != 0 {
		t.Errorf("Expected empty watch list, got %d items", len(watchList))
	}

	tempDir, err := os.MkdirTemp("", "watcher_test")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	err = watcher.AddRecursive(tempDir)
	if err != nil {
		t.Fatalf("AddRecursive() failed: %v", err)
	}

	watchList = watcher.WatchList()
	if len(watchList) == 0 {
		t.Error("Expected non-empty watch list after adding directory")
	}
}

func TestClose(t *testing.T) {
	t.Parallel()
	watcher, err := New()
	if err != nil {
		t.Fatalf("New() failed: %v", err)
	}

	tempDir, err := os.MkdirTemp("", "watcher_test")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	err = watcher.AddRecursive(tempDir)
	if err != nil {
		t.Fatalf("AddRecursive() failed: %v", err)
	}

	err = watcher.Close()
	if err != nil {
		t.Errorf("Close() failed: %v", err)
	}

	err = watcher.AddRecursive(tempDir)
	if err == nil {
		t.Error("Expected AddRecursive() to fail after Close()")
	}
}

func TestEventTypeConversion(t *testing.T) {
	t.Parallel()
	fsEvent := fsnotify.Event{
		Name: "/test/path",
		Op:   fsnotify.Create,
	}

	event := Event(fsEvent)
	if event.Name != fsEvent.Name {
		t.Errorf("Expected event name %s, got %s", fsEvent.Name, event.Name)
	}
	if event.Op != fsEvent.Op {
		t.Errorf("Expected event op %v, got %v", fsEvent.Op, event.Op)
	}
}

func TestIgnoredDirs(t *testing.T) {
	t.Parallel()
	expectedDirs := []string{".git"}

	if len(IgnoredDirs) != len(expectedDirs) {
		t.Errorf("Expected %d ignored dirs, got %d", len(expectedDirs), len(IgnoredDirs))
	}

	for _, expected := range expectedDirs {
		found := slices.Contains(IgnoredDirs, expected)
		if !found {
			t.Errorf("Expected %s to be in IgnoredDirs", expected)
		}
	}
}