package fsext

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

func TestPathExistsFile(t *testing.T) {
	dir := t.TempDir()
	fp := filepath.Join(dir, "file.txt")
	if err := os.WriteFile(fp, []byte("hello"), 0644); err != nil {
		t.Fatalf("setup: %v", err)
	}

	ok, err := PathExists(fp)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if !ok {
		t.Errorf("PathExists(%q) = false, want true", fp)
	}
}

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

	ok, err := PathExists(dir)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if !ok {
		t.Errorf("PathExists(%q) = false, want true", dir)
	}
}

func TestPathExistsMissing(t *testing.T) {
	dir := t.TempDir()
	fp := filepath.Join(dir, "does_not_exist")

	ok, err := PathExists(fp)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if ok {
		t.Errorf("PathExists(%q) = true, want false", fp)
	}
}

func TestPathExistsMissingNested(t *testing.T) {
	dir := t.TempDir()
	fp := filepath.Join(dir, "nope", "still_nope", "file.txt")

	ok, err := PathExists(fp)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if ok {
		t.Errorf("PathExists(%q) = true, want false", fp)
	}
}

func TestFileExistsFile(t *testing.T) {
	dir := t.TempDir()
	fp := filepath.Join(dir, "file.txt")
	if err := os.WriteFile(fp, []byte("data"), 0644); err != nil {
		t.Fatalf("setup: %v", err)
	}

	ok, err := FileExists(fp)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if !ok {
		t.Errorf("FileExists(%q) = false, want true", fp)
	}
}

func TestFileExistsEmptyFile(t *testing.T) {
	dir := t.TempDir()
	fp := filepath.Join(dir, "empty.txt")
	if err := os.WriteFile(fp, []byte{}, 0644); err != nil {
		t.Fatalf("setup: %v", err)
	}

	ok, err := FileExists(fp)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if !ok {
		t.Errorf("FileExists(%q) = false, want true", fp)
	}
}

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

	ok, err := FileExists(dir)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if ok {
		t.Errorf("FileExists(%q) = true, want false (it's a directory)", dir)
	}
}

func TestFileExistsMissing(t *testing.T) {
	dir := t.TempDir()
	fp := filepath.Join(dir, "missing.txt")

	ok, err := FileExists(fp)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if ok {
		t.Errorf("FileExists(%q) = true, want false", fp)
	}
}

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

	ok, err := DirectoryExists(dir)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if !ok {
		t.Errorf("DirectoryExists(%q) = false, want true", dir)
	}
}

func TestDirectoryExistsNestedDirectory(t *testing.T) {
	dir := t.TempDir()
	nested := filepath.Join(dir, "a", "b", "c")
	if err := os.MkdirAll(nested, 0755); err != nil {
		t.Fatalf("setup: %v", err)
	}

	ok, err := DirectoryExists(nested)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if !ok {
		t.Errorf("DirectoryExists(%q) = false, want true", nested)
	}
}

func TestDirectoryExistsFileReturnsFalse(t *testing.T) {
	dir := t.TempDir()
	fp := filepath.Join(dir, "file.txt")
	if err := os.WriteFile(fp, []byte("data"), 0644); err != nil {
		t.Fatalf("setup: %v", err)
	}

	ok, err := DirectoryExists(fp)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if ok {
		t.Errorf("DirectoryExists(%q) = true, want false (it's a file)", fp)
	}
}

func TestDirectoryExistsMissing(t *testing.T) {
	dir := t.TempDir()
	fp := filepath.Join(dir, "missing")

	ok, err := DirectoryExists(fp)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if ok {
		t.Errorf("DirectoryExists(%q) = true, want false", fp)
	}
}

func TestPathExistsEmptyString(t *testing.T) {
	ok, err := PathExists("")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if ok {
		t.Errorf("PathExists(\"\") = true, want false")
	}
}

func TestFileExistsEmptyString(t *testing.T) {
	ok, err := FileExists("")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if ok {
		t.Errorf("FileExists(\"\") = true, want false")
	}
}

func TestDirectoryExistsEmptyString(t *testing.T) {
	ok, err := DirectoryExists("")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if ok {
		t.Errorf("DirectoryExists(\"\") = true, want false")
	}
}

func TestPathExistsSymlinkToFile(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("symlinks require admin privileges on windows")
	}
	dir := t.TempDir()
	target := filepath.Join(dir, "target.txt")
	if err := os.WriteFile(target, []byte("data"), 0644); err != nil {
		t.Fatalf("setup: %v", err)
	}
	link := filepath.Join(dir, "link.txt")
	if err := os.Symlink(target, link); err != nil {
		t.Fatalf("setup: %v", err)
	}

	ok, err := PathExists(link)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if !ok {
		t.Errorf("PathExists(symlink) = false, want true")
	}

	ok, err = FileExists(link)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if !ok {
		t.Errorf("FileExists(symlink-to-file) = false, want true")
	}

	ok, err = DirectoryExists(link)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if ok {
		t.Errorf("DirectoryExists(symlink-to-file) = true, want false")
	}
}

func TestPathExistsBrokenSymlink(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("symlinks require admin privileges on windows")
	}
	dir := t.TempDir()
	link := filepath.Join(dir, "broken")
	if err := os.Symlink(filepath.Join(dir, "nonexistent_target"), link); err != nil {
		t.Fatalf("setup: %v", err)
	}

	ok, err := PathExists(link)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if ok {
		t.Errorf("PathExists(broken-symlink) = true, want false")
	}
}