lk_inside/ui/components/

file_browser.rs

//! Provides a file browsing component for navigating the file system within the TUI.

use std::{
    fs,
    path::PathBuf,
};

use ratatui::{
    widgets::ListState,
};

use crossterm::event::KeyCode;

// NEW: Define FileBrowserEvent enum
pub enum FileBrowserEvent {
    FileSelected(PathBuf),
    DirectoryEntered,
    NavigationUp,
    NoChange,
}

/// A TUI component for browsing the file system.
///
/// Allows navigation through directories, selection of files, and displaying directory contents.
pub struct FileBrowser {
    /// The current directory being displayed.
    pub current_path: PathBuf,
    /// A list of files and directories in the `current_path`.
    pub entries: Vec<PathBuf>,
    /// The state of the `List` widget used to render the entries.
    pub state: ListState,
    /// A message to display the status of the file browser (e.g., "Empty directory").
    status_message: String,
}

impl FileBrowser {
    /// Creates a new `FileBrowser` instance, initialized to the current working directory.
    ///
    /// It automatically lists the entries in the initial directory.
    pub fn new() -> Self {
        let mut browser = FileBrowser {
            current_path: std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")),
            entries: Vec::new(),
            state: ListState::default(),
            status_message: String::new(),
        };
        browser.list_entries();
        browser
    }

    /// Lists the contents of the `current_path`, populating `self.entries`.
    ///
    /// Directories are listed before files, and both are sorted alphabetically.
    /// A ".." entry is added if navigation upwards is possible.
    pub fn list_entries(&mut self) {
        self.entries.clear();
        self.status_message.clear();

        if let Ok(read_dir) = fs::read_dir(&self.current_path) {
            let mut dirs = Vec::new();
            let mut files = Vec::new();

            for entry in read_dir {
                if let Ok(entry) = entry {
                    let path = entry.path();
                    if path.is_dir() {
                        dirs.push(path);
                    } else {
                        files.push(path);
                    }
                }
            }

            dirs.sort();
            files.sort();

            if self.current_path.parent().is_some() {
                self.entries.push(PathBuf::from(".."));
            }

            self.entries.extend(dirs);
            self.entries.extend(files);

            if !self.entries.is_empty() {
                self.state.select(Some(0));
            } else {
                self.status_message = "Current directory is empty.".to_string();
                self.state.select(None);
            }
        } else {
            self.status_message = format!("Could not read directory: {}", self.current_path.display());
            self.state.select(None);
        }
    }

    /// Navigates the browser one level up in the directory hierarchy.
    ///
    /// # Returns
    ///
    /// `FileBrowserEvent` indicating if navigation occurred or not.
    pub fn navigate_up(&mut self) -> FileBrowserEvent { // Changed return type
        if let Some(parent) = self.current_path.parent() {
            self.current_path = parent.to_path_buf();
            self.list_entries();
            FileBrowserEvent::NavigationUp // Return new event type
        } else {
            FileBrowserEvent::NoChange
        }
    }

    /// Handles the selection of the currently highlighted entry.
    ///
    /// If a directory is selected (including ".."), it navigates into it.
    /// If a file is selected, it returns the `PathBuf` of that file.
    ///
    /// # Returns
    ///
    /// `FileBrowserEvent` indicating the outcome of the selection.
    pub fn select_entry(&mut self) -> FileBrowserEvent { // Changed return type
        if let Some(selected) = self.state.selected() {
            if selected < self.entries.len() {
                let path = self.entries[selected].clone();
                if path.file_name().map_or(false, |name| name == "..") {
                    let _ = self.navigate_up(); // Call navigate_up, ignore its event as we're explicitly returning one
                    FileBrowserEvent::NavigationUp // Explicitly return event
                } else if path.is_dir() {
                    self.current_path = path;
                    self.list_entries();
                    FileBrowserEvent::DirectoryEntered // Return event
                } else {
                    FileBrowserEvent::FileSelected(path) // Return event
                }
            } else {
                FileBrowserEvent::NoChange
            }
        } else {
            FileBrowserEvent::NoChange
        }
    }

    /// Returns the `PathBuf` of the currently selected entry without performing any action.
    ///
    /// # Returns
    ///
    /// `Some(PathBuf)` of the selected entry, or `None` if no entry is selected.
    pub fn selected_path(&self) -> Option<PathBuf> {
        self.state.selected().and_then(|i| self.entries.get(i).cloned())
    }

    /// Handles key events for navigating and interacting with the file browser.
    ///
    /// # Arguments
    ///
    /// * `key` - The `KeyCode` representing the pressed key.
    ///
    /// # Returns
    ///
    /// `FileBrowserEvent` indicating the outcome of the key press.
    pub fn handle_key(&mut self, key: KeyCode) -> FileBrowserEvent { // Changed return type
        let event = match key { // Store the event to return it
            KeyCode::Up => {
                if let Some(selected) = self.state.selected() {
                    if selected > 0 {
                        self.state.select(Some(selected - 1));
                    } else {
                        self.state.select(Some(self.entries.len() - 1));
                    }
                }
                FileBrowserEvent::NoChange // Movement doesn't trigger a specific event beyond redraw
            }
            KeyCode::Down => {
                if let Some(selected) = self.state.selected() {
                    if selected < self.entries.len() - 1 {
                        self.state.select(Some(selected + 1));
                    } else {
                        self.state.select(Some(0));
                    }
                } else if !self.entries.is_empty() {
                    self.state.select(Some(0));
                }
                FileBrowserEvent::NoChange // Movement doesn't trigger a specific event beyond redraw
            }
            KeyCode::Left => {
                self.navigate_up() // This will now return an event
            }
            KeyCode::Right => {
                self.select_entry() // This will now return an event
            }
            _ => FileBrowserEvent::NoChange,
        };
        event // Return the event
    }

    pub fn get_status_message(&self) -> String { // ADDED
        self.status_message.clone()
    }
}