// bibiman - a TUI for managing BibLaTeX databases
// Copyright (C) 2024  lukeflo
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
/////

use crate::bibiman::entries::EntryTableColumn;
use crate::bibiman::{bibisetup::*, search::BibiSearch};
use crate::cliargs::CLIArgs;
use crate::config::BibiConfig;
use crate::tui::popup::{PopupArea, PopupKind};
use crate::tui::Tui;
use crate::{app, cliargs};
use crate::{bibiman::entries::EntryTable, bibiman::keywords::TagList};
use arboard::Clipboard;
use color_eyre::eyre::Result;
use editor_command::EditorBuilder;
use ratatui::widgets::ScrollbarState;
use regex::Regex;
use std::fs::{self, read_to_string};
use std::fs::{File, OpenOptions};
use std::io::Write;
use std::path::PathBuf;
use std::process::Command;
use std::result::Result::Ok;
use tui_input::Input;

pub mod bibisetup;
pub mod entries;
pub mod keywords;
pub mod search;

// Areas in which actions are possible
#[derive(Debug)]
pub enum CurrentArea {
    EntryArea,
    TagArea,
    SearchArea,
    PopupArea,
}

// Check which area was active when popup set active
#[derive(Debug)]
pub enum FormerArea {
    EntryArea,
    TagArea,
    SearchArea,
}

// Application.
#[derive(Debug)]
pub struct Bibiman {
    // main bib file
    pub main_bibfiles: Vec<PathBuf>,
    // main bibliography
    pub main_biblio: BibiSetup,
    // search struct:
    pub search_struct: BibiSearch,
    // tag list
    pub tag_list: TagList,
    // table items
    pub entry_table: EntryTable,
    // scroll state info buffer
    pub scroll_info: u16,
    // area
    pub current_area: CurrentArea,
    // mode for popup window
    pub former_area: Option<FormerArea>,
    // active popup
    pub popup_area: PopupArea,
}

impl Bibiman {
    // Constructs a new instance of [`App`].
    pub fn new(args: &mut CLIArgs, cfg: &mut BibiConfig) -> Result<Self> {
        let mut main_bibfiles: Vec<PathBuf> = args.pos_args.clone();
        if cfg.general.as_ref().unwrap().bibfiles.is_some() {
            main_bibfiles.append(cfg.general.as_mut().unwrap().bibfiles.as_mut().unwrap())
        };
        let main_bibfiles = cliargs::parse_files(main_bibfiles);
        let main_biblio = BibiSetup::new(&main_bibfiles);
        let tag_list = TagList::new(main_biblio.keyword_list.clone());
        let search_struct = BibiSearch::default();
        let entry_table = EntryTable::new(main_biblio.entry_list.clone());
        let current_area = CurrentArea::EntryArea;
        Ok(Self {
            main_bibfiles,
            main_biblio,
            tag_list,
            search_struct,
            entry_table,
            scroll_info: 0,
            current_area,
            former_area: None,
            popup_area: PopupArea::default(),
        })
    }

    pub fn show_help(&mut self) {
        if let CurrentArea::EntryArea = self.current_area {
            self.former_area = Some(FormerArea::EntryArea);
        } else if let CurrentArea::TagArea = self.current_area {
            self.former_area = Some(FormerArea::TagArea);
        }
        self.popup_area.is_popup = true;
        self.current_area = CurrentArea::PopupArea;
        self.popup_area.popup_kind = Some(PopupKind::Help);
    }

    pub fn close_popup(&mut self) {
        // Reset all popup fields to default values
        self.popup_area = PopupArea::default();

        // Go back to previously selected area
        if let Some(FormerArea::EntryArea) = self.former_area {
            self.current_area = CurrentArea::EntryArea
        } else if let Some(FormerArea::TagArea) = self.former_area {
            self.current_area = CurrentArea::TagArea
        }

        // Clear former_area field
        self.former_area = None;
    }

    pub fn update_lists(&mut self) {
        self.main_biblio = BibiSetup::new(&self.main_bibfiles);
        self.tag_list = TagList::new(self.main_biblio.keyword_list.clone());
        self.entry_table = EntryTable::new(self.main_biblio.entry_list.clone());
    }

    /// Toggle moveable list between entries and tags
    pub fn toggle_area(&mut self) {
        if let CurrentArea::EntryArea = self.current_area {
            self.entry_table.entry_scroll_state = self.entry_table.entry_scroll_state.position(0);
            self.current_area = CurrentArea::TagArea;
            self.tag_list.tag_list_state.select(Some(0));
            self.tag_list.tag_scroll_state = self
                .tag_list
                .tag_scroll_state
                .position(self.tag_list.tag_list_state.selected().unwrap());
        } else if let CurrentArea::TagArea = self.current_area {
            self.current_area = CurrentArea::EntryArea;
            self.tag_list.tag_list_state.select(None);
            self.entry_table.entry_scroll_state = self
                .entry_table
                .entry_scroll_state
                .position(self.entry_table.entry_table_state.selected().unwrap());
        }
    }

    pub fn reset_current_list(&mut self) {
        self.entry_table = EntryTable::new(self.main_biblio.entry_list.clone());
        self.tag_list = TagList::new(self.main_biblio.keyword_list.clone());
        if let CurrentArea::TagArea = self.current_area {
            self.tag_list.tag_list_state.select(Some(0))
        }
        self.entry_table.entry_table_at_search_start.clear();
        self.search_struct.filtered_tag_list.clear();
        self.search_struct.inner_search = false;
        self.former_area = None
    }

    /// Yank the passed string to system clipboard
    pub fn yank_text(selection: &str) {
        let mut clipboard = Clipboard::new().unwrap();
        let yanked_text = selection.to_string();
        clipboard.set_text(yanked_text).unwrap();
    }

    pub fn scroll_info_down(&mut self) {
        self.entry_table.entry_info_scroll = self.entry_table.entry_info_scroll.saturating_add(1);
        self.entry_table.entry_info_scroll_state = self
            .entry_table
            .entry_info_scroll_state
            .position(self.entry_table.entry_info_scroll.into());
    }

    pub fn scroll_info_up(&mut self) {
        self.entry_table.entry_info_scroll = self.entry_table.entry_info_scroll.saturating_sub(1);
        self.entry_table.entry_info_scroll_state = self
            .entry_table
            .entry_info_scroll_state
            .position(self.entry_table.entry_info_scroll.into());
    }
}

impl Bibiman {
    // Entry Table commands

    /// Select next entry in Table holding the bibliographic entries.
    ///
    /// Takes u16 value as argument to specify number of entries which
    /// should be scrolled
    pub fn select_next_entry(&mut self, entries: u16) {
        self.entry_table.entry_info_scroll = 0;
        self.entry_table.entry_info_scroll_state =
            self.entry_table.entry_info_scroll_state.position(0);
        self.entry_table.entry_table_state.scroll_down_by(entries);
        self.entry_table.entry_scroll_state = self
            .entry_table
            .entry_scroll_state
            .position(self.entry_table.entry_table_state.selected().unwrap());
    }

    /// Select previous entry in Table holding the bib entries.
    ///
    /// Takes u16 value as argument to specify number of entries which
    /// should be scrolled
    pub fn select_previous_entry(&mut self, entries: u16) {
        self.entry_table.entry_info_scroll = 0;
        self.entry_table.entry_info_scroll_state =
            self.entry_table.entry_info_scroll_state.position(0);
        self.entry_table.entry_table_state.scroll_up_by(entries);
        self.entry_table.entry_scroll_state = self
            .entry_table
            .entry_scroll_state
            .position(self.entry_table.entry_table_state.selected().unwrap());
    }

    /// Select first entry in bib list
    pub fn select_first_entry(&mut self) {
        self.entry_table.entry_info_scroll = 0;
        self.entry_table.entry_info_scroll_state =
            self.entry_table.entry_info_scroll_state.position(0);
        self.entry_table.entry_table_state.select_first();
        self.entry_table.entry_scroll_state = self.entry_table.entry_scroll_state.position(0);
    }

    /// Select last entry in bib list
    pub fn select_last_entry(&mut self) {
        self.entry_table.entry_info_scroll = 0;
        self.entry_table.entry_info_scroll_state =
            self.entry_table.entry_info_scroll_state.position(0);
        // self.entry_table.entry_table_state.select_last(); // Does not work properly after upgrading to ratatui 0.29.0
        self.entry_table
            .entry_table_state
            .select(Some(self.entry_table.entry_table_items.len() - 1));
        self.entry_table.entry_scroll_state = self
            .entry_table
            .entry_scroll_state
            .position(self.entry_table.entry_table_items.len());
    }

    /// Select next (right) column of entry table
    pub fn select_next_column(&mut self) {
        if self
            .entry_table
            .entry_table_state
            .selected_column()
            .unwrap()
            == 3
        {
            self.entry_table.entry_table_state.select_first_column();
        } else {
            self.entry_table.entry_table_state.select_next_column();
        }
        match self.entry_table.entry_table_selected_column {
            EntryTableColumn::Authors => {
                self.entry_table.entry_table_selected_column = EntryTableColumn::Title;
            }
            EntryTableColumn::Title => {
                self.entry_table.entry_table_selected_column = EntryTableColumn::Year;
            }
            EntryTableColumn::Year => {
                self.entry_table.entry_table_selected_column = EntryTableColumn::Pubtype;
            }
            EntryTableColumn::Pubtype => {
                self.entry_table.entry_table_selected_column = EntryTableColumn::Authors;
            }
        }
    }

    /// Select previous (left) column of entry table
    pub fn select_prev_column(&mut self) {
        if self
            .entry_table
            .entry_table_state
            .selected_column()
            .unwrap()
            == 0
        {
            self.entry_table.entry_table_state.select_last_column();
        } else {
            self.entry_table.entry_table_state.select_previous_column();
        }
        match self.entry_table.entry_table_selected_column {
            EntryTableColumn::Authors => {
                self.entry_table.entry_table_selected_column = EntryTableColumn::Pubtype;
            }
            EntryTableColumn::Title => {
                self.entry_table.entry_table_selected_column = EntryTableColumn::Authors;
            }
            EntryTableColumn::Year => {
                self.entry_table.entry_table_selected_column = EntryTableColumn::Title;
            }
            EntryTableColumn::Pubtype => {
                self.entry_table.entry_table_selected_column = EntryTableColumn::Year;
            }
        }
    }

    pub fn select_entry_by_citekey(&mut self, citekey: &str) {
        // Search for entry by matching citekeys
        let mut idx_count = 0;
        loop {
            if idx_count == self.entry_table.entry_table_items.len() {
                idx_count = 0;
                break;
            } else if self.entry_table.entry_table_items[idx_count]
                .citekey
                .contains(citekey)
            {
                break;
            }
            idx_count += 1
        }

        // Set selected entry to vec-index of match
        self.entry_table.entry_table_state.select(Some(idx_count));
    }

    pub fn run_editor(&mut self, cfg: &BibiConfig, args: &CLIArgs, tui: &mut Tui) -> Result<()> {
        // get filecontent and citekey for calculating line number
        let citekey: &str = &self.entry_table.entry_table_items
            [self.entry_table.entry_table_state.selected().unwrap()]
        .citekey
        .clone();

        // Add comma as suffix that only
        // main citekeys are matched, not other fields like crossref
        let citekey_pattern: String = format!("{},", citekey);

        // Check if multiple files were passed to bibiman and
        // return the correct file path
        let filepath = if self.main_bibfiles.len() == 1 {
            self.main_bibfiles.first().unwrap().as_os_str()
        } else {
            let mut idx = 0;
            for f in &self.main_bibfiles {
                if search::search_pattern_in_file(&citekey_pattern, &f).is_some() {
                    break;
                }
                idx += 1;
            }
            self.main_bibfiles[idx].as_os_str()
        };
        let filecontent = fs::read_to_string(&filepath).unwrap();

        // Search the line number to place the cursor at
        let mut line_count = 0;

        for line in filecontent.lines() {
            line_count += 1;
            // if reaching the citekey break the loop
            // if reaching end of lines without match, reset to 0
            if line.contains(&citekey_pattern) {
                break;
            } else if line_count == filecontent.len() {
                eprintln!(
                    "Citekey {} not found, opening file {} at line 1",
                    citekey,
                    filepath.to_string_lossy()
                );
                line_count = 0;
                break;
            }
        }

        // Exit TUI to enter editor
        tui.exit()?;
        // Use VISUAL or EDITOR. Set "vi" as last fallback
        let mut cmd: Command = EditorBuilder::new()
            .source(cfg.general.as_ref().unwrap().editor.clone())
            .environment()
            .source(Some("vi"))
            .build()
            .unwrap();
        // Prepare arguments to open file at specific line
        let status = cmd.arg(format!("+{}", line_count)).arg(filepath).status()?;
        if !status.success() {
            eprintln!("Spawning editor failed with status {}", status);
        }

        // Enter TUI again
        tui.enter()?;
        tui.terminal.clear()?;

        // Update the database and the lists to show changes
        Self::update_lists(self);

        // Select entry which was selected before entering editor
        self.select_entry_by_citekey(citekey);

        Ok(())
    }

    pub fn add_entry(&mut self) {
        if let CurrentArea::EntryArea = self.current_area {
            self.former_area = Some(FormerArea::EntryArea);
        }
        self.popup_area.is_popup = true;
        self.current_area = CurrentArea::PopupArea;
        self.popup_area.popup_kind = Some(PopupKind::AddEntry);
    }

    ///Try to resolve entered DOI. If successfull, choose file where to append
    ///the new entry via `append_to_file()` function. If not, show error popup
    ///
    ///The method needs two arguments: the CLIArgs struct and the `str` containing the DOI
    pub fn handle_new_entry_submission(&mut self, args: &CLIArgs, doi_string: &str) {
        let doi_string = if doi_string.starts_with("10.") {
            "https://doi.org/".to_string() + doi_string
        } else {
            doi_string.to_owned()
        };

        // Send GET request to doi resolver
        let doi_entry = ureq::get(&doi_string)
            .set("Accept", "application/x-bibtex")
            .call();

        if let Ok(entry) = doi_entry {
            // Save generated bibtex entry in structs field
            let entry = entry
                .into_string()
                .expect("Couldn't parse fetched entry into string");
            self.popup_area.popup_sel_item = entry;
            self.popup_area.popup_kind = Some(PopupKind::AppendToFile);
            self.append_to_file();
            self.former_area = Some(FormerArea::EntryArea);
            self.current_area = CurrentArea::PopupArea;
            self.popup_area.popup_state.select(Some(0))
        } else {
            self.popup_area
                .popup_message("Can't find DOI: ", &doi_string, false);
        }
    }

    pub fn append_to_file(&mut self) {
        let mut items = vec!["Create new file".to_owned()];
        if self.main_bibfiles.len() > 1 {
            for f in self.main_bibfiles.clone() {
                items.push(f.to_str().unwrap().to_owned());
            }
        } else {
            items.push(
                self.main_bibfiles
                    .first()
                    .unwrap()
                    .to_str()
                    .unwrap()
                    .to_owned(),
            );
        }
        self.popup_area.popup_selection(items);
    }

    pub fn append_entry_to_file(&mut self, args: &mut CLIArgs) -> Result<()> {
        // Index of selected popup field
        let popup_idx = self.popup_area.popup_state.selected().unwrap();

        // regex pattern to match citekey in fetched bibtexstring
        let pattern = Regex::new(r"\{([^\{\},]*),").unwrap();

        let citekey = pattern
            .captures(&self.popup_area.popup_sel_item)
            .unwrap()
            .get(1)
            .unwrap()
            .as_str()
            .to_string();

        // Check if new file or existing file was choosen
        let mut file = if self.popup_area.popup_list[popup_idx].contains("Create new file") {
            let citekey = PathBuf::from(&citekey);
            // Get path of current files
            let path: PathBuf = if self.main_bibfiles[0].is_file() {
                self.main_bibfiles[0].parent().unwrap().to_owned()
            } else {
                dirs::home_dir().unwrap() // home dir as fallback
            };

            let citekey = citekey.with_extension("bib");

            let newfile = path.join(citekey);

            self.main_bibfiles.push(newfile.clone());

            File::create_new(newfile).unwrap()
        } else {
            let file_path = &self.main_bibfiles[popup_idx - 1];

            // Check if similar citekey already exists
            let file_string = read_to_string(&file_path).unwrap();

            // If choosen file contains entry with fetched citekey, append an
            // char to the citekey so no dublettes are created
            if file_string.contains(&citekey) {
                let mut new_citekey = String::new();

                // Loop over ASCII alpabetic chars and check again if citekey with
                // appended char exists. If yes, move to next char and test again.
                // If the citekey is free, use it and break the loop
                for c in b'a'..=b'z' {
                    let append_char = (c as char).to_string();
                    new_citekey = citekey.clone() + &append_char;
                    if !file_string.contains(&new_citekey) {
                        break;
                    }
                }

                let new_entry_string_clone = self.popup_area.popup_sel_item.clone();

                // Replace the double citekey with newly created
                self.popup_area.popup_sel_item = pattern
                    .replace(&new_entry_string_clone, format!("{{{},", &new_citekey))
                    .to_string();
            }

            OpenOptions::new().append(true).open(file_path).unwrap()
        };
        // Optionally, add a newline before the content
        file.write_all(b"\n")?;
        // Write content to file
        file.write_all(self.popup_area.popup_sel_item.as_bytes())?;
        // Update the database and the lists to reflect the new content
        self.update_lists();
        self.close_popup();

        // Select newly created entry
        self.select_entry_by_citekey(&citekey);

        Ok(())
    }

    pub fn open_connected_res(&mut self, cfg: &BibiConfig) -> Result<()> {
        // Index of selected entry
        let entry_idx = self.entry_table.entry_table_state.selected().unwrap();

        // Index of selected popup field
        let popup_idx = self.popup_area.popup_state.selected().unwrap();

        // Choose ressource depending an selected popup field
        if self.popup_area.popup_list[popup_idx].contains("Weblink") {
            let object = self.entry_table.entry_table_items[entry_idx].doi_url();
            let url = app::prepare_weblink(object);
            app::open_connected_link(cfg, &url)?;
        } else if self.popup_area.popup_list[popup_idx].contains("File") {
            let object = self.entry_table.entry_table_items[entry_idx].filepath();
            app::open_connected_file(cfg, object)?;
        } else {
            eprintln!("Unable to find ressource to open");
        };
        // run command to open file/Url
        self.close_popup();

        Ok(())
    }

    /// Formats a raw BibTeX entry string for better readability.
    pub fn format_bibtex_entry(entry: &str, file_path: &str) -> String {
        let mut formatted = String::new();

        // Find the position of the first '{'
        if let Some(start_brace_pos) = entry.find('{') {
            // Extract the preamble (e.g., '@article{')
            let preamble = &entry[..start_brace_pos + 1];
            let preamble = preamble.trim_start();
            formatted.push_str(preamble);
            // formatted.push('\n'); // Add newline

            // Get the content inside the braces
            let rest = &entry[start_brace_pos + 1..];
            // Remove the last '}' at the end, if present
            let rest = rest.trim_end();
            let rest = if rest.ends_with('}') {
                &rest[..rest.len() - 1]
            } else {
                rest
            };

            // Parse the fields, considering braces and quotes
            let mut fields = Vec::new();
            let mut current_field = String::new();
            let mut brace_level = 0;
            let mut in_quotes = false;
            for c in rest.chars() {
                match c {
                    '{' if !in_quotes => {
                        brace_level += 1;
                        current_field.push(c);
                    }
                    '}' if !in_quotes => {
                        brace_level -= 1;
                        current_field.push(c);
                    }
                    '"' => {
                        in_quotes = !in_quotes;
                        current_field.push(c);
                    }
                    ',' if brace_level == 0 && !in_quotes => {
                        // Outside of braces and quotes, comma separates fields
                        fields.push(current_field.trim().to_string());
                        current_field.clear();
                    }
                    _ => {
                        current_field.push(c);
                    }
                }
            }
            // Add the last field
            if !current_field.trim().is_empty() {
                fields.push(current_field.trim().to_string());
            }

            // **Conditionally Clean the Citation Key**
            if let Some(citation_key) = fields.get_mut(0) {
                // Check if the citation key contains any non-alphanumerical characters except underscores
                let needs_cleaning = citation_key
                    .chars()
                    .any(|c| !c.is_alphanumeric() && c != '_');
                if needs_cleaning {
                    // Retain only alphanumerical characters and underscores
                    let cleaned_key: String = citation_key
                        .chars()
                        .filter(|c| c.is_alphanumeric() || *c == '_')
                        .collect();
                    // If the cleaned key is longer than 14 characters, retain only the last 14
                    let limited_key = if cleaned_key.len() > 14 {
                        cleaned_key
                            .chars()
                            .rev()
                            .take(14)
                            .collect::<String>()
                            .chars()
                            .rev()
                            .collect()
                    } else {
                        cleaned_key
                    };
                    // Replace the original citation key with the cleaned and possibly limited key
                    *citation_key = limited_key;
                }
            }

            // Add the new 'file' field
            let file_field = format!("file = {{{}}}", file_path);
            fields.push(file_field);

            // Reconstruct the entry with proper indentation
            for (i, field) in fields.iter().enumerate() {
                formatted.push_str("    ");
                formatted.push_str(field);
                // Add a comma if it's not the last field
                if i < fields.len() - 1 {
                    formatted.push(',');
                }
                formatted.push('\n');
            }
            formatted.push('}'); // Close the entry
            formatted
        } else {
            // No opening brace found, return the entry as is
            entry.to_string()
        }
    }
    // Search entry list
    pub fn search_entries(&mut self) {
        // Use snapshot of entry list saved when starting the search
        // so deleting a char, will show former entries too
        let orig_list = self.entry_table.entry_table_at_search_start.clone();
        let filtered_list =
            BibiSearch::search_entry_list(&self.search_struct.search_string, orig_list.clone());
        self.entry_table.entry_table_items = filtered_list;
        self.entry_table.sort_entry_table(false);
        self.entry_table.entry_scroll_state = ScrollbarState::content_length(
            self.entry_table.entry_scroll_state,
            self.entry_table.entry_table_items.len(),
        );
    }
}

impl Bibiman {
    // Tag List commands

    // Movement
    pub fn select_next_tag(&mut self, keywords: u16) {
        self.tag_list.tag_list_state.scroll_down_by(keywords);
        self.tag_list.tag_scroll_state = self
            .tag_list
            .tag_scroll_state
            .position(self.tag_list.tag_list_state.selected().unwrap());
    }

    pub fn select_previous_tag(&mut self, keywords: u16) {
        self.tag_list.tag_list_state.scroll_up_by(keywords);
        self.tag_list.tag_scroll_state = self
            .tag_list
            .tag_scroll_state
            .position(self.tag_list.tag_list_state.selected().unwrap());
    }

    pub fn select_first_tag(&mut self) {
        self.tag_list.tag_list_state.select_first();
        self.tag_list.tag_scroll_state = self.tag_list.tag_scroll_state.position(0);
    }

    pub fn select_last_tag(&mut self) {
        // self.tag_list.tag_list_state.select_last(); // Doesn't work properly after upgrade to ratatui v.0.29
        self.tag_list
            .tag_list_state
            .select(Some(self.tag_list.tag_list_items.len() - 1));
        self.tag_list.tag_scroll_state = self
            .tag_list
            .tag_scroll_state
            .position(self.tag_list.tag_list_items.len());
    }

    pub fn get_selected_tag(&self) -> &str {
        let idx = self.tag_list.tag_list_state.selected().unwrap();
        &self.tag_list.tag_list_items[idx]
    }

    pub fn search_tags(&mut self) {
        let orig_list = &self.tag_list.tag_list_at_search_start;
        let filtered_list =
            BibiSearch::search_tag_list(&self.search_struct.search_string, orig_list.clone());
        self.tag_list.tag_list_items = filtered_list;
        // Update scrollbar length after filtering list
        self.tag_list.tag_scroll_state = ScrollbarState::content_length(
            self.tag_list.tag_scroll_state,
            self.tag_list.tag_list_items.len(),
        );
    }

    pub fn filter_tags_by_entries(&mut self) {
        let mut filtered_keywords: Vec<String> = Vec::new();

        let orig_list = &self.entry_table.entry_table_items;

        for e in orig_list {
            if !e.keywords.is_empty() {
                let mut key_vec: Vec<String> = e
                    .keywords
                    .split(',')
                    .map(|s| s.trim().to_string())
                    .filter(|s| !s.is_empty())
                    .collect();
                filtered_keywords.append(&mut key_vec);
            }
        }

        filtered_keywords.sort_by_key(|a| a.to_lowercase());
        filtered_keywords.dedup();

        self.search_struct.filtered_tag_list = filtered_keywords.clone();
        self.tag_list.tag_list_items = filtered_keywords;
        self.tag_list.tag_scroll_state = ScrollbarState::content_length(
            self.tag_list.tag_scroll_state,
            self.tag_list.tag_list_items.len(),
        );
    }

    // Filter the entry list by tags when hitting enter
    // If already inside a filtered tag or entry list, apply the filtering
    // to the already filtered list only
    pub fn filter_for_tags(&mut self) {
        let orig_list = &self.entry_table.entry_table_items;
        let keyword = self.get_selected_tag();
        let filtered_list = BibiSearch::filter_entries_by_tag(keyword, orig_list);
        // self.tag_list.selected_keyword = keyword.to_string();
        self.tag_list.selected_keywords.push(keyword.to_string());
        self.entry_table.entry_table_items = filtered_list;
        // Update scrollbar state with new lenght of itemlist
        self.entry_table.entry_scroll_state = ScrollbarState::content_length(
            self.entry_table.entry_scroll_state,
            self.entry_table.entry_table_items.len(),
        );
        self.filter_tags_by_entries();
        self.toggle_area();
        self.entry_table.entry_table_state.select(Some(0));
        self.former_area = Some(FormerArea::TagArea);
    }
}

impl Bibiman {
    // Search Area

    // Enter the search area
    pub fn enter_search_area(&mut self) {
        if let CurrentArea::EntryArea = self.current_area {
            if let Some(FormerArea::TagArea) = self.former_area {
                self.search_struct.inner_search = true
            }
            self.entry_table.entry_table_at_search_start =
                self.entry_table.entry_table_items.clone();
            self.former_area = Some(FormerArea::EntryArea)
        } else if let CurrentArea::TagArea = self.current_area {
            self.tag_list.tag_list_at_search_start = self.tag_list.tag_list_items.clone();
            self.former_area = Some(FormerArea::TagArea)
        }
        self.current_area = CurrentArea::SearchArea
    }

    // Confirm search: Search former list by pattern
    pub fn confirm_search(&mut self) {
        if let Some(FormerArea::EntryArea) = self.former_area {
            self.current_area = CurrentArea::EntryArea;
            self.entry_table.entry_table_state.select(Some(0));
            self.entry_table.entry_table_at_search_start.clear();
        } else if let Some(FormerArea::TagArea) = self.former_area {
            self.current_area = CurrentArea::TagArea;
            self.tag_list.tag_list_state.select(Some(0));
            self.tag_list.tag_list_at_search_start.clear();
        }
        self.former_area = Some(FormerArea::SearchArea);
        self.search_struct.search_string.clear();
    }

    // Break search: leave search area without filtering list
    pub fn break_search(&mut self) {
        if let Some(FormerArea::EntryArea) = self.former_area {
            self.current_area = CurrentArea::EntryArea;
            self.entry_table.entry_table_state.select(Some(0));
            self.entry_table.entry_table_at_search_start.clear();
        } else if let Some(FormerArea::TagArea) = self.former_area {
            self.current_area = CurrentArea::TagArea;
            self.tag_list.tag_list_state.select(Some(0));
            self.tag_list.tag_list_at_search_start.clear();
        }
        // But keep filtering by tag if applied before entering search area
        if !self.search_struct.inner_search {
            self.reset_current_list();
        }
        self.former_area = None;
        // If search is canceled, reset default status of struct
        self.search_struct.search_string.clear();
    }

    // Remove last char from search pattern and filter list immidiately
    pub fn search_pattern_pop(&mut self) {
        self.search_struct.search_string.pop();
        if let Some(FormerArea::EntryArea) = self.former_area {
            self.search_entries();
            self.filter_tags_by_entries();
        } else if let Some(FormerArea::TagArea) = self.former_area {
            self.search_tags();
        }
    }

    // Add current char to search pattern and filter list immidiatley
    pub fn search_pattern_push(&mut self, search_pattern: char) {
        self.search_struct.search_string.push(search_pattern);
        if let Some(FormerArea::EntryArea) = self.former_area {
            self.search_entries();
            self.filter_tags_by_entries();
        } else if let Some(FormerArea::TagArea) = self.former_area {
            self.search_tags();
        }
    }

    pub fn search_list_by_pattern(&mut self, searchpattern: &Input) {
        self.search_struct.search_string = searchpattern.value().to_string();
        if let Some(FormerArea::EntryArea) = self.former_area {
            self.search_entries();
            self.filter_tags_by_entries();
        } else if let Some(FormerArea::TagArea) = self.former_area {
            self.search_tags();
        }
    }
}

#[cfg(test)]
mod tests {
    use regex::Captures;

    use super::*;

    #[test]
    fn citekey_pattern() {
        let citekey = format!("{{{},", "a_key_2001");

        assert_eq!(citekey, "{a_key_2001,")
    }

    #[test]
    fn regex_capture_citekey() {
        let re = Regex::new(r"\{([^\{\},]*),").unwrap();

        let bibstring = String::from("@article{citekey77_2001:!?, author = {Hanks, Tom}, title = {A great book}, year = {2001}}");

        let citekey = re.captures(&bibstring).unwrap().get(1).unwrap().as_str();

        assert_eq!(citekey, "citekey77_2001:!?");

        if bibstring.contains(&citekey) {
            let append_char = "a";
            let new_entry_string_clone = bibstring.clone();

            let updated_bibstring = re
                .replace(&new_entry_string_clone, |caps: &Captures| {
                    format!("{{{}{},", &caps[1], &append_char)
                })
                .to_string();

            assert_eq!(updated_bibstring, "@article{citekey77_2001:!?a, author = {Hanks, Tom}, title = {A great book}, year = {2001}}")
        }
    }
}