SeaBattle/rust/cli_player/src/main.rs

use std::error::Error;
use std::fmt::Debug;
use std::io;
use std::io::ErrorKind;

use cli_player::cli_args::{cli_args, TestDevScreen};
use crossterm::event::DisableMouseCapture;
use crossterm::event::EnableMouseCapture;
use crossterm::execute;
use crossterm::terminal::EnterAlternateScreen;
use crossterm::terminal::LeaveAlternateScreen;
use crossterm::terminal::{disable_raw_mode, enable_raw_mode};
use env_logger::Env;
use tui::backend::{Backend, CrosstermBackend};
use tui::Terminal;

use cli_player::server::start_server_if_missing;
use cli_player::ui_screens::popup_screen::PopupScreen;
use cli_player::ui_screens::*;
use sea_battle_backend::data::GameRules;

async fn run_dev<B: Backend>(
    terminal: &mut Terminal<B>,
    d: TestDevScreen,
) -> Result<(), Box<dyn Error>> {
    let res = match d {
        TestDevScreen::Popup => PopupScreen::new("Welcome there!!")
            .show(terminal)?
            .as_string(),
        TestDevScreen::Input => input_screen::InputScreen::new("Whas it your name ?")
            .set_title("A custom title")
            .show(terminal)?
            .as_string(),
    };

    // Temporary code
    // let res = configure_game_rules::configure_play_rules(GameRules::default(), terminal)?; // select_bot_type::select_bot_type(terminal)?;
    /*let mut rules = GameRules::default();
    rules.boats_can_touch = true;
    let res = set_boats_layout::set_boat_layout(&rules, terminal)?; // select_bot_type::select_bot_type(terminal)?;*/
    // let res = confirm_dialog::confirm_dialog("Do you really want to interrupt game ?", terminal)?; // select_bot_type::select_bot_type(terminal)?;
    // select_bot_type::select_bot_type(terminal)?;
    Err(io::Error::new(
        ErrorKind::Other,
        format!("DEV result: {:?}", res),
    ))?
}

async fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> Result<(), Box<dyn Error>> {
    if let Some(d) = cli_args().dev_screen {
        run_dev(terminal, d).await
    } else {
        // TODO : run app
        Ok(())
    }
}

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn Error>> {
    env_logger::Builder::from_env(Env::default()).init();

    start_server_if_missing().await;

    // 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 res = run_app(&mut terminal).await;

    // restore terminal
    disable_raw_mode()?;
    execute!(
        terminal.backend_mut(),
        LeaveAlternateScreen,
        DisableMouseCapture
    )?;
    terminal.show_cursor()?;

    if let Err(err) = res {
        println!("{:?}", err)
    }

    Ok(())
}