basic tui implementation

src/anime/anime.rs

@@ -13,7 +13,7 @@ pub fn anime_stream(search: String, episode: u32, resume: bool) {
         string_input("Search anime: ")
     };
 
-    let anime_list = anime_names(&query);
+    let anime_list = anime_names(query);
     let mut count = 0;
     print!("\x1B[2J\x1B[1;1H");
     anime_list.iter().for_each(|anime| {

src/anime/player.rs

@@ -9,5 +9,4 @@ pub fn open_video(link: (String, String)) {
         .expect("failed to open mpv");
 
     // clear terminal
-    print!("\x1b[2J\x1b[1;1H");
 }

src/anime/scraper.rs

@@ -31,7 +31,7 @@ pub fn get_ep_location(url: &str) -> String {
     location.to_str().unwrap().to_string()
 }
 
-pub fn anime_names(query: &str) -> Vec<String> {
+pub fn anime_names(query: String) -> Vec<String> {
     let url = format!("https://gogoanime.lu//search.html?keyword={}", query);
     //relpace all spaces with %20
     let url = url.replace(' ', "%20");

src/main.rs

@@ -1,6 +1,7 @@
 mod anime;
 mod helpers;
 mod ln;
+mod ui;
 
 use anime::anime::anime_stream;
 use colored::Colorize;
@@ -14,7 +15,7 @@ use crate::anime::{
 };
 use crate::helpers::take_input::{int_input, string_input};
 use crate::ln::{menu::chapter_selector, open_text::open_bat, scraper::get_full_text};
-
+use crate::ui::anime_ui::ui_anime;
 fn main() {
     let mut help = false;
     let mut anime = false;
@@ -89,7 +90,8 @@ fn main() {
     if ln == true {
         ln_read(&search, chapter);
     } else if anime == true {
-        anime_stream(search, episode, resume);
+        //anime_stream(search, episode, resume);
+        ui_anime();
     } else {
         println!("Invalid argument");
     }

src/ui/anime_ui.rs

@@ -0,0 +1,286 @@
+use crate::open_video;
+use crate::{anime_ep_range, anime_link, anime_names};
+use crate::{get_anime_id, get_token, get_user_anime_progress, update_anime_progress};
+
+use crossterm::{
+    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+};
+use std::{error::Error, io};
+use tui::{
+    backend::{Backend, CrosstermBackend},
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    text::{Span, Spans, Text},
+    widgets::{Block, BorderType, Borders, List, ListItem, ListState, Paragraph},
+    Frame, Terminal,
+};
+use unicode_width::UnicodeWidthStr;
+
+enum InputMode {
+    Normal,
+    Editing,
+}
+
+struct StatefulList<T> {
+    state: ListState,
+    items: Vec<T>,
+}
+
+impl<T> StatefulList<T> {
+    fn with_items(items: Vec<T>) -> StatefulList<T> {
+        StatefulList {
+            state: ListState::default(),
+            items,
+        }
+    }
+
+    fn next(&mut self) {
+        let i = match self.state.selected() {
+            Some(i) => {
+                if i >= self.items.len() - 1 {
+                    0
+                } else {
+                    i + 1
+                }
+            }
+            None => 0,
+        };
+        self.state.select(Some(i));
+    }
+
+    fn previous(&mut self) {
+        let i = match self.state.selected() {
+            Some(i) => {
+                if i == 0 {
+                    self.items.len() - 1
+                } else {
+                    i - 1
+                }
+            }
+            None => 0,
+        };
+        self.state.select(Some(i));
+    }
+
+    fn unselect(&mut self) {
+        self.state.select(None);
+    }
+    fn push(&mut self, item: T) {
+        self.items.push(item);
+    }
+    fn iter(&self) -> impl Iterator<Item = &T> {
+        self.items.iter()
+    }
+}
+
+struct App {
+    /// Current value of the input box
+    input: String,
+    /// Current input mode
+    input_mode: InputMode,
+    /// History of recorded messages
+    messages: StatefulList<String>,
+    title: String,
+    ep: u64,
+}
+
+impl<'a> App {
+    fn default() -> App {
+        App {
+            input: String::new(),
+            input_mode: InputMode::Normal,
+            messages: StatefulList::with_items(Vec::new()),
+            title: String::new(),
+            ep: 0,
+        }
+    }
+}
+
+pub fn ui_anime() -> Result<(), Box<dyn Error>> {
+    // setup terminal
+    enable_raw_mode()?;
+    let mut stdout = io::stdout();
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+    let backend = CrosstermBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    // create app and run it
+    let app = App::default();
+    let res = run_app(&mut terminal, app);
+
+    // restore terminal
+    disable_raw_mode()?;
+    execute!(
+        terminal.backend_mut(),
+        LeaveAlternateScreen,
+        DisableMouseCapture
+    )?;
+    terminal.show_cursor()?;
+
+    if let Err(err) = res {
+        println!("{:?}", err)
+    }
+
+    Ok(())
+}
+
+fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<()> {
+    let mut ep_select = false;
+    loop {
+        terminal.draw(|f| ui(f, &mut app))?;
+
+        if let Event::Key(key) = event::read()? {
+            match app.input_mode {
+                InputMode::Normal => match key.code {
+                    KeyCode::Char('e') => {
+                        app.input_mode = InputMode::Editing;
+                    }
+                    KeyCode::Char('q') => {
+                        return Ok(());
+                    }
+                    KeyCode::Left => app.messages.unselect(),
+                    KeyCode::Down => app.messages.next(),
+                    KeyCode::Up => app.messages.previous(),
+                    //if KeyCode::Enter => {
+                    KeyCode::Enter => {
+                        if ep_select == false {
+                            let selected = app.messages.state.selected();
+                            app.title = app
+                                .messages
+                                .iter()
+                                .nth(selected.unwrap())
+                                .unwrap()
+                                .to_string();
+                            let ep_range = anime_ep_range(&app.title);
+                            app.messages.items.clear();
+                            for ep in 1..ep_range {
+                                app.messages.push(format!("Episode {}", ep));
+                            }
+                            ep_select = true;
+                        } else {
+                            let selected = app.messages.state.selected();
+                            let ep = app.messages.iter().nth(selected.unwrap()).unwrap();
+                            let ep = ep.replace("Episode ", "");
+                            let ep = ep.parse::<u64>().unwrap();
+                            let link = anime_link(&app.title, ep);
+                            open_video(link);
+                        }
+                    }
+                    _ => {}
+                },
+                InputMode::Editing => match key.code {
+                    KeyCode::Enter => {
+                        //push app.input into app.messages with '1
+                        let anime_list = anime_names(app.input.drain(..).collect());
+                        app.messages.items.clear();
+                        for anime in anime_list {
+                            app.messages.push(anime);
+                        }
+                    }
+                    KeyCode::Char(c) => {
+                        app.input.push(c);
+                    }
+                    KeyCode::Backspace => {
+                        app.input.pop();
+                    }
+                    KeyCode::Esc => {
+                        app.input_mode = InputMode::Normal;
+                    }
+                    _ => {}
+                },
+            }
+        }
+    }
+}
+
+fn ui<B: Backend>(f: &mut Frame<B>, app: &mut App) {
+    let chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .margin(2)
+        .constraints(
+            [
+                Constraint::Length(1),
+                Constraint::Length(3),
+                Constraint::Min(1),
+            ]
+            .as_ref(),
+        )
+        .split(f.size());
+    let block = Block::default()
+        .borders(Borders::ALL)
+        .title("kami")
+        .border_type(BorderType::Rounded);
+    f.render_widget(block, f.size());
+
+    let (msg, style) = match app.input_mode {
+        InputMode::Normal => (
+            vec![
+                Span::raw("Press "),
+                Span::styled("q", Style::default().add_modifier(Modifier::BOLD)),
+                Span::raw(" to exit, "),
+                Span::styled("e", Style::default().add_modifier(Modifier::BOLD)),
+                Span::raw(" to start editing."),
+            ],
+            Style::default().add_modifier(Modifier::RAPID_BLINK),
+        ),
+        InputMode::Editing => (
+            vec![
+                Span::raw("Press "),
+                Span::styled("Esc", Style::default().add_modifier(Modifier::BOLD)),
+                Span::raw(" to stop editing, "),
+                Span::styled("Enter", Style::default().add_modifier(Modifier::BOLD)),
+                Span::raw(" to record the message"),
+            ],
+            Style::default(),
+        ),
+    };
+    let mut text = Text::from(Spans::from(msg));
+    text.patch_style(style);
+    let help_message = Paragraph::new(text);
+    f.render_widget(help_message, chunks[0]);
+
+    let input = Paragraph::new(app.input.as_ref())
+        .style(match app.input_mode {
+            InputMode::Normal => Style::default(),
+            InputMode::Editing => Style::default().fg(Color::Yellow),
+        })
+        .block(Block::default().borders(Borders::ALL).title("Input"));
+    f.render_widget(input, chunks[1]);
+    match app.input_mode {
+        InputMode::Normal =>
+            // Hide the cursor. `Frame` does this by default, so we don't need to do anything here
+            {}
+
+        InputMode::Editing => {
+            // Make the cursor visible and ask tui-rs to put it at the specified coordinates after rendering
+            f.set_cursor(
+                // Put cursor past the end of the input text
+                chunks[1].x + app.input.width() as u16 + 1,
+                // Move one line down, from the border to the input line
+                chunks[1].y + 1,
+            )
+        }
+    }
+
+    let messages: Vec<ListItem> = app
+        .messages
+        .iter()
+        .enumerate()
+        .map(|(i, m)| {
+            let content = vec![Spans::from(Span::raw(format!("{}: {}", i, m)))];
+            ListItem::new(content)
+        })
+        .collect();
+    let messages = List::new(messages)
+        .block(Block::default().borders(Borders::ALL).title("Messages"))
+        .style(Style::default().fg(Color::White))
+        .highlight_style(
+            Style::default()
+                .bg(Color::LightGreen)
+                .add_modifier(Modifier::BOLD),
+        )
+        .highlight_symbol(">>");
+    f.render_stateful_widget(messages, chunks[2], &mut app.messages.state);
+}

src/ui/mod.rs

@@ -0,0 +1 @@
+pub mod anime_ui;