rtlibs-tui 0.1.5

use clap::ArgMatches;
use crossterm::event::KeyCode;
use crossterm::event::KeyModifiers;

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

use super::CommanderMode;
use super::CommanderState;

pub enum CommanderEvent
{
    Handled,
    Action(
        (
            String,
            ArgMatches,
        ),
    ),
}

impl KeyEventHandler<'_, CommanderEvent> for CommanderState
{
    fn handle_key_event(
        &mut self,
        code: KeyCode,
        modifiers: KeyModifiers,
    ) -> Result<CommanderEvent>
    {
        self.error_message = None;

        if self
            .mode
            .eq(&CommanderMode::Message)
        {
            if code.eq(&KeyCode::Char(':'))
            {
                self.mode = CommanderMode::Input;
            }
            else if code.eq(&KeyCode::Esc)
            {
                self.message
                    .clear();
                self.message_style
                    .take();
            }

            Ok(CommanderEvent::Handled)
        }
        else if code.eq(&KeyCode::Esc)
        {
            // self.selected_index = None;
            // self.input
            //     .clear();
            // // self.filter
            // //     .clear();
            // self.message
            //     .clear();
            // self.message_style
            //     .take();
            // self.mode = CommanderMode::Message;
            self.clear_edit();
            Ok(CommanderEvent::Handled)
        }
        else if code.eq(&KeyCode::Tab)
            && !self
                .input
                .has_placeholder()
        {
            let (filtered, _) = self.filtered();
            let count_filtered = filtered.len();

            if count_filtered == 0
            {
                return Ok(CommanderEvent::Handled);
            }

            let new_index = self
                .selected_index
                .map(
                    |i| {
                        i.saturating_add(1)
                            .rem_euclid(count_filtered)
                    },
                )
                .unwrap_or_default();

            self.selected_index = Some(new_index);

            // self.in

            let (filtered, same_level) = self.filtered();
            let command_name = filtered
                .get(
                    self.selected_index
                        .unwrap(),
                )
                .unwrap()
                .get_name()
                .to_string();

            if same_level
            {
                let filter = self.get_input_filter();
                let command_name = command_name
                    .strip_prefix(&filter)
                    .unwrap_or(&command_name);
                // let input = self
                //     .input
                //     .input();
                self.input
                    .write_pending(command_name);
                // .write(format!("{command_name}"));

                //
            }
            else
            {
                self.input
                    .write_pending(command_name);
                // .write_pending(format!("{command_name}"));
            }
            // self.input
            // .write_pending(&command_name);

            Ok(CommanderEvent::Handled)
        }
        else if code.eq(&KeyCode::BackTab)
            && !self
                .input
                .has_placeholder()
        {
            let (filtered, _) = self.filtered();
            let count_filtered = filtered.len();

            if count_filtered == 0
            {
                return Ok(CommanderEvent::Handled);
            }

            let new_index = self
                .selected_index
                .map(
                    |i| {
                        if i == 0
                        {
                            count_filtered - 1
                        }
                        else
                        {
                            i - 1
                        }
                    },
                )
                .unwrap_or_default();

            self.selected_index = Some(new_index);

            Ok(CommanderEvent::Handled)
        }
        else
        {
            match self
                .input
                .handle_key_event(
                    code, modifiers,
                )?
            {
                InputEvent::NotHandled =>
                {
                    //     if code.eq(&KeyCode::Tab)
                    //     {
                    //         let (filtered, _) = self.filtered();
                    //         let count_filtered = filtered.len();

                    //         if count_filtered == 0
                    //         {
                    //             return Ok(CommanderEvent::Handled);
                    //         }

                    //         let new_index = self
                    //             .selected_index
                    //             .map(
                    //                 |i| {
                    //                     i.saturating_add(1)
                    //                         .rem_euclid(count_filtered)
                    //                 },
                    //             )
                    //             .unwrap_or_default();

                    //         self.selected_index = Some(new_index);

                    //         // self.in

                    //         let (filtered, same_level) = self.filtered();
                    //         let command_name = filtered
                    //             .get(
                    //                 self.selected_index
                    //                     .unwrap(),
                    //             )
                    //             .unwrap()
                    //             .get_name()
                    //             .to_string();

                    //         if same_level
                    //         {
                    //             let filter = self.get_input_filter();
                    //             let command_name = command_name
                    //                 .strip_prefix(&filter)
                    //                 .unwrap_or(&command_name);
                    //             // let input = self
                    //             //     .input
                    //             //     .input();
                    //             self.input
                    //                 .write_pending(command_name);
                    //             // .write(format!("{command_name}"));

                    //             //
                    //         }
                    //         else
                    //         {
                    //             self.input
                    //                 .write_pending(command_name);
                    //             // .write_pending(format!("{command_name}"));
                    //         }
                    //         // self.input
                    //         // .write_pending(&command_name);

                    //         return Ok(CommanderEvent::Handled);
                    //     }
                    //     else if code.eq(&KeyCode::BackTab)
                    //     {
                    //         let (filtered, _) = self.filtered();
                    //         let count_filtered = filtered.len();

                    //         if count_filtered == 0
                    //         {
                    //             return Ok(CommanderEvent::Handled);
                    //         }

                    //         let new_index = self
                    //             .selected_index
                    //             .map(
                    //                 |i| {
                    //                     if i == 0
                    //                     {
                    //                         count_filtered - 1
                    //                     }
                    //                     else
                    //                     {
                    //                         i - 1
                    //                     }
                    //                 },
                    //             )
                    //             .unwrap_or_default();

                    //         self.selected_index = Some(new_index);

                    //         return Ok(CommanderEvent::Handled);
                    //     }
                }
                InputEvent::Handled => (),
                InputEvent::Change(_) =>
                {
                    self.selected_index = None;
                }
                InputEvent::Confirm(_) =>
                {
                    let Some((name, args)) = self.execute_command()
                    else
                    {
                        return Ok(CommanderEvent::Handled);
                    };
                    return Ok(
                        CommanderEvent::Action((
                            name, args,
                        )),
                    );
                }
                InputEvent::Cancel() => (),
            };

            Ok(CommanderEvent::Handled)
        }
    }
}