ssh-portfolio/src/components/content.rs

use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;

use color_eyre::eyre::eyre;
use color_eyre::Result;
use figlet_rs::FIGfont;
use ratatui::prelude::*;
use ratatui::widgets::*;
use tokio::sync::mpsc::UnboundedSender;

use super::Component;
use crate::action::Action;
#[cfg(feature = "blog")]
use crate::components::Post;
use crate::config::Config;

pub(super) fn truncate(s: &str, max: usize) -> String {
    s.char_indices()
        .find(|(idx, ch)| idx + ch.len_utf8() > max)
        .map_or(s.to_string(), |(idx, _)| s[..idx].to_string() + "...")
}

#[derive(Default)]
pub struct Content {
    command_tx: Option<UnboundedSender<Action>>,
    config: Config,
    selected_tab: Arc<AtomicUsize>,
}

impl Content {
    pub fn new(selected_tab: Arc<AtomicUsize>) -> Self {
        Self { selected_tab, ..Default::default() }
    }

    /// Generate the content for the "About" tab
    fn about_content(&self, area: Rect) -> Result<Vec<Line<'static>>> {
        let greetings_header =
            FIGfont::from_content(include_str!("../../assets/drpepper.flf"))
                .map_err(|err| eyre!(err))?
                .convert("hiya!")
                .ok_or(eyre!("Failed to create figlet header for about page"))?
                .to_string();

        let lines: Vec<String> = greetings_header
            .trim_end_matches('\n')
            .split('\n')
            .map(String::from)
            .collect();

        let mut content = lines
            .iter()
            .enumerate()
            .map(|(pos, line)| {
                if pos == lines.len() - 3 {
                    return Line::from(vec![
                        Span::from(" "),
                        Span::from(line.clone()),
                        Span::from("  I'm Erica ("),
                        Span::styled(
                            "she/they",
                            Style::default().add_modifier(Modifier::ITALIC),
                        ),
                        Span::from(
                            "), and I make scalable systems or something. \
                             IDFK.",
                        ),
                    ]);
                }
                Line::raw(format!(" {}", line))
                    .style(Style::default().add_modifier(Modifier::BOLD))
            })
            .collect::<Vec<Line<'static>>>();

        content.extend(vec![
            Line::from(""),
            Line::from(vec![
                Span::from(" "),
                Span::from(
                    "I specialize in systems programming, primarily in ",
                ),
                Span::styled(
                    "Rust 🦀",
                    Style::default()
                        .fg(Color::LightRed)
                        .add_modifier(Modifier::BOLD | Modifier::ITALIC),
                ),
                Span::from(" and "),
                Span::styled(
                    "Luau 🦭",
                    Style::default()
                        .fg(Color::LightBlue)
                        .add_modifier(Modifier::BOLD | Modifier::ITALIC),
                ),
                Span::from("."),
            ]),
            Line::from(""),
            Line::from(
                " I am an avid believer of open-source software, and \
                 contribute to a few projects such as:",
            ),
        ]);

        let projects = vec![
            (
                Style::default()
                    .fg(Color::LightMagenta)
                    .add_modifier(Modifier::BOLD),
                "lune-org/lune: A standalone Luau runtime",
            ),
            (
                Style::default().fg(Color::Blue).add_modifier(Modifier::BOLD),
                "DiscordLuau/discord-luau: A Luau library for creating \
                 Discord bots, powered by Lune",
            ),
            (
                Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD),
                "pesde-pkg/pesde: A package manager for the Luau programming \
                 language, supporting multiple runtimes including Roblox and \
                 Lune",
            ),
        ];

        for (style, project) in projects {
            let parts: Vec<&str> = project.splitn(2, ':').collect();
            let (left, right) = if parts.len() == 2 {
                (parts[0], parts[1])
            } else {
                (project, "")
            };

            let formatted_left = Span::styled(left, style);

            let bullet = " • ";
            let indent = "   ";

            let first_line =
                if project.len() > area.width as usize - bullet.len() {
                    let split_point = project
                        .char_indices()
                        .take_while(|(i, _)| {
                            *i < area.width as usize - bullet.len()
                        })
                        .last()
                        .map(|(i, _)| i)
                        .unwrap_or(project.len());
                    let (first, rest) = project.split_at(split_point);
                    content.push(Line::from(vec![
                        Span::from(bullet),
                        formatted_left,
                        Span::from(":"),
                        Span::styled(
                            first
                                .trim_start_matches(format!("{left}:").as_str())
                                .to_string(),
                            Style::default().fg(Color::White),
                        ),
                    ]));
                    rest.to_string()
                } else {
                    content.push(Line::from(vec![
                        Span::from(bullet),
                        formatted_left,
                        Span::from(":"),
                        Span::styled(
                            right.to_string(),
                            Style::default().fg(Color::White),
                        ),
                    ]));
                    String::new()
                };

            let mut remaining_text = first_line;
            while !remaining_text.is_empty() {
                if remaining_text.len() > area.width as usize - indent.len() {
                    let split_point = remaining_text
                        .char_indices()
                        .take_while(|(i, _)| {
                            *i < area.width as usize - indent.len()
                        })
                        .last()
                        .map(|(i, _)| i)
                        .unwrap_or(remaining_text.len());
                    let (first, rest) = remaining_text.split_at(split_point);
                    content.push(Line::from(vec![
                        Span::from(indent),
                        Span::styled(
                            first.to_string(),
                            Style::default().fg(Color::White),
                        ),
                    ]));
                    remaining_text = rest.to_string();
                } else {
                    content.push(Line::from(vec![
                        Span::from(indent),
                        Span::styled(
                            remaining_text.clone(),
                            Style::default().fg(Color::White),
                        ),
                    ]));
                    remaining_text.clear();
                }
            }
        }

        content.extend(vec![
            Line::from(""),
            Line::from(
                " I am also a fan of the 8 bit aesthetic and think seals are \
                 super adorable :3",
            ),
        ]);

        Ok(content)
    }

    /// Generate the content for the "Projects" tab
    fn projects_content(&self) -> Vec<Line<'static>> {
        vec![Line::from("WIP")]
    }

    /// Generate the content for the "Blog" tab
    #[cfg(feature = "blog")]
    pub async fn blog_content(&self) -> Result<Vec<Post>> {
        Ok(crate::atproto::blog::get_all_posts()
            .await?
            .iter()
            .map(|post| Arc::new(post.clone()))
            .collect())
    }
}

impl Component for Content {
    fn register_action_handler(
        &mut self,
        tx: UnboundedSender<Action>,
    ) -> Result<()> {
        self.command_tx = Some(tx);
        Ok(())
    }

    fn register_config_handler(&mut self, config: Config) -> Result<()> {
        self.config = config;
        Ok(())
    }

    fn update(&mut self, action: Action) -> Result<Option<Action>> {
        match action {
            Action::Tick => {}
            Action::Render => {}
            _ => {}
        }
        Ok(None)
    }

    fn draw(&mut self, frame: &mut Frame, area: Rect) -> Result<()> {
        let selected_tab = self.selected_tab.load(Ordering::Relaxed);
        let content = match selected_tab {
            0 => self.about_content(area)?,
            1 => self.projects_content(),
            /* Blog tab handled in `App::render` */
            _ => vec![],
        };

        // Create the border lines
        let mut border_top = Line::default();
        border_top
            .spans
            .push(Span::styled("╭", Style::default().fg(Color::DarkGray)));

        let devcomp_width = 13;
        border_top.spans.push(Span::styled(
            "─".repeat(devcomp_width),
            Style::default().fg(Color::DarkGray),
        ));

        let tabs = ["about", "projects", "blog"];
        let mut current_pos = 1 + devcomp_width;

        for (i, &tab) in tabs.iter().enumerate() {
            let (char, style) =
                if i == self.selected_tab.load(Ordering::Relaxed) {
                    (
                        "━",
                        Style::default()
                            .fg(Color::Magenta)
                            .add_modifier(Modifier::BOLD),
                    )
                } else {
                    ("─", Style::default().fg(Color::DarkGray))
                };

            let default_style = Style::default().fg(Color::DarkGray);

            border_top.spans.push(Span::styled("┴", default_style));
            border_top.spans.push(Span::styled("─", default_style));
            border_top.spans.push(Span::styled(char.repeat(tab.len()), style));
            border_top.spans.push(Span::styled("─", default_style));
            border_top.spans.push(Span::styled("┴", default_style));

            current_pos += tab.len() + 4;
        }

        border_top.spans.push(Span::styled(
            "─".repeat(area.width as usize - current_pos - 1),
            Style::default().fg(Color::DarkGray),
        ));

        border_top
            .spans
            .push(Span::styled("╮", Style::default().fg(Color::DarkGray)));

        let border_bottom = Line::from(Span::styled(
            "╰".to_owned() + &"─".repeat(area.width as usize - 2) + "╯",
            Style::default().fg(Color::DarkGray),
        ));

        let border_left =
            Span::styled("│", Style::default().fg(Color::DarkGray));
        let border_right =
            Span::styled("│", Style::default().fg(Color::DarkGray));

        // Render the content
        let content_widget = Paragraph::new(content)
            .block(Block::default().borders(Borders::NONE))
            .wrap(Wrap { trim: false });

        frame.render_widget(
            content_widget,
            Rect {
                x: area.x + 1,
                y: area.y + 1,
                width: area.width - 2,
                height: area.height - 2,
            },
        );

        // Render the borders
        frame.render_widget(
            Paragraph::new(border_top),
            Rect { x: area.x, y: area.y, width: area.width, height: 1 },
        );

        frame.render_widget(
            Paragraph::new(border_bottom),
            Rect {
                x: area.x,
                y: area.y + area.height - 1,
                width: area.width,
                height: 1,
            },
        );

        for i in 1..area.height - 1 {
            frame.render_widget(
                Paragraph::new(Line::from(border_left.clone())),
                Rect { x: area.x, y: area.y + i, width: 1, height: 1 },
            );

            frame.render_widget(
                Paragraph::new(Line::from(border_right.clone())),
                Rect {
                    x: area.x + area.width - 1,
                    y: area.y + i,
                    width: 1,
                    height: 1,
                },
            );
        }

        Ok(())
    }
}