rtlibs-tui 0.1.5

use std::path::PathBuf;

use crossterm::event::KeyCode;
use crossterm::event::KeyModifiers;

use crate::widgets::KeyEventHandler;
use crate::Result;

use super::InputState;

pub enum InputEvent
{
    NotHandled,
    Handled,
    Change(String),
    Confirm(String),
    Cancel(),
}

impl KeyEventHandler<'_, InputEvent> for InputState
{
    fn handle_key_event(
        &mut self,
        code: KeyCode,
        _modifiers: KeyModifiers,
    ) -> Result<InputEvent>
    {
        self.pending = None;

        let response = match code
        {
            KeyCode::Esc =>
            {
                self.clear_placeholder();
                if self.clear_on_cancel
                {
                    self.clear();
                }
                InputEvent::Cancel()
            }
            KeyCode::Char(to_insert) =>
            {
                self.clear_placeholder();
                self.enter_char(to_insert);

                // self.placeholder
                //     .clear();
                // self.placeholder_options
                //     .clear();
                // self.placeholder_options_index = 0;

                // if self
                //     .placeholder
                //     .is_some()
                // {
                // self.placeholder = None;
                // let mut prefix = "";

                let path = self.word_under_cursor();
                // println!("+++{path}+++");
                let path = PathBuf::from(path);
                if path.is_dir() && to_insert == '/'
                {
                    // self.placeholder = Some("DIR!!!".to_string());
                    let dirs = std::fs::read_dir(path)?;
                    // let mut available = Vec::new();
                    for dir in dirs
                    {
                        let dir = dir?;
                        let dirname = dir
                            .file_name()
                            .into_string()
                            .unwrap();
                        self.placeholder_options
                            .push(dirname);
                        // available.push(dirname);
                    }
                    // let first = available
                    //     .first()
                    //     .cloned()
                    //     .unwrap_or_default();
                    // self.placeholder = Some(first);
                }
                else
                {
                    // self.placeholder = Some(
                    //     format!(
                    //         "{:?}",
                    //         path.file_name()
                    //     ),
                    // );

                    if let Some(base) = path.parent()
                    {
                        let remaining = path
                            .file_name()
                            .unwrap_or_default();
                        if base.exists()
                        {
                            let prefix = remaining
                                .to_str()
                                .unwrap();
                            let dirs = std::fs::read_dir(base)?;
                            // let mut available = Vec::new();
                            for dir in dirs
                            {
                                let dir = dir?;
                                let dirname = dir
                                    .file_name()
                                    .into_string()
                                    .unwrap();

                                // self.placeholder = Some(
                                //     format!(
                                //         "{} {basename}",
                                //         dirname.clone()
                                //     ),
                                // );
                                if dirname.starts_with(prefix)
                                {
                                    self.placeholder_options
                                        .push(
                                            dirname
                                                .strip_prefix(prefix)
                                                .unwrap()
                                                .to_string(),
                                        );
                                    // available.push(dirname);
                                }
                            }
                            // let first = available
                            //     .first()
                            //     .cloned()
                            //     .unwrap_or_default()
                            //     .strip_prefix(basename)
                            //     .unwrap_or_default()
                            //     .to_string();
                            // self.placeholder = Some(first);
                        }
                        else
                        {
                            // self.placeholder = Some("BASE DOES NOT EXIST".to_string());
                        }
                    }
                    else
                    {
                        // self.placeholder = Some("NO PARENT".to_string());
                    }
                }
                if !self
                    .placeholder_options
                    .is_empty()
                {
                    //
                }
                self.placeholder_options
                    .sort();
                let first = self
                    .placeholder_options
                    .first()
                    .cloned()
                    .unwrap_or_default();
                // .strip_prefix(prefix)
                // .unwrap_or_default()
                // .to_string();
                // let first = available
                //     .first()
                //     .cloned()
                //     .unwrap_or_default()
                //     .strip_prefix(basename)
                //     .unwrap_or_default()
                //     .to_string();
                self.placeholder = first;
                // }
                // else if to_insert == '/'
                // {
                // self.placeholder = Some("".to_string());
                // }
                InputEvent::Change(
                    self.input
                        .clone(),
                )
            }
            KeyCode::Delete =>
            {
                self.clear_placeholder();
                self.supp_char();
                InputEvent::Change(
                    self.input
                        .clone(),
                )
            }
            KeyCode::Backspace =>
            {
                self.clear_placeholder();
                self.delete_char();
                InputEvent::Change(
                    self.input
                        .clone(),
                )
            }
            KeyCode::Left =>
            {
                self.clear_placeholder();
                self.move_cursor_left();
                InputEvent::Handled
            }
            KeyCode::Right =>
            {
                self.clear_placeholder();
                self.move_cursor_right();
                InputEvent::Handled
            }
            KeyCode::Home =>
            {
                self.clear_placeholder();
                self.move_cursor_start();
                InputEvent::Handled
            }
            KeyCode::End =>
            {
                self.clear_placeholder();
                self.move_cursor_end();
                InputEvent::Handled
            }
            KeyCode::Enter =>
            {
                self.clear_placeholder();
                let result = InputEvent::Confirm(
                    self.input
                        .clone(),
                );
                if self.clear_on_confirm
                {
                    self.clear();
                }
                result
            }
            KeyCode::Tab =>
            {
                if self
                    .placeholder_options
                    .len()
                    > 1
                {
                    self.placeholder_options_index = self
                        .placeholder_options_index
                        .saturating_add(1)
                        .rem_euclid(
                            self.placeholder_options
                                .len(),
                        );
                    let placeholder = self
                        .placeholder_options
                        .get(self.placeholder_options_index)
                        .unwrap()
                        .clone();
                    self.placeholder = placeholder;
                    // self.write(placeholder);
                    InputEvent::Handled
                }
                else if self
                    .placeholder
                    .is_empty()
                {
                    InputEvent::NotHandled
                }
                else
                {
                    self.write(
                        self.placeholder
                            .clone(),
                    );
                    self.placeholder = String::new();
                    InputEvent::Handled
                }
            }
            _ => InputEvent::NotHandled,
        };

        Ok(response)
    }
}