editor.go

package main

import (
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"

	tea "github.com/charmbracelet/bubbletea"
)

// hasAnyExt reports whether path (compared case-insensitively) ends with any of
// the provided extensions (e.g. ".png", ".jpg").
func hasAnyExt(path string, exts []string) bool {
	lower := strings.ToLower(path)
	for _, e := range exts {
		if strings.HasSuffix(lower, e) {
			return true
		}
	}
	return false
}

// editorAvailable checks if an editor command is available
func editorAvailable(cmd string) bool {
	_, err := exec.LookPath(cmd)
	return err == nil
}

// getAvailableEditor returns the first available editor
func getAvailableEditor() string {
	editors := []string{"micro", "nano", "vim", "vi"}
	for _, editor := range editors {
		if editorAvailable(editor) {
			return editor
		}
	}
	return ""
}

// getTUIClassicsPath returns the path to TUIClassics launcher if found
// Checks multiple common installation locations in order:
// 1. In PATH (globally installed)
// 2. ~/TUIClassics/bin/classics
// 3. ~/projects/TUIClassics/bin/classics
// 4. ~/go/src/github.com/GGPrompts/TUIClassics/bin/classics
func getTUIClassicsPath() string {
	// First check if it's in PATH (user may have installed globally)
	if path, err := exec.LookPath("classics"); err == nil {
		return path
	}

	// Then check common installation directories
	homeDir, err := os.UserHomeDir()
	if err != nil {
		return ""
	}

	commonPaths := []string{
		filepath.Join(homeDir, "TUIClassics", "bin", "classics"),
		filepath.Join(homeDir, "projects", "TUIClassics", "bin", "classics"),
		filepath.Join(homeDir, "go", "src", "github.com", "GGPrompts", "TUIClassics", "bin", "classics"),
	}

	for _, path := range commonPaths {
		if _, err := os.Stat(path); err == nil {
			return path
		}
	}

	return ""
}

// openEditor opens a file in an external editor
func openEditor(editor, path string) tea.Cmd {
	// SECURITY: Validate filename to prevent argument injection
	// Filenames starting with '-' could be interpreted as editor flags
	cleanPath := filepath.Clean(path)
	filename := filepath.Base(cleanPath)

	if strings.HasPrefix(filename, "-") {
		return func() tea.Msg {
			return editorFinishedMsg{
				err: fmt.Errorf("invalid filename: cannot open files starting with '-' (potential argument injection)"),
			}
		}
	}

	// Use absolute path to avoid ambiguity
	absPath, err := filepath.Abs(cleanPath)
	if err != nil {
		return func() tea.Msg {
			return editorFinishedMsg{err: err}
		}
	}

	c := exec.Command(editor, absPath)
	return tea.Sequence(
		tea.ClearScreen,
		tea.ExecProcess(c, func(err error) tea.Msg {
			return editorFinishedMsg{err}
		}),
	)
}

// openTUITool opens a TUI application in the specified directory
func openTUITool(tool, dir string) tea.Cmd {
	c := exec.Command(tool)
	c.Dir = dir // Set working directory
	return tea.Sequence(
		tea.ClearScreen,
		tea.ExecProcess(c, func(err error) tea.Msg {
			return editorFinishedMsg{err}
		}),
	)
}

// launchTmuxQuad exits TFE and launches tmux with 4 equal panes in the specified directory
// Session name is derived from directory name for easy reattachment
func launchTmuxQuad(dir string) tea.Cmd {
	// Derive session name from directory (sanitize for tmux)
	sessionName := filepath.Base(dir)
	// Replace characters that tmux doesn't like in session names
	sessionName = strings.ReplaceAll(sessionName, ".", "_")
	sessionName = strings.ReplaceAll(sessionName, ":", "_")

	// Shell-quote values before interpolating into the script so paths/names
	// containing quotes or other shell metacharacters can't break out
	qDir := shellQuote(dir)
	qSession := shellQuote(sessionName)

	// Create script that launches tmux with quad split after TFE exits
	tmuxScript := fmt.Sprintf(`#!/bin/bash

# Wait for TFE to exit and terminal to settle
sleep 0.3

# Reset terminal to sane state
stty sane 2>/dev/null || true

clear

# Change to target directory first so pane 0 inherits it
cd %[1]s

# Check if session already exists
if tmux has-session -t %[2]s 2>/dev/null; then
    echo "Attaching to existing tmux session:" %[2]s
    sleep 0.5
    tmux attach-session -t %[2]s
else
    echo "Creating tmux quad session:" %[2]s
    echo "Directory:" %[1]s
    sleep 0.5
    # Create new session with quad layout (2x2 grid)
    # Pane layout:
    # +-------+-------+
    # |   0   |   1   |
    # +-------+-------+
    # |   2   |   3   |
    # +-------+-------+
    tmux new-session -d -s %[2]s -c %[1]s \; \
        split-window -h -c %[1]s \; \
        split-window -v -c %[1]s \; \
        select-pane -t 0 \; \
        split-window -v -c %[1]s \; \
        select-pane -t 0 \; \
        attach-session
fi

# Clean up temp script
rm -f "$0"
`, qDir, qSession)

	// Write script to temp file
	tmpScript := filepath.Join(os.TempDir(), fmt.Sprintf("tfe-tmux-%d.sh", os.Getpid()))
	if err := os.WriteFile(tmpScript, []byte(tmuxScript), 0755); err != nil {
		// If we can't write the script, just return without doing anything
		return nil
	}

	// Launch script detached - use platform-appropriate method
	var cmd *exec.Cmd

	if editorAvailable("setsid") {
		// Linux: Use setsid to fully detach the process
		cmd = exec.Command("setsid", "-f", "bash", tmpScript)
	} else {
		// macOS/Termux: Use nohup with background execution
		// The script runs in background (&) and nohup ensures it survives TFE exit
		cmd = exec.Command("bash", "-c", fmt.Sprintf("nohup bash %s &", shellQuote(tmpScript)))
	}

	cmd.Stdin = nil
	cmd.Stdout = nil
	cmd.Stderr = nil

	if err := cmd.Start(); err != nil {
		os.Remove(tmpScript)
		return nil
	}

	// Exit TFE so tmux can take over the terminal
	return tea.Quit
}

// copyToClipboard copies text to the system clipboard
func copyToClipboard(text string) error {
	var cmd *exec.Cmd

	// Try different clipboard commands based on platform
	if editorAvailable("termux-clipboard-set") {
		// Termux (Android) - use shell wrapper because termux-clipboard-set
		// fails with exit status 2 when using StdinPipe directly
		cmd = exec.Command("bash", "-c", fmt.Sprintf("termux-clipboard-set <<'CLIPBOARD_EOF'\n%s\nCLIPBOARD_EOF", text))
		return cmd.Run()
	} else if editorAvailable("wl-copy") {
		// Wayland - wl-copy reads from stdin
		cmd = exec.Command("wl-copy")
	} else if editorAvailable("xclip") {
		cmd = exec.Command("xclip", "-selection", "clipboard")
	} else if editorAvailable("xsel") {
		cmd = exec.Command("xsel", "--clipboard", "--input")
	} else if editorAvailable("pbcopy") {
		// macOS
		cmd = exec.Command("pbcopy")
	} else if editorAvailable("clip.exe") {
		// Windows/WSL
		cmd = exec.Command("clip.exe")
	} else {
		return fmt.Errorf("no clipboard utility found (install wl-copy, xclip, xsel, or use WSL)")
	}

	// For non-Termux platforms, use the standard StdinPipe approach
	pipe, err := cmd.StdinPipe()
	if err != nil {
		return err
	}

	if err := cmd.Start(); err != nil {
		return err
	}

	if _, err := pipe.Write([]byte(text)); err != nil {
		return err
	}

	if err := pipe.Close(); err != nil {
		return err
	}

	return cmd.Wait()
}

// isImageFile checks if a file is an image based on extension (case-insensitive)
func isImageFile(path string) bool {
	return hasAnyExt(path, []string{".png", ".jpg", ".jpeg", ".gif", ".bmp", ".svg", ".webp", ".ico", ".tiff", ".tif"})
}

// isHTMLFile checks if a file is an HTML file based on extension (case-insensitive)
func isHTMLFile(path string) bool {
	return hasAnyExt(path, []string{".html", ".htm"})
}

// isBrowserFile checks if a file should be opened in a browser
func isBrowserFile(path string) bool {
	return isImageFile(path) || isHTMLFile(path) || isPDFFile(path)
}

// isCSVFile checks if a file is a CSV/TSV file based on extension (case-insensitive)
func isCSVFile(path string) bool {
	return hasAnyExt(path, []string{".csv", ".tsv"})
}

// isPDFFile checks if a file is a PDF based on extension (case-insensitive)
func isPDFFile(path string) bool {
	return hasAnyExt(path, []string{".pdf"})
}

// isVideoFile checks if a file is a video based on extension (case-insensitive)
func isVideoFile(path string) bool {
	return hasAnyExt(path, []string{".mp4", ".mkv", ".avi", ".mov", ".webm", ".flv", ".wmv", ".m4v"})
}

// isAudioFile checks if a file is an audio file based on extension (case-insensitive)
func isAudioFile(path string) bool {
	return hasAnyExt(path, []string{".mp3", ".wav", ".flac", ".ogg", ".m4a", ".aac", ".wma", ".opus", ".ape"})
}

// isDatabaseFile checks if a file is a database file based on extension (case-insensitive)
func isDatabaseFile(path string) bool {
	return hasAnyExt(path, []string{".db", ".sqlite", ".sqlite3"})
}

// isArchiveFile checks if a file is an archive based on extension (case-insensitive)
func isArchiveFile(path string) bool {
	return hasAnyExt(path, []string{".zip", ".tar", ".gz", ".7z", ".rar", ".bz2", ".xz", ".tar.gz", ".tgz"})
}

// isWSL checks if we're running in Windows Subsystem for Linux
func isWSL() bool {
	// Check for WSL-specific indicators
	if _, err := os.Stat("/proc/version"); err == nil {
		data, err := os.ReadFile("/proc/version")
		if err == nil {
			version := string(data)
			return strings.Contains(strings.ToLower(version), "microsoft") ||
				strings.Contains(strings.ToLower(version), "wsl")
		}
	}
	return false
}

// getAvailableBrowser returns the command to open files in the default browser
func getAvailableBrowser() string {
	// WSL - try wslview first (from wslu package), then use Windows commands
	if editorAvailable("wslview") {
		return "wslview"
	}
	// Windows via WSL
	if editorAvailable("cmd.exe") {
		return "cmd.exe"
	}
	// Linux - xdg-open is the standard
	if editorAvailable("xdg-open") {
		return "xdg-open"
	}
	// macOS
	if editorAvailable("open") {
		return "open"
	}
	return ""
}

// browserOpenedMsg is returned when a file is opened in browser
type browserOpenedMsg struct {
	success bool
	err     error
}

// openInBrowser opens a file in the default browser
func openInBrowser(path string) tea.Cmd {
	browser := getAvailableBrowser()
	if browser == "" {
		return func() tea.Msg {
			return browserOpenedMsg{
				success: false,
				err:     fmt.Errorf("no browser command found (install xdg-open, wslview, or open)"),
			}
		}
	}

	return func() tea.Msg {
		var c *exec.Cmd
		browserPath := path

		// In WSL, convert Linux paths to Windows paths for better compatibility
		if isWSL() && browser != "wslview" {
			// Use wslpath to convert WSL path to Windows path
			cmd := exec.Command("wslpath", "-w", path)
			output, err := cmd.Output()
			if err != nil {
				// wslpath failed - can't open with Windows browser
				return browserOpenedMsg{
					success: false,
					err:     fmt.Errorf("failed to convert path for Windows browser: %w", err),
				}
			}
			browserPath = strings.TrimSpace(string(output))
			// Validate it looks like a Windows path (e.g., C:\path or \\wsl.localhost\...)
			if len(browserPath) < 3 {
				return browserOpenedMsg{
					success: false,
					err:     fmt.Errorf("wslpath produced invalid Windows path: %q", browserPath),
				}
			}
			// Check for drive letter (C:\) or UNC path (\\)
			hasDriveLetter := len(browserPath) >= 3 && browserPath[1] == ':' && (browserPath[2] == '\\' || browserPath[2] == '/')
			hasUNCPath := len(browserPath) >= 2 && browserPath[0] == '\\' && browserPath[1] == '\\'
			if !hasDriveLetter && !hasUNCPath {
				return browserOpenedMsg{
					success: false,
					err:     fmt.Errorf("wslpath produced invalid Windows path (expected drive letter or UNC): %q", browserPath),
				}
			}
		}

		if browser == "cmd.exe" {
			// Windows via WSL - use powershell.exe Start-Process (handles UNC paths)
			// cmd.exe /c start doesn't support UNC paths (\\wsl.localhost\...)
			c = exec.Command("powershell.exe", "-Command", "Start-Process", "'"+browserPath+"'")
		} else {
			// Linux/macOS/wslview
			c = exec.Command(browser, browserPath)
		}

		// Start the browser without blocking (browsers run in background)
		err := c.Start()
		if err != nil {
			return browserOpenedMsg{
				success: false,
				err:     err,
			}
		}

		// Success
		return browserOpenedMsg{
			success: true,
			err:     nil,
		}
	}
}

// getAvailableImageViewer returns the first available image viewer
func getAvailableImageViewer() string {
	viewers := []string{"viu", "timg", "chafa"}
	for _, viewer := range viewers {
		if editorAvailable(viewer) {
			return viewer
		}
	}
	return ""
}

// viewerPauseScript builds a bash script that runs viewerCmd on the given path
// (shell-quoted to survive apostrophes and other metacharacters in filenames)
// and pauses for a keypress before returning to TFE.
func viewerPauseScript(viewerCmd, path, prompt string) string {
	return fmt.Sprintf(`%s %s
echo ""
echo "%s"
read -n 1 -s -r`, viewerCmd, shellQuote(path), prompt)
}

// openImageViewer opens an image in a TUI viewer
func openImageViewer(path string) tea.Cmd {
	viewer := getAvailableImageViewer()
	if viewer == "" {
		return func() tea.Msg {
			return editorFinishedMsg{fmt.Errorf("no image viewer found (install viu, timg, or chafa)")}
		}
	}

	var c *exec.Cmd
	if viewer == "viu" {
		// viu with transparent background and size to terminal
		// Wrap in shell to pause after displaying image (same as command prompt)
		script := viewerPauseScript("viu -t", path, "Press any key to continue...")
		c = exec.Command("bash", "-c", script)
	} else if viewer == "timg" {
		// timg with grid view support
		script := viewerPauseScript("timg", path, "Press any key to continue...")
		c = exec.Command("bash", "-c", script)
	} else {
		// chafa or other
		script := viewerPauseScript(viewer, path, "Press any key to continue...")
		c = exec.Command("bash", "-c", script)
	}

	// Set up stdin/stdout/stderr for interaction (same as command execution)
	c.Stdin = os.Stdin
	c.Stdout = os.Stdout
	c.Stderr = os.Stderr

	return tea.Sequence(
		tea.ClearScreen,
		tea.ExecProcess(c, func(err error) tea.Msg {
			return editorFinishedMsg{err}
		}),
	)
}

// getAvailableCSVViewer returns the first available CSV/spreadsheet viewer
func getAvailableCSVViewer() string {
	viewers := []string{"visidata", "sc-im"}
	for _, viewer := range viewers {
		if editorAvailable(viewer) {
			return viewer
		}
	}
	return ""
}

// openCSVViewer opens a CSV file in a spreadsheet viewer
func openCSVViewer(path string) tea.Cmd {
	viewer := getAvailableCSVViewer()
	if viewer == "" {
		// Fallback to text editor
		editor := getAvailableEditor()
		if editor == "" {
			return func() tea.Msg {
				return editorFinishedMsg{fmt.Errorf("no CSV viewer or text editor found")}
			}
		}
		return openEditor(editor, path)
	}

	c := exec.Command(viewer, path)
	c.Stdin = os.Stdin
	c.Stdout = os.Stdout
	c.Stderr = os.Stderr

	return tea.Sequence(
		tea.ClearScreen,
		tea.ExecProcess(c, func(err error) tea.Msg {
			return editorFinishedMsg{err}
		}),
	)
}

// getAvailableVideoPlayer returns the first available video player
func getAvailableVideoPlayer() string {
	players := []string{"mpv", "vlc", "mplayer"}
	for _, player := range players {
		if editorAvailable(player) {
			return player
		}
	}
	return ""
}

// openVideoPlayer opens a video file in a media player
func openVideoPlayer(path string) tea.Cmd {
	player := getAvailableVideoPlayer()
	if player == "" {
		return func() tea.Msg {
			return editorFinishedMsg{fmt.Errorf("no video player found (install mpv)")}
		}
	}

	// mpv with terminal output
	c := exec.Command(player, path)
	c.Stdin = os.Stdin
	c.Stdout = os.Stdout
	c.Stderr = os.Stderr

	return tea.Sequence(
		tea.ClearScreen,
		tea.ExecProcess(c, func(err error) tea.Msg {
			return editorFinishedMsg{err}
		}),
	)
}

// getAvailableAudioPlayer returns the first available audio player
func getAvailableAudioPlayer() string {
	players := []string{"mpv", "cmus", "moc"}
	for _, player := range players {
		if editorAvailable(player) {
			return player
		}
	}
	return ""
}

// openAudioPlayer opens an audio file in a media player
func openAudioPlayer(path string) tea.Cmd {
	player := getAvailableAudioPlayer()
	if player == "" {
		return func() tea.Msg {
			return editorFinishedMsg{fmt.Errorf("no audio player found (install mpv)")}
		}
	}

	// mpv with audio-only mode
	c := exec.Command(player, path)
	c.Stdin = os.Stdin
	c.Stdout = os.Stdout
	c.Stderr = os.Stderr

	return tea.Sequence(
		tea.ClearScreen,
		tea.ExecProcess(c, func(err error) tea.Msg {
			return editorFinishedMsg{err}
		}),
	)
}

// getAvailableHexViewer returns the first available hex viewer
func getAvailableHexViewer() string {
	viewers := []string{"hexyl", "hexpatch", "hexabyte", "xxd"}
	for _, viewer := range viewers {
		if editorAvailable(viewer) {
			return viewer
		}
	}
	return ""
}

// openHexViewer opens a binary file in a hex viewer
func openHexViewer(path string) tea.Cmd {
	viewer := getAvailableHexViewer()
	if viewer == "" {
		return func() tea.Msg {
			return editorFinishedMsg{fmt.Errorf("no hex viewer found (install hexyl)")}
		}
	}

	var c *exec.Cmd
	if viewer == "hexyl" {
		// hexyl displays directly with built-in paging on terminals
		// Add a pause wrapper to return to TFE cleanly
		script := viewerPauseScript("hexyl", path, "Press any key to return to TFE...")
		c = exec.Command("bash", "-c", script)
	} else {
		// Other hex viewers
		c = exec.Command(viewer, path)
	}

	c.Stdin = os.Stdin
	c.Stdout = os.Stdout
	c.Stderr = os.Stderr

	return tea.Sequence(
		tea.ClearScreen,
		tea.ExecProcess(c, func(err error) tea.Msg {
			return editorFinishedMsg{err}
		}),
	)
}

// getAvailableDatabaseViewer returns the first available database viewer
func getAvailableDatabaseViewer() string {
	viewers := []string{"harlequin", "litecli", "sqlite3"}
	for _, viewer := range viewers {
		if editorAvailable(viewer) {
			return viewer
		}
	}
	return ""
}

// openDatabaseViewer opens a database file in a viewer
func openDatabaseViewer(path string) tea.Cmd {
	viewer := getAvailableDatabaseViewer()
	if viewer == "" {
		return func() tea.Msg {
			return editorFinishedMsg{fmt.Errorf("no database viewer found (install harlequin)")}
		}
	}

	c := exec.Command(viewer, path)
	c.Stdin = os.Stdin
	c.Stdout = os.Stdout
	c.Stderr = os.Stderr

	return tea.Sequence(
		tea.ClearScreen,
		tea.ExecProcess(c, func(err error) tea.Msg {
			return editorFinishedMsg{err}
		}),
	)
}

// getAvailablePDFViewer returns the first available PDF viewer
func getAvailablePDFViewer() string {
	viewers := []string{"timg", "termpdf.py"}
	for _, viewer := range viewers {
		if editorAvailable(viewer) {
			return viewer
		}
	}
	return ""
}

// openPDFViewer opens a PDF file in a terminal viewer
func openPDFViewer(path string) tea.Cmd {
	viewer := getAvailablePDFViewer()
	if viewer == "" {
		// Fallback to browser
		return openInBrowser(path)
	}

	var c *exec.Cmd
	if viewer == "timg" {
		script := viewerPauseScript("timg", path, "Press any key to continue...")
		c = exec.Command("bash", "-c", script)
	} else {
		c = exec.Command(viewer, path)
	}

	c.Stdin = os.Stdin
	c.Stdout = os.Stdout
	c.Stderr = os.Stderr

	return tea.Sequence(
		tea.ClearScreen,
		tea.ExecProcess(c, func(err error) tea.Msg {
			return editorFinishedMsg{err}
		}),
	)
}

// getAvailableImageEditor returns the first available image editor
func getAvailableImageEditor() string {
	editors := []string{"textual-paint", "durdraw"}
	for _, editor := range editors {
		if editorAvailable(editor) {
			return editor
		}
	}
	return ""
}

// openImageEditor opens an image in a TUI editor
func openImageEditor(path string) tea.Cmd {
	editor := getAvailableImageEditor()
	if editor == "" {
		return func() tea.Msg {
			return editorFinishedMsg{fmt.Errorf("no image editor found (install textual-paint)")}
		}
	}

	c := exec.Command(editor, path)
	return tea.Sequence(
		tea.ClearScreen,
		tea.ExecProcess(c, func(err error) tea.Msg {
			return editorFinishedMsg{err}
		}),
	)
}

// openImageEditorNew launches an image editor with a blank canvas (no file required)
func openImageEditorNew(currentDir string) tea.Cmd {
	editor := getAvailableImageEditor()
	if editor == "" {
		return func() tea.Msg {
			return editorFinishedMsg{fmt.Errorf("no image editor found (install textual-paint)")}
		}
	}

	// Launch textual-paint without a file argument - it will start with a blank canvas
	// Set the working directory so when user saves, it defaults to current directory
	c := exec.Command(editor)
	c.Dir = currentDir
	return tea.Sequence(
		tea.ClearScreen,
		tea.ExecProcess(c, func(err error) tea.Msg {
			return editorFinishedMsg{err}
		}),
	)
}

// fileExplorerOpenedMsg is returned when a folder is opened in file explorer
type fileExplorerOpenedMsg struct {
	success bool
	err     error
}

// openInFileExplorer opens the current directory in the system file explorer
func openInFileExplorer(path string) tea.Cmd {
	return func() tea.Msg {
		var c *exec.Cmd

		if isWSL() {
			// WSL: Use explorer.exe to open Windows Explorer
			// Convert Linux path to Windows path for better compatibility
			cmd := exec.Command("wslpath", "-w", path)
			output, err := cmd.Output()
			if err != nil {
				// wslpath failed - can't open with Windows Explorer
				return fileExplorerOpenedMsg{
					success: false,
					err:     fmt.Errorf("failed to convert path for Windows Explorer: %w", err),
				}
			}
			winPath := strings.TrimSpace(string(output))
			// Validate it looks like a Windows path (e.g., C:\path or \\wsl.localhost\...)
			if len(winPath) < 3 {
				return fileExplorerOpenedMsg{
					success: false,
					err:     fmt.Errorf("wslpath produced invalid Windows path: %q", winPath),
				}
			}
			// Check for drive letter (C:\) or UNC path (\\)
			hasDriveLetter := len(winPath) >= 3 && winPath[1] == ':' && (winPath[2] == '\\' || winPath[2] == '/')
			hasUNCPath := len(winPath) >= 2 && winPath[0] == '\\' && winPath[1] == '\\'
			if !hasDriveLetter && !hasUNCPath {
				return fileExplorerOpenedMsg{
					success: false,
					err:     fmt.Errorf("wslpath produced invalid Windows path (expected drive letter or UNC): %q", winPath),
				}
			}
			c = exec.Command("explorer.exe", winPath)
		} else if editorAvailable("xdg-open") {
			// Linux: Use xdg-open to open default file manager
			c = exec.Command("xdg-open", path)
		} else if editorAvailable("open") {
			// macOS: Use open to open Finder
			c = exec.Command("open", path)
		} else {
			return fileExplorerOpenedMsg{
				success: false,
				err:     fmt.Errorf("no file explorer command found"),
			}
		}

		// Start the file explorer without blocking
		err := c.Start()
		if err != nil {
			return fileExplorerOpenedMsg{
				success: false,
				err:     err,
			}
		}

		// Success
		return fileExplorerOpenedMsg{
			success: true,
			err:     nil,
		}
	}
}