[package]
name = "anagram-tui"
version = "0.1.0"
publish = false
license.workspace = true
edition.workspace = true
rust-version.workspace = true

[dependencies]
color-eyre.workspace = true
crossterm.workspace = true
ratatui.workspace = true

[lints]
workspace = true

/// An interactive TUI application built with Ratatui to find anagrams of a entered name/word.
///
/// It loads words from `/usr/share/dict/words` on startup, falling back to a built-in
/// dictionary of classic anagram pairs if the file is unavailable.
use std::collections::HashMap;
use std::fs::File;
use std::io::{BufRead, BufReader};
use std::time::{Duration, Instant};

use color_eyre::Result;
use crossterm::event::{self, KeyCode, KeyEventKind};
use ratatui::layout::{Constraint, Layout, Position};
use ratatui::style::{Color, Modifier, Style};
use ratatui::text::{Line, Span, Text};
use ratatui::widgets::{Block, BorderType, List, ListItem, ListState, Paragraph};
use ratatui::{DefaultTerminal, Frame};

const FALLBACK_WORDS: &[&str] = &[
    "silent", "listen", "enlist", "tinsel", "inlets", "stone", "tones", "notes", "steno", "onset",
    "post", "stop", "tops", "pots", "spot", "opts", "meat", "team", "tame", "mate", "pears",
    "spear", "parse", "reaps", "spare", "heart", "earth", "hater", "rat", "art", "tar", "cat",
    "act", "dog", "god", "anagram", "nag a ram", "hello", "world", "rust", "tui", "ratatui",
    "baker", "brake", "break", "care", "race", "acre", "live", "evil", "veil", "vile", "lemon",
    "melon", "dormitory", "dirty room", "astronomer", "moon starer", "schoolmaster", "the classroom",
    "conversation", "voices rant on", "the eyes", "they see", "eleven plus two", "twelve plus one",
];

struct Dictionary {
    map: HashMap<String, Vec<String>>,
    total_words: usize,
    is_fallback: bool,
}

impl Dictionary {
    fn load() -> Self {
        let mut map = HashMap::new();
        let mut total_words = 0;
        let mut is_fallback = false;

        if let Ok(file) = File::open("/usr/share/dict/words") {
            let reader = BufReader::new(file);
            for line in reader.lines() {
                if let Ok(word) = line {
                    let trimmed = word.trim();
                    if trimmed.is_empty() {
                        continue;
                    }
                    // Filter out single character words except 'a' and 'i'
                    let char_count = trimmed.chars().filter(|c| c.is_alphabetic()).count();
                    if char_count == 1 {
                        let lower = trimmed.to_lowercase();
                        if lower != "a" && lower != "i" {
                            continue;
                        }
                    }
                    let key = Self::signature(trimmed);
                    if !key.is_empty() {
                        let entry = map.entry(key).or_insert_with(Vec::new);
                        let word_str = trimmed.to_string();
                        if !entry.contains(&word_str) {
                            entry.push(word_str);
                            total_words += 1;
                        }
                    }
                }
            }
        }

        // If dictionary is empty or failed to load, load fallback words
        if map.is_empty() {
            is_fallback = true;
            for &word in FALLBACK_WORDS {
                let key = Self::signature(word);
                if !key.is_empty() {
                    let entry = map.entry(key).or_insert_with(Vec::new);
                    let word_str = word.to_string();
                    if !entry.contains(&word_str) {
                        entry.push(word_str);
                        total_words += 1;
                    }
                }
            }
        }

        Self {
            map,
            total_words,
            is_fallback,
        }
    }

    fn signature(word: &str) -> String {
        let mut chars: Vec<char> = word
            .chars()
            .filter(|c| c.is_alphabetic())
            .map(|c| c.to_ascii_lowercase())
            .collect();
        chars.sort_unstable();
        chars.into_iter().collect()
    }

    fn is_sub_multiset(b: &str, a: &str) -> bool {
        if b.len() < a.len() {
            return false;
        }
        let mut a_chars = a.chars().peekable();
        for b_char in b.chars() {
            if let Some(&a_char) = a_chars.peek() {
                if b_char == a_char {
                    a_chars.next();
                } else if b_char > a_char {
                    return false;
                }
            }
        }
        a_chars.peek().is_none()
    }

    fn subtract_signature(b: &str, a: &str) -> Option<String> {
        if b.len() < a.len() {
            return None;
        }
        let mut result = String::with_capacity(b.len() - a.len());
        let mut a_chars = a.chars().peekable();
        for b_char in b.chars() {
            if let Some(&a_char) = a_chars.peek() {
                if b_char == a_char {
                    a_chars.next();
                    continue;
                } else if b_char > a_char {
                    return None;
                }
            }
            result.push(b_char);
        }
        if a_chars.peek().is_none() {
            Some(result)
        } else {
            None
        }
    }

    fn search(
        remaining_sig: &str,
        current_words: &mut Vec<String>,
        results: &mut Vec<String>,
        candidates: &[(&String, &Vec<String>)],
        clean_input: &str,
        start_time: Instant,
        max_results: usize,
        max_words: usize,
    ) {
        if remaining_sig.is_empty() {
            let phrase = current_words.join(" ");
            let clean_phrase = phrase
                .chars()
                .filter(|c| c.is_alphabetic())
                .collect::<String>()
                .to_lowercase();
            if clean_phrase != clean_input {
                results.push(phrase);
            }
            return;
        }

        if current_words.len() >= max_words {
            return;
        }

        if results.len() >= max_results {
            return;
        }

        if start_time.elapsed() > Duration::from_millis(50) {
            return;
        }

        for (key, words) in candidates {
            if let Some(next_sig) = Self::subtract_signature(remaining_sig, key) {
                for word in *words {
                    current_words.push(word.clone());
                    Self::search(
                        &next_sig,
                        current_words,
                        results,
                        candidates,
                        clean_input,
                        start_time,
                        max_results,
                        max_words,
                    );
                    current_words.pop();
                    if results.len() >= max_results || start_time.elapsed() > Duration::from_millis(50) {
                        return;
                    }
                }
            }
        }
    }

    fn find_anagrams(&self, name: &str) -> Vec<String> {
        let input_sig = Self::signature(name);
        if input_sig.is_empty() {
            return Vec::new();
        }
        let clean_input = name
            .chars()
            .filter(|c| c.is_alphabetic())
            .collect::<String>()
            .to_lowercase();

        let mut candidates: Vec<(&String, &Vec<String>)> = self
            .map
            .iter()
            .filter(|(key, _)| Self::is_sub_multiset(&input_sig, key))
            .collect();

        candidates.sort_by_key(|(key, _)| std::cmp::Reverse(key.len()));

        let mut results = Vec::new();
        let mut current_words = Vec::new();
        let start_time = Instant::now();

        Self::search(
            &input_sig,
            &mut current_words,
            &mut results,
            &candidates,
            &clean_input,
            start_time,
            1000,
            4,
        );

        results.sort_by(|a, b| {
            let a_words = a.split_whitespace().count();
            let b_words = b.split_whitespace().count();
            a_words.cmp(&b_words).then_with(|| a.cmp(b))
        });
        results.dedup();

        results
    }
}

struct App {
    dictionary: Dictionary,
    input: String,
    character_index: usize,
    anagrams: Vec<String>,
    search_duration: Duration,
    list_state: ListState,
}

impl App {
    fn new(dictionary: Dictionary) -> Self {
        Self {
            dictionary,
            input: String::new(),
            character_index: 0,
            anagrams: Vec::new(),
            search_duration: Duration::ZERO,
            list_state: ListState::default(),
        }
    }

    fn move_cursor_left(&mut self) {
        if self.character_index > 0 {
            self.character_index -= 1;
        }
    }

    fn move_cursor_right(&mut self) {
        let char_count = self.input.chars().count();
        if self.character_index < char_count {
            self.character_index += 1;
        }
    }

    fn enter_char(&mut self, new_char: char) {
        let mut chars: Vec<char> = self.input.chars().collect();
        chars.insert(self.character_index, new_char);
        self.input = chars.into_iter().collect();
        self.character_index += 1;
        self.update_anagrams();
    }

    fn delete_char(&mut self) {
        if self.character_index > 0 {
            let mut chars: Vec<char> = self.input.chars().collect();
            chars.remove(self.character_index - 1);
            self.input = chars.into_iter().collect();
            self.character_index -= 1;
            self.update_anagrams();
        }
    }

    fn update_anagrams(&mut self) {
        let start = Instant::now();
        self.anagrams = self.dictionary.find_anagrams(&self.input);
        self.search_duration = start.elapsed();
        self.list_state.select(None);
        if !self.anagrams.is_empty() {
            self.list_state.select(Some(0));
        }
    }

    fn select_next(&mut self) {
        if self.anagrams.is_empty() {
            self.list_state.select(None);
            return;
        }
        let i = match self.list_state.selected() {
            Some(i) => {
                if i >= self.anagrams.len() - 1 {
                    0
                } else {
                    i + 1
                }
            }
            None => 0,
        };
        self.list_state.select(Some(i));
    }

    fn select_previous(&mut self) {
        if self.anagrams.is_empty() {
            self.list_state.select(None);
            return;
        }
        let i = match self.list_state.selected() {
            Some(i) => {
                if i == 0 {
                    self.anagrams.len() - 1
                } else {
                    i - 1
                }
            }
            None => 0,
        };
        self.list_state.select(Some(i));
    }

    fn run(mut self, terminal: &mut DefaultTerminal) -> Result<()> {
        loop {
            terminal.draw(|frame| self.render(frame))?;

            if let Some(key) = event::read()?.as_key_press_event() {
                if key.kind == KeyEventKind::Press {
                    match key.code {
                        KeyCode::Esc => {
                            return Ok(());
                        }
                        KeyCode::Char(to_insert) => {
                            self.enter_char(to_insert);
                        }
                        KeyCode::Backspace => {
                            self.delete_char();
                        }
                        KeyCode::Left => {
                            self.move_cursor_left();
                        }
                        KeyCode::Right => {
                            self.move_cursor_right();
                        }
                        KeyCode::Down => {
                            self.select_next();
                        }
                        KeyCode::Up => {
                            self.select_previous();
                        }
                        _ => {}
                    }
                }
            }
        }
    }

    fn render(&mut self, frame: &mut Frame) {
        let chunks = Layout::vertical([
            Constraint::Length(3), // Header
            Constraint::Length(3), // Input box
            Constraint::Min(1),    // Main results area
            Constraint::Length(1), // Footer / Status bar
        ])
        .split(frame.area());

        // 1. Header
        let title_content = vec![
            Span::styled(" RATATUI ANAGRAM FINDER ", Style::default().fg(Color::Yellow).bold()),
            Span::styled(" - Hello World TUI Edition", Style::default().fg(Color::Cyan)),
        ];
        let header_paragraph = Paragraph::new(Line::from(title_content))
            .block(
                Block::bordered()
                    .border_type(BorderType::Rounded)
                    .border_style(Style::default().fg(Color::Magenta)),
            );
        frame.render_widget(header_paragraph, chunks[0]);

        // 2. Input Box
        let input_text = Paragraph::new(self.input.as_str())
            .style(Style::default().fg(Color::Yellow))
            .block(
                Block::bordered()
                    .title(" Type Your Name / Word ")
                    .border_type(BorderType::Rounded)
                    .border_style(Style::default().fg(Color::Cyan)),
            );
        frame.render_widget(input_text, chunks[1]);

        // Set cursor position in the input field
        frame.set_cursor_position(Position::new(
            chunks[1].x + self.character_index as u16 + 1,
            chunks[1].y + 1,
        ));

        // 3. Main results area (splits into list on left, stats/tips on right)
        let main_chunks = Layout::horizontal([
            Constraint::Percentage(60),
            Constraint::Percentage(40),
        ])
        .split(chunks[2]);

        // Left side: Anagrams List
        let list_items: Vec<ListItem> = self
            .anagrams
            .iter()
            .map(|word| {
                ListItem::new(Line::from(vec![
                    Span::styled("• ", Style::default().fg(Color::Cyan)),
                    Span::raw(word),
                ]))
            })
            .collect();

        let list_title = format!(" Anagrams found for '{}' ", self.input);
        let list_widget = List::new(list_items)
            .block(
                Block::bordered()
                    .title(if self.input.is_empty() {
                        " Enter a word to see anagrams ".to_string()
                    } else {
                        list_title
                    })
                    .border_type(BorderType::Rounded)
                    .border_style(Style::default().fg(Color::Green)),
            )
            .highlight_style(
                Style::default()
                    .bg(Color::Rgb(40, 40, 40))
                    .fg(Color::Yellow)
                    .add_modifier(Modifier::BOLD),
            )
            .highlight_symbol(">> ");

        frame.render_stateful_widget(list_widget, main_chunks[0], &mut self.list_state);

        // Right side: Info / Stats
        let mut info_text = Vec::new();
        info_text.push(Line::from(""));
        info_text.push(Line::from(vec![
            Span::styled("Dictionary Mode: ", Style::default().fg(Color::DarkGray)),
            if self.dictionary.is_fallback {
                Span::styled("Fallback (Built-in)", Style::default().fg(Color::Red))
            } else {
                Span::styled("System Dict (/usr/share/dict/words)", Style::default().fg(Color::Green))
            },
        ]));
        info_text.push(Line::from(vec![
            Span::styled("Dictionary Size: ", Style::default().fg(Color::DarkGray)),
            Span::styled(
                format!("{} words", self.dictionary.total_words),
                Style::default().fg(Color::White),
            ),
        ]));

        if !self.input.is_empty() {
            info_text.push(Line::from(""));
            info_text.push(Line::from(vec![
                Span::styled("Results count: ", Style::default().fg(Color::DarkGray)),
                Span::styled(
                    format!("{} anagrams", self.anagrams.len()),
                    Style::default().fg(Color::White).bold(),
                ),
            ]));
            info_text.push(Line::from(vec![
                Span::styled("Search time: ", Style::default().fg(Color::DarkGray)),
                Span::styled(
                    format!("{:.2?}", self.search_duration),
                    Style::default().fg(Color::LightGreen),
                ),
            ]));
        }

        info_text.push(Line::from(""));
        info_text.push(Line::from(Span::styled("Try typing these names/words/phrases:", Style::default().fg(Color::Cyan).underlined())));
        info_text.push(Line::from("  • Listen (gives 'silent', 'enlist', ...)"));
        info_text.push(Line::from("  • Stop   (gives 'post', 'pots', ...)"));
        info_text.push(Line::from("  • dirty room (gives 'dormitory')"));
        info_text.push(Line::from("  • moon starer (gives 'astronomer')"));

        let info_paragraph = Paragraph::new(info_text).block(
            Block::bordered()
                .title(" Statistics & Tips ")
                .border_type(BorderType::Rounded)
                .border_style(Style::default().fg(Color::Blue)),
        );
        frame.render_widget(info_paragraph, main_chunks[1]);

        // 4. Footer
        let footer_text = Text::from(Line::from(vec![
            Span::styled(" Esc ", Style::default().bg(Color::Rgb(50, 50, 50)).fg(Color::White).bold()),
            Span::styled(" Exit  |  ", Style::default().fg(Color::DarkGray)),
            Span::styled(" Up/Down ", Style::default().bg(Color::Rgb(50, 50, 50)).fg(Color::White).bold()),
            Span::styled(" Scroll Anagrams  |  ", Style::default().fg(Color::DarkGray)),
            Span::styled(" Backspace ", Style::default().bg(Color::Rgb(50, 50, 50)).fg(Color::White).bold()),
            Span::styled(" Delete  |  Type to search instantly", Style::default().fg(Color::DarkGray)),
        ]));
        let footer_paragraph = Paragraph::new(footer_text);
        frame.render_widget(footer_paragraph, chunks[3]);
    }
}

fn main() -> Result<()> {
    color_eyre::install()?;
    let dictionary = Dictionary::load();
    let app = App::new(dictionary);
    ratatui::run(|terminal| app.run(terminal))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_find_anagrams() {
        let dictionary = Dictionary::load();
        
        // Single word anagram test
        let silent_anagrams = dictionary.find_anagrams("silent");
        assert!(silent_anagrams.contains(&"listen".to_string()));
        assert!(silent_anagrams.contains(&"enlist".to_string()));
        assert!(!silent_anagrams.contains(&"silent".to_string()));

        // Multi word anagram test depending on dictionary type
        if dictionary.is_fallback {
            let multi_anagrams = dictionary.find_anagrams("rust tui");
            assert!(multi_anagrams.contains(&"tui rust".to_string()));
        } else {
            let rat_cat_anagrams = dictionary.find_anagrams("rat cat");
            assert!(rat_cat_anagrams.contains(&"cat rat".to_string()) || rat_cat_anagrams.contains(&"act tar".to_string()));
        }
    }
}

fn main() -> Result<()> {
    color_eyre::install()?;
    let dictionary = Dictionary::load();
    let app = App::new(dictionary);
    ratatui::run(|terminal| app.run(terminal))
}