#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args = std::env::args().collect();
    if catapult::version::contains_version(&args) {
        catapult::version::print_version();
        std::process::exit(-1);
    }

    let app = match catapult::app::load_app().await {
        Ok(app) => app,
        Err(err) => {
            eprintln!("Error: {err:?}");
            std::process::exit(-1);
        }
    };

    println!("App: {app:?}");

    let auth = catapult::service::auth::Auth { app: app.clone() };
    let token = match auth.get_token().await {
        Ok(token) => token,
        Err(err) => {
            eprintln!("Error getting token");
            eprintln!("Error: {err:?}");
            std::process::exit(-1);
        }
    };

    println!("Access token: {}", token.access_token);

    let mut svc = catapult::service::core::Service {
        app: app.clone(),
        token: token,
    };

    loop {
        // TODO: Need to update textsender_models. The token module needs updating.
        // The LoginResult needs expires_in populated
        if catapult::service::auth::has_token_expired(&svc.token).await {
            match auth.get_refresh_token(&svc.token).await {
                Ok(refresh) => {
                    println!("Refresh token: {refresh:?}");
                    svc.token = refresh;
                }
                Err(err) => {
                    eprintln!("Error: {err:?}");
                    std::process::exit(-1);
                }
            }
        }

        svc.do_the_work().await;

        tokio::time::sleep(tokio::time::Duration::from_secs(
            catapult::app::SECONDS_TO_SLEEP,
        ))
        .await;
    }
}