//! The Menu is a View representing a Gopher menu. It renders the
//! colorful representation, manages the cursor and selection state,
//! and responds to input like the UP and DOWN arrows or other key
//! combinations.
//!
//! The Menu doesn't draw or perform any actions on its own, instead
//! it returns an Action to the UI representing its intent.

use crate::{
    config::SharedConfig as Config,
    gopher::{self, Type},
    terminal,
    ui::{self, Action, Key, View, MAX_COLS},
};
use std::fmt;

/// The Menu holds our Gopher Lines, a list of links, and maintains
/// both where the cursor is on screen and which lines need to be
/// drawn on screen. While the main UI can be used to prompt the user
/// for input, the Menu maintains its own `input` for the "quick
/// navigation" feature using number entry and the "incremental search"
/// (over menu links) feature using text entry.
pub struct Menu {
    /// Gopher URL
    pub url: String,
    /// Lines in the menu. Not all are links. Use the `lines()` iter
    /// or `line(N)` or `link(N)` to access one.
    spans: Vec<LineSpan>,
    /// Indexes of links in the `lines` vector. Pauper's pointers.
    pub links: Vec<usize>,
    /// Currently selected link. Index of the `links` vec.
    pub link: usize,
    /// Size of the longest line, for wrapping purposes
    pub longest: usize,
    /// Actual Gopher response
    pub raw: String,
    /// User input on a prompt() line
    pub input: String,
    /// UI mode. Interactive (Run), Printing, Raw mode...
    pub mode: ui::Mode,
    /// Scrolling offset, in rows. 0 = full screen
    pub offset: usize,
    /// Incremental search mode?
    pub searching: bool,
    /// Was this menu retrieved via TLS?
    tls: bool,
    /// Retrieved via Tor?
    tor: bool,
    /// Size of the screen currently, cols and rows
    pub size: (usize, usize),
    /// Wide mode?
    wide: bool,
    /// Scroll by how many lines?
    scroll: usize,
    /// Global config
    config: Config,
}

/// Represents a line in a Gopher menu. Provides the actual text of
/// the line, vs LineSpan which is just location data.
pub struct Line<'line, 'txt: 'line> {
    span: &'line LineSpan,
    text: &'txt str,
}

impl<'line, 'txt> Line<'line, 'txt> {
    fn new(span: &'line LineSpan, text: &'txt str) -> Line<'line, 'txt> {
        Line { span, text }
    }

    /// Visible line as text. What appeared in the raw Gopher
    /// response.
    pub fn text(&self) -> &str {
        if self.start < self.text_end {
            &self.text[self.start + 1..self.text_end]
        } else {
            ""
        }
    }

    /// Truncated version of the line, according to visible characters
    /// and MAX_COLS.
    pub fn text_truncated(&self) -> String {
        self.text().chars().take(self.truncated_len).collect()
    }

    /// URL for this line, if it's a link.
    pub fn url(&self) -> String {
        if !self.typ.is_link() || self.text_end >= self.end {
            return String::from("");
        }

        let line = &self.text[self.text_end..self.end].trim_end_matches('\r');
        let mut sel = "(null)";
        let mut host = "localhost";
        let mut port = "70";
        for (i, chunk) in line.split('\t').enumerate() {
            match i {
                0 => {}
                1 => sel = chunk,
                2 => host = chunk,
                3 => port = chunk,
                _ => break,
            }
        }

        if self.typ.is_html() {
            sel.trim_start_matches('/')
                .trim_start_matches("URL:")
                .to_string()
        } else if self.typ.is_telnet() {
            format!("telnet://{}:{}", host, port)
        } else {
            let mut path = format!("/{}{}", self.typ, sel);
            if sel.is_empty() || sel == "/" {
                path.clear();
            }
            if port == "70" {
                format!("gopher://{}{}", host, path)
            } else {
                format!("gopher://{}:{}{}", host, port, path)
            }
        }
    }
}

/// Line wraps LineSpan.
impl<'line, 'txt: 'line> std::ops::Deref for Line<'line, 'txt> {
    type Target = LineSpan;
    fn deref(&self) -> &Self::Target {
        self.span
    }
}

/// The LineSpan represents a single line's location in a Gopher menu.
/// It only exists in the context of a Menu struct - its `link`
/// field is its index in the Menu's `links` Vec, and
/// start/end/text_end point to locations in Menu's `raw` Gopher
/// response.
/// You won't really interact with this directly, instead call
/// `menu.lines()` get an iter over `Line` or `menu.line(idx)` to get
/// a single Line.
pub struct LineSpan {
    /// Gopher Item Type.
    pub typ: Type,
    /// Where this line starts in its Menu's `raw` Gopher response.
    start: usize,
    /// Where this line ends in Menu.raw.
    end: usize,
    /// Where the text/label of this line ends. Might be the same as
    /// `end`, or might be earlier.
    text_end: usize,
    /// Length of visible text, ignoring ANSI escape codes (colors).
    visible_len: usize,
    /// How many chars() to grab from text() if we want to only show
    /// `MAX_COLS` visible chars on screen, aka ignore ANSI escape
    /// codes and colors.
    truncated_len: usize,
    /// Index of this link in the Menu::links vector, if it's a
    /// `gopher::Type.is_link()`
    pub link: usize,
}

impl LineSpan {
    /// Get the length of this line's text field.
    pub fn text_len(&self) -> usize {
        self.visible_len
    }
}

/// Iterator over (dynamically created) Line structs.
pub struct LinesIter<'menu> {
    spans: &'menu [LineSpan],
    text: &'menu str,
    curr: usize,
}

impl<'menu> LinesIter<'menu> {
    fn new(spans: &'menu [LineSpan], text: &'menu str) -> LinesIter<'menu> {
        LinesIter {
            spans,
            text,
            curr: 0,
        }
    }
}

impl<'menu> Iterator for LinesIter<'menu> {
    type Item = Line<'menu, 'menu>;
    fn next(&mut self) -> Option<Self::Item> {
        if self.curr >= self.spans.len() {
            None
        } else {
            let line_with = Line::new(&self.spans[self.curr], self.text);
            self.curr += 1;
            Some(line_with)
        }
    }
}

/// Direction of a given link relative to the visible screen.
#[derive(PartialEq)]
enum LinkPos {
    Above,
    Below,
    Visible,
}

impl fmt::Display for Menu {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.url())
    }
}

impl View for Menu {
    fn is_tls(&self) -> bool {
        self.tls
    }

    fn is_tor(&self) -> bool {
        self.tor
    }

    fn raw(&self) -> &str {
        self.raw.as_ref()
    }

    fn render(&mut self) -> String {
        self.render_lines()
    }

    fn respond(&mut self, key: Key) -> Action {
        self.process_key(key)
    }

    fn set_wide(&mut self, wide: bool) {
        self.wide = wide;
    }

    fn wide(&mut self) -> bool {
        self.wide
    }

    fn term_size(&mut self, cols: usize, rows: usize) {
        self.size = (cols, rows);
    }

    fn url(&self) -> &str {
        self.url.as_ref()
    }
}

impl Menu {
    /// Create a representation of a Gopher Menu from a raw Gopher
    /// response and a few options.
    pub fn from(url: &str, response: String, config: Config, tls: bool) -> Menu {
        Menu {
            tls,
            tor: config.read().unwrap().tor,
            wide: config.read().unwrap().wide,
            scroll: config.read().unwrap().scroll,
            mode: config.read().unwrap().mode,
            ..parse(url, response, config.clone())
        }
    }

    /// Lines in this menu. Main iterator for getting Line with text.
    pub fn lines(&self) -> LinesIter {
        LinesIter::new(&self.spans, &self.raw)
    }

    /// Get a single Line in this menu by index.
    pub fn line(&self, idx: usize) -> Option<Line> {
        if idx >= self.spans.len() {
            None
        } else {
            Some(Line::new(&self.spans[idx], &self.raw))
        }
    }

    /// Find a link by its link index.
    pub fn link(&self, idx: usize) -> Option<Line> {
        let line = self.links.get(idx)?;
        self.line(*line)
    }

    fn cols(&self) -> usize {
        self.size.0
    }

    fn rows(&self) -> usize {
        self.size.1
    }

    fn scroll_by(&self) -> usize {
        if self.scroll == 0 {
            self.rows() - 1
        } else {
            self.scroll
        }
    }

    /// Calculated size of left margin.
    fn indent(&self) -> usize {
        if self.wide {
            return 0;
        }
        let cols = self.cols();
        let longest = if self.longest > MAX_COLS {
            MAX_COLS
        } else {
            self.longest
        };
        if longest > cols {
            0
        } else {
            let left = (cols - longest) / 2;
            if left > 6 {
                left - 6
            } else {
                0
            }
        }
    }

    /// Is the given link visible on screen?
    fn is_visible(&self, link: usize) -> bool {
        self.link_visibility(link) == Some(LinkPos::Visible)
    }

    /// Where is the given link relative to the screen?
    fn link_visibility(&self, i: usize) -> Option<LinkPos> {
        let &pos = self.links.get(i)?;
        Some(if pos < self.offset {
            LinkPos::Above
        } else if pos >= self.offset + self.rows() - 1 {
            LinkPos::Below
        } else {
            LinkPos::Visible
        })
    }

    /// The x and y position of a given link on screen.
    fn screen_coords(&self, link: usize) -> Option<(u16, u16)> {
        if !self.is_visible(link) {
            return None;
        }
        let &pos = self.links.get(link)?;
        let x = self.indent() + 1;
        let y = if self.offset > pos {
            pos + 1
        } else {
            pos + 1 - self.offset
        };

        Some((x as u16, y as u16))
    }

    fn render_lines(&mut self) -> String {
        let mut out = String::new();
        let limit = if self.mode == ui::Mode::Run {
            // only show as many lines as screen rows minus one
            // (status bar is always last line)
            self.rows() - 1
        } else {
            self.spans.len()
        };
        let iter = self.lines().skip(self.offset).take(limit);
        let indent = self.indent();
        let left_margin = " ".repeat(indent);

        for line in iter {
            out.push_str(&left_margin);
            let config = self.config.read().unwrap();

            if line.typ == Type::Info {
                out.push_str("      ");
            } else {
                if line.link == self.link && self.show_cursor() {
                    out.push_str(&config.theme.ui_cursor);
                    out.push('*');
                    out.push_str(reset_color!());
                } else {
                    out.push(' ');
                }
                out.push(' ');
                out.push_str(&config.theme.ui_number);
                if line.link < 9 {
                    out.push(' ');
                }
                let num = (line.link + 1).to_string();
                out.push_str(&num);
                out.push_str(". ");
                out.push_str(reset_color!());
            }

            // truncate long lines, instead of wrapping
            let text = line.text_truncated();

            // color the line
            if line.typ.is_media() {
                out.push_str(&config.theme.item_media);
            } else if line.typ.is_download() {
                out.push_str(&config.theme.item_download);
            } else if !line.typ.is_supported() {
                out.push_str(&self.config.read().unwrap().theme.item_unsupported);
            } else {
                out.push_str(match line.typ {
                    Type::Text => &config.theme.item_text,
                    Type::Menu => &config.theme.item_menu,
                    Type::Info => &config.theme.ui_menu,
                    Type::HTML => &config.theme.item_external,
                    Type::Error => &config.theme.item_error,
                    Type::Telnet => &config.theme.item_telnet,
                    Type::Search => &config.theme.item_search,
                    _ => &config.theme.item_error,
                });
            }
            out.push_str(&text);
            out.push_str(reset_color!());

            // clear rest of line
            out.push_str(terminal::ClearUntilNewline.as_ref());
            out.push_str("\r\n");
        }

        // clear remainder of screen
        out.push_str(terminal::ClearAfterCursor.as_ref());

        out
    }

    /// Clear and re-draw the cursor.
    fn reset_cursor(&mut self, old_link: usize) -> Action {
        if self.links.is_empty() {
            return Action::None;
        }
        let mut out = String::new();
        if let Some(clear) = self.clear_cursor(old_link) {
            out.push_str(clear.as_ref());
        }
        if let Some(cursor) = self.draw_cursor() {
            out.push_str(cursor.as_ref());
        }
        Action::Draw(out)
    }

    /// Clear the cursor, if it's on screen.
    fn clear_cursor(&self, link: usize) -> Option<String> {
        if self.links.is_empty() || !self.is_visible(link) {
            return None;
        }
        let (x, y) = self.screen_coords(link)?;
        Some(format!("{} {}", terminal::Goto(x, y), terminal::HideCursor))
    }

    /// Print this string to draw the cursor on screen.
    /// Returns None if no is link selected.
    fn draw_cursor(&self) -> Option<String> {
        if self.links.is_empty() || !self.show_cursor() {
            return None;
        }
        let (x, y) = self.screen_coords(self.link)?;
        Some(format!(
            "{}{}*\x1b[0m{}",
            terminal::Goto(x, y),
            self.config.read().unwrap().theme.ui_cursor,
            terminal::HideCursor
        ))
    }

    /// Should we show the cursor? Not when printing.
    fn show_cursor(&self) -> bool {
        self.mode == ui::Mode::Run
    }

    /// User input field.
    fn render_input(&self) -> String {
        format!("Find: {}{}", self.input, terminal::ShowCursor)
    }

    fn redraw_input(&self) -> Action {
        if self.searching {
            Action::Status(self.render_input())
        } else {
            Action::Status(terminal::HideCursor.to_string())
        }
    }

    /// Scroll down by a page, if possible.
    fn action_page_down(&mut self) -> Action {
        // If there are fewer menu items than screen lines, just
        // select the final link and do nothing else.
        if self.spans.len() < self.rows() {
            if !self.links.is_empty() {
                self.link = self.links.len() - 1;
                return Action::Redraw;
            }
            return Action::None;
        }

        // If we've already scrolled too far, select the final link
        // and do nothing.
        if self.offset >= self.final_offset() {
            self.offset = self.final_offset();
            if !self.links.is_empty() {
                self.link = self.links.len() - 1;
            }
            return Action::Redraw;
        }

        // Scroll...
        self.offset += self.scroll_by();

        // ...but don't go past the final line.
        if self.offset > self.final_offset() {
            self.offset = self.final_offset();
        }

        // If the selected link isn't visible...
        if Some(LinkPos::Above) == self.link_visibility(self.link) {
            // ...find the next one that is.
            if let Some(&next_link_pos) = self
                .links
                .iter()
                .skip(self.link + 1)
                .find(|&&i| i >= self.offset)
            {
                if let Some(next_link_line) = self.line(next_link_pos) {
                    self.link = next_link_line.link;
                }
            }
        }

        Action::Redraw
    }

    fn action_page_up(&mut self) -> Action {
        if self.offset > 0 {
            if self.offset > self.scroll_by() {
                self.offset -= self.scroll_by();
            } else {
                self.offset = 0;
            }
            if self.link == 0 {
                return Action::Redraw;
            }
            if let Some(dir) = self.link_visibility(self.link) {
                match dir {
                    LinkPos::Below => {
                        let scroll = self.offset;
                        if let Some(&pos) = self
                            .links
                            .iter()
                            .take(self.link)
                            .rev()
                            .find(|&&i| i < (self.rows() + scroll - 1))
                        {
                            self.link = self.line(pos).unwrap().link;
                        }
                    }
                    LinkPos::Above => {}
                    LinkPos::Visible => {}
                }
            }
            Action::Redraw
        } else if self.link > 0 {
            self.link = 0;
            Action::Redraw
        } else {
            Action::None
        }
    }

    fn action_up(&mut self) -> Action {
        // no links, just scroll up
        if self.link == 0 {
            return if self.offset > 0 {
                self.offset -= 1;
                Action::Redraw
            } else if !self.links.is_empty() {
                self.link = self.links.len() - 1;
                self.scroll_to(self.link);
                Action::Redraw
            } else {
                Action::None
            };
        }

        // if text is entered, find previous match
        if self.searching && !self.input.is_empty() {
            if let Some(pos) = self.rlink_matching(self.link, &self.input) {
                return self.action_select_link(pos);
            } else {
                return Action::None;
            }
        }

        let new_link = self.link - 1;
        if let Some(dir) = self.link_visibility(new_link) {
            match dir {
                LinkPos::Above => {
                    // scroll up by 1
                    if self.offset > 0 {
                        self.offset -= 1;
                    }
                    // select it if it's visible now
                    if self.is_visible(new_link) {
                        self.link = new_link;
                    }
                }
                LinkPos::Below => {
                    // jump to link....
                    if let Some(&pos) = self.links.get(new_link) {
                        self.offset = pos;
                        self.link = new_link;
                    }
                }
                LinkPos::Visible => {
                    // select next link up
                    let old_link = self.link;
                    self.link = new_link;
                    // scroll if we are within 5 lines of the top
                    if let Some(&pos) = self.links.get(self.link) {
                        if self.offset > 0 && pos < self.offset + 5 {
                            self.offset -= 1;
                        } else {
                            // otherwise redraw just the cursor
                            return self.reset_cursor(old_link);
                        }
                    }
                }
            }
            Action::Redraw
        } else {
            Action::None
        }
    }

    /// Final `self.offset` value.
    fn final_offset(&self) -> usize {
        let padding = (self.rows() as f64 * 0.9) as usize;
        if self.spans.len() > padding {
            self.spans.len() - padding
        } else {
            0
        }
    }

    /// Search through links to find a match based on the pattern,
    /// starting at link position `start`. returns the link position.
    fn link_matching(&self, start: usize, pattern: &str) -> Option<usize> {
        self.link_match_with_iter(pattern, &mut self.links.iter().skip(start))
    }

    /// Search backwards through all links.
    fn rlink_matching(&self, start: usize, pattern: &str) -> Option<usize> {
        self.link_match_with_iter(pattern, &mut self.links.iter().take(start).rev())
    }

    fn link_match_with_iter<'a, T>(&self, pattern: &str, it: &mut T) -> Option<usize>
    where
        T: std::iter::Iterator<Item = &'a usize>,
    {
        let pattern = pattern.to_ascii_lowercase();
        for &pos in it {
            let line = self.line(pos)?;
            if line.text().to_ascii_lowercase().contains(&pattern) {
                return Some(line.link);
            }
        }
        None
    }

    fn action_down(&mut self) -> Action {
        let new_link = self.link + 1;

        // no links or final link selected already
        if self.links.is_empty() || new_link >= self.links.len() {
            // if there are more rows, scroll down
            if self.spans.len() >= self.rows() && self.offset < self.final_offset() {
                self.offset += 1;
                return Action::Redraw;
            } else if !self.links.is_empty() {
                // wrap around
                self.link = 0;
                self.offset = 0;
                return Action::Redraw;
            }
        }

        // if text is entered, find next match
        if self.searching && !self.input.is_empty() {
            if let Some(pos) = self.link_matching(self.link + 1, &self.input) {
                return self.action_select_link(pos);
            } else {
                return Action::None;
            }
        }

        if self.link < self.links.len() {
            if let Some(dir) = self.link_visibility(new_link) {
                match dir {
                    LinkPos::Above => {
                        // jump to link....
                        if let Some(&pos) = self.links.get(new_link) {
                            self.offset = pos;
                            self.link = new_link;
                        }
                    }
                    LinkPos::Below => {
                        // scroll down by 1
                        self.offset += 1;
                        // select it if it's visible now
                        if self.is_visible(new_link) {
                            self.link = new_link;
                        }
                    }
                    LinkPos::Visible => {
                        // link is visible, so select it
                        if let Some(&pos) = self.links.get(self.link) {
                            let old_link = self.link;
                            self.link = new_link;

                            // scroll if we are within 5 lines of the end
                            if self.spans.len() >= self.rows() // dont scroll if content too small
                                && pos >= self.offset + self.rows() - 6
                            {
                                self.offset += 1;
                            } else {
                                // otherwise try to just re-draw the cursor
                                return self.reset_cursor(old_link);
                            }
                        }
                    }
                }
                Action::Redraw
            } else {
                Action::None
            }
        } else {
            Action::None
        }
    }

    /// Select and optionally scroll to a link.
    fn action_select_link(&mut self, link: usize) -> Action {
        if let Some(&pos) = self.links.get(link) {
            let old_link = self.link;
            self.link = link;
            if self.is_visible(link) {
                if !self.input.is_empty() {
                    Action::List(vec![self.redraw_input(), self.reset_cursor(old_link)])
                } else {
                    self.reset_cursor(old_link)
                }
            } else {
                if pos > 5 {
                    self.offset = pos - 5;
                } else {
                    self.offset = 0;
                }
                if !self.input.is_empty() {
                    Action::List(vec![self.redraw_input(), Action::Redraw])
                } else {
                    Action::Redraw
                }
            }
        } else {
            Action::None
        }
    }

    /// Select and open link.
    fn action_follow_link(&mut self, link: usize) -> Action {
        self.action_select_link(link);
        self.action_open()
    }

    /// Scroll to a link if it's not visible.
    fn scroll_to(&mut self, link: usize) -> Action {
        if !self.is_visible(link) {
            if let Some(&pos) = self.links.get(link) {
                if pos > 5 {
                    self.offset = pos - 5;
                } else {
                    self.offset = 0;
                }
                if self.offset > self.final_offset() {
                    self.offset = self.final_offset();
                }
                return Action::Redraw;
            }
        }
        Action::None
    }

    /// Open the currently selected link.
    fn action_open(&mut self) -> Action {
        // if the selected link isn't visible, jump to it:
        if !self.is_visible(self.link) {
            return self.scroll_to(self.link);
        }

        self.searching = false;
        self.input.clear();

        if let Some(line) = self.link(self.link) {
            let url = line.url();
            let typ = gopher::type_for_url(&url);
            match typ {
                Type::Search => {
                    let prompt = format!("{}> ", line.text());
                    Action::Prompt(
                        prompt.clone(),
                        Box::new(move |query| {
                            Action::Open(
                                format!("{}{}", prompt, query),
                                format!("{}?{}", url, query),
                            )
                        }),
                    )
                }
                Type::Error => Action::Error(line.text().to_string()),
                t if !t.is_supported() => Action::Error(format!("{:?} not supported", t)),
                _ => Action::Open(line.text().to_string(), url),
            }
        } else {
            Action::None
        }
    }

    /// self.searching == true
    fn process_search_mode_char(&mut self, c: char) -> Action {
        if c == '\n' {
            if self.link_matching(0, &self.input).is_some() {
                return self.action_open();
            } else {
                let input = self.input.clone();
                self.searching = false;
                self.input.clear();
                return Action::Error(format!("No links match: {}", input));
            }
        }

        self.input.push(c);
        if let Some(pos) = self.link_matching(0, &self.input) {
            self.action_select_link(pos)
        } else {
            self.redraw_input()
        }
    }

    /// Respond to user input.
    fn process_key(&mut self, key: Key) -> Action {
        if self.searching {
            if let Key::Char(c) = key {
                return self.process_search_mode_char(c);
            }
        }

        match key {
            Key::Char('\n') => self.action_open(),
            Key::Up | Key::Ctrl('p') | Key::Char('p') | Key::Ctrl('k') | Key::Char('k') => {
                self.action_up()
            }
            Key::Down | Key::Ctrl('n') | Key::Char('n') | Key::Ctrl('j') | Key::Char('j') => {
                self.action_down()
            }
            Key::PageUp | Key::Ctrl('-') | Key::Char('-') => self.action_page_up(),
            Key::PageDown | Key::Ctrl(' ') | Key::Char(' ') => self.action_page_down(),
            Key::Home => {
                self.offset = 0;
                self.link = 0;
                Action::Redraw
            }
            Key::End => {
                self.offset = self.final_offset();
                if !self.links.is_empty() {
                    self.link = self.links.len() - 1;
                }
                Action::Redraw
            }
            Key::Char('f') | Key::Ctrl('f') | Key::Char('/') | Key::Char('i') | Key::Ctrl('i') => {
                self.searching = true;
                self.input.clear();
                self.redraw_input()
            }
            Key::Backspace | Key::Delete => {
                if self.searching {
                    self.input.pop();
                    self.redraw_input()
                } else {
                    Action::Keypress(key)
                }
            }
            Key::Esc | Key::Ctrl('c') => {
                if self.searching {
                    if self.input.is_empty() {
                        self.searching = false;
                    } else {
                        self.input.clear();
                    }
                    self.redraw_input()
                } else {
                    Action::Keypress(key)
                }
            }
            Key::Char(c) => {
                if !c.is_ascii_digit() {
                    return Action::Keypress(key);
                }

                self.input.push(c);
                // jump to number
                let s = self
                    .input
                    .chars()
                    .take(self.input.chars().count())
                    .collect::<String>();
                if let Ok(num) = s.parse::<usize>() {
                    if num > 0 && num <= self.links.len() {
                        if self.links.len() < (num * 10) {
                            return self.action_follow_link(num - 1);
                        } else {
                            return self.action_select_link(num - 1);
                        }
                    }
                }

                Action::None
            }
            _ => Action::Keypress(key),
        }
    }
}

/// Parse gopher response into a Menu object.
pub fn parse(url: &str, raw: String, config: Config) -> Menu {
    let mut spans = vec![];
    let mut links = vec![];
    let mut longest = 0;
    let mut start = 0;

    for line in raw.split_terminator('\n') {
        // Check for Gopher's weird "end of response" message.
        if line == ".\r" || line == "." {
            break;
        }

        if line.is_empty() {
            start += 1;
            continue;
        }

        if let Some(mut span) = parse_line(start, &raw) {
            if span.text_len() > longest {
                longest = span.text_len();
            }
            if span.typ.is_link() {
                span.link = links.len();
                links.push(spans.len());
            }
            spans.push(span);
        }

        start += line.len() + 1;
    }

    Menu {
        url: url.into(),
        spans,
        links,
        longest,
        raw,
        input: String::new(),
        link: 0,
        mode: Default::default(),
        offset: 0,
        searching: false,
        size: (0, 0),
        tls: false,
        tor: false,
        wide: false,
        scroll: 0,
        config,
    }
}

/// Parses a single line from a Gopher menu into a `LineSpan` struct.
pub fn parse_line(start: usize, raw: &str) -> Option<LineSpan> {
    if raw.is_empty() || start >= raw.len() {
        return None;
    }

    let line = &raw[start..];
    let end = line.find('\n').unwrap_or_else(|| line.chars().count()) + start;
    let line = &raw[start..end]; // constrain \t search
    let text_end = if let Some(i) = line.find('\t') {
        i + start
    } else if let Some(i) = line.find('\r') {
        i + start
    } else {
        end
    };
    let typ = Type::from(line.chars().next()?).unwrap_or(Type::Binary);

    let mut truncated_len = if text_end - start > MAX_COLS {
        MAX_COLS + 1
    } else {
        text_end - start
    };
    let mut visible_len = truncated_len;

    // if this line contains colors, calculate the visible length and
    // where to truncate when abiding by `MAX_COLS`
    if raw[start..text_end].contains("\x1b[") {
        let mut is_color = false;
        let mut iter = raw[start..text_end].char_indices();
        visible_len = 0;

        while let Some((i, c)) = iter.next() {
            if is_color {
                if c == 'm' {
                    is_color = false;
                }
            } else if c == '\x1b' {
                if let Some((_, '[')) = iter.next() {
                    is_color = true;
                }
            } else if visible_len < MAX_COLS {
                truncated_len = i;
                visible_len += 1;
            } else {
                truncated_len = i;
                visible_len = MAX_COLS + 1;
                break;
            }
        }
    }

    Some(LineSpan {
        start,
        end,
        text_end,
        truncated_len,
        visible_len,
        typ,
        link: 0,
    })
}

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

    macro_rules! parse {
        ($s:expr) => {
            parse("test", $s.to_string(), Config::default())
        };
    }

    #[test]
    fn test_simple_menu() {
        let menu = parse!(
            "
i---------------------------------------------------------
1SDF PHLOGOSPHERE (297 phlogs)	/phlogs/	gopher.club	70
1SDF GOPHERSPACE (1303 ACTIVE users)	/maps/	sdf.org	70
1Geosphere	Geosphere	earth.rice.edu
iwacky links
i-----------	spacer
8DJ's place	a	bbs.impakt.net	6502
hgit tree	/URL:https://github.com/my/code	(null)	70
i-----------	spacer	localhost	70
i---------------------------------------------------------
"
        );
        assert_eq!(menu.spans.len(), 10);
        assert_eq!(menu.links.len(), 5);
        assert_eq!(
            menu.lines().nth(1).unwrap().url(),
            "gopher://gopher.club/1/phlogs/"
        );
        assert_eq!(
            menu.lines().nth(2).unwrap().url(),
            "gopher://sdf.org/1/maps/"
        );
        assert_eq!(
            menu.lines().nth(3).unwrap().url(),
            "gopher://earth.rice.edu/1Geosphere"
        );
        assert_eq!(menu.lines().nth(4).unwrap().text(), "wacky links");
        assert_eq!(menu.lines().nth(5).unwrap().text(), "-----------");
        assert_eq!(
            menu.lines().nth(6).unwrap().url(),
            "telnet://bbs.impakt.net:6502"
        );
        assert_eq!(
            menu.lines().nth(7).unwrap().url(),
            "https://github.com/my/code"
        );
        assert_eq!(menu.lines().nth(8).unwrap().text(), "-----------");
    }

    #[test]
    fn test_no_path() {
        let menu = parse!("1Circumlunar Space		circumlunar.space	70");
        assert_eq!(menu.links.len(), 1);
        assert_eq!(
            menu.lines().next().unwrap().url(),
            "gopher://circumlunar.space"
        );
    }

    #[test]
    fn test_find_links() {
        let mut menu = parse!(
            "
i________________________________G_O_P_H_E_R_______________________________	Err	bitreich.org	70
iHelp us building a nice sorted directory of the gopherspace:	Err	bitreich.org	70
1THE GOPHER LAWN – THE gopher directory	/lawn	bitreich.org	70
i	Err	bitreich.org	70
1Gopher Tutorials Project	/tutorials	bitreich.org	70
i	Err	bitreich.org	70
iRun more gopherholes on tor!	Err	bitreich.org	70
1The Gopher Onion Initiative	/onion	bitreich.org	70
i	Err	bitreich.org	70
1You are missing a gopher client? Use our kiosk mode.	/kiosk	bitreich.org	70
hssh kiosk@bitreich.org	URL:ssh://kiosk@bitreich.org	bitreich.org	70
i	Err	bitreich.org	70
iFurther gopherspace links:	Err	bitreich.org	70
1The Gopher Project	/	gopherproject.org	70
7Search the global gopherspace at Veronica II	/v2/vs	gopher.floodgap.com	70
i	Err	bitreich.org	70
iBest viewed using:	Err	bitreich.org	70
1sacc	/scm/sacc	bitreich.org	70
1clic	/scm/clic	bitreich.org	70
i	Err	bitreich.org	70
"
        );
        menu.term_size(80, 40);

        assert_eq!(menu.links.len(), 9);
        assert_eq!(menu.link(0).unwrap().url(), "gopher://bitreich.org/1/lawn");
        assert_eq!(
            menu.link(1).unwrap().url(),
            "gopher://bitreich.org/1/tutorials"
        );
        assert_eq!(menu.link(2).unwrap().url(), "gopher://bitreich.org/1/onion");
        assert_eq!(menu.link(3).unwrap().url(), "gopher://bitreich.org/1/kiosk");
        assert_eq!(menu.link, 0);

        let ssh = menu.link(4).unwrap();
        assert_eq!(ssh.url(), "ssh://kiosk@bitreich.org");
        assert_eq!(ssh.typ, Type::HTML);

        menu.action_down();
        assert_eq!(menu.link, 1);
        assert_eq!(menu.link(menu.link).unwrap().link, 1);

        menu.action_down();
        assert_eq!(menu.link, 2);
        assert_eq!(menu.link(menu.link).unwrap().link, 2);

        menu.action_page_down();
        assert_eq!(menu.link, 8);
        assert_eq!(menu.link(menu.link).unwrap().link, 8);

        menu.action_up();
        assert_eq!(menu.link, 7);
        assert_eq!(menu.link(menu.link).unwrap().link, 7);

        assert_eq!(menu.offset, 0);
        menu.action_page_up();
        assert_eq!(menu.link, 0);
        assert_eq!(menu.link(menu.link).unwrap().link, 0);
    }

    #[test]
    fn test_color_lines() {
        let long_color_line = "ihi there. \x1b[1mthis\x1b[0m is a preeeeeety long line with \x1b[93mcolors \x1b[92mthat make it \x1b[91mseem longer than it is\x1b[0m	/kiosk	bitreich.org	70";

        let menu = parse!(long_color_line);
        let line = menu.lines().next().unwrap();
        assert_eq!(long_color_line.chars().count(), 139);
        assert_eq!(line.visible_len, MAX_COLS + 1);
        assert_eq!(line.truncated_len, 100);
        assert_eq!(
            line.text_truncated(),
            "hi there. \x1b[1mthis\x1b[0m is a preeeeeety long line with \x1b[93mcolors \x1b[92mthat make it \x1b[91mseem longer".to_string()
        );

        let long_reg_line = "1This is a regular line that is long but also has links and stuff. You are missing a gopher client? Use our kiosk mode. Thanks for coming. Hope you enjoy the fish, it's freshly grown in our lab!	/kiosk	bitreich.org	70";
        let menu = parse!(long_reg_line);
        let line = menu.lines().next().unwrap();
        assert_eq!(long_color_line.chars().count(), 139);
        assert_eq!(line.visible_len, MAX_COLS + 1);
        assert_eq!(line.truncated_len, MAX_COLS + 1);
        assert_eq!(
            line.text_truncated(),
            "This is a regular line that is long but also has links and stuff. You are miss"
                .to_string()
        );
    }
}