use axum::prelude::*;
use std::net::SocketAddr;

use diesel::{
    prelude::*,
    r2d2::{ConnectionManager, Pool},
};
use dotenv::dotenv;
use std::env;
use std::str::FromStr;

#[macro_use]
extern crate diesel;
extern crate redis;

mod endpoints;
pub mod helpers;
pub mod logging;
pub mod migration;
pub mod models;
pub mod schema;
pub mod tests;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let _ = setup_logger();

    let db_url = env::var("DATABASE_URL").expect("DATABASE_URL is not set");

    migration::run_migrations(&db_url);
    let manager = ConnectionManager::<PgConnection>::new(&db_url);
    let pool = Pool::builder()
        .build(manager)
        .expect("Could not build connection pool");

    let root = route("/api", endpoints::get_routes(pool));

    let port = env::var("PORT").unwrap_or(String::from("8000"));
    let addr = SocketAddr::from(([127, 0, 0, 1], port.parse().unwrap_or(8000)));

    log::info!("started listening on {:?}", addr);
    hyper::Server::bind(&addr)
        .serve(root.into_make_service())
        .await
        .unwrap();
}

fn setup_logger() -> Result<(), fern::InitError> {
    let log_level = env::var("LOG_LEVEL").unwrap_or(String::from("INFO"));
    fern::Dispatch::new()
        .format(|out, message, record| {
            out.finish(format_args!(
                "{} <{}> [{}] {}",
                chrono::Local::now().format("%Y-%m-%d %H:%M:%S"),
                record.file().unwrap_or(record.target()),
                record.level(),
                message
            ))
        })
        .level(log::LevelFilter::from_str(log_level.as_str()).unwrap_or(log::LevelFilter::Info))
        .chain(std::io::stdout())
        .chain(fern::log_file("latest.log")?)
        .apply()?;
    Ok(())
}