mod botdriver;
mod browser;
mod chromedriver;
mod webserve;
use std::io::{self, Write};

use botdriver::BotDriver;
use browser::BrowserSession;
use chromedriver::Driver;
use serde::{Deserialize, Serialize};
use signal_hook::iterator::Signals;

const STATIC_ADDR: &str = "127.0.0.1:8010";

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    let mut cfg: FRCConfig = confy::load_path(CFG_NAME)?;
    if cfg.username == None || cfg.token == None {
        cfg = create_config()?;
        confy::store_path(CFG_NAME, cfg.clone())?;
    }
    let username = cfg.username.unwrap();
    let static_handle = webserve::start_server(STATIC_ADDR.to_string()).await?;

    println!("Starting frc with username to listen to: {}", username);

    let mut chr = Driver::new()?;

    let driver = BrowserSession::new().await?;
    let browser = driver.handle();

    let mut bot = BotDriver::new(cfg.token.unwrap(), username);
    browser.start(STATIC_ADDR).await?;
    println!("################");
    println!("# starting frc #");
    println!("################");
    tokio::spawn(async move {
        let mut signals =
            Signals::new(&[signal_hook::consts::SIGINT, signal_hook::consts::SIGTERM])
                .expect("could not init listen signals");

        for _ in signals.forever() {
            println!();
            println!("closing down");
            static_handle.abort();
            driver.stop().await.expect("failed killing browser");
            chr.exit().expect("failed killing chromedriver");
            break;
        }

        std::process::exit(0);
    });
    bot.listen_and_paste(browser).await.unwrap();
    Ok(())
}

const CFG_NAME: &str = "frc.toml";

#[derive(Serialize, Deserialize, Clone, Debug)]
struct FRCConfig {
    username: Option<String>,
    token: Option<String>,
}

impl ::std::default::Default for FRCConfig {
    fn default() -> Self {
        Self {
            username: None,
            token: None,
        }
    }
}

fn create_config() -> Result<FRCConfig, anyhow::Error> {
    let username = get_config_from_user("Enter username to listen to:")?;
    let token = get_config_from_user("Enter telegram bot token:")?;
    Ok(FRCConfig {
        username: Some(username),
        token: Some(token),
    })
}

fn get_config_from_user(prompt: &str) -> Result<String, anyhow::Error> {
    print!("{} ", prompt);
    io::stdout().flush()?;
    let mut value = String::new();
    io::stdin().read_line(&mut value)?;
    Ok(value.trim().to_string())
}