#[macro_use]
extern crate rocket;

use poise::serenity_prelude::Http;
use rocket::{fs::{relative, FileServer}, Rocket, Ignite};
use rocket_dyn_templates::{tera, Template};
use sass_rocket_fairing::SassFairing;
use std::{collections::HashMap, env};
use clap::{Parser, Subcommand};

mod models;
use models::{Settings, Database};

mod utils;

mod cookies;

mod routes;
use routes::*;

mod i18n;
use i18n::{i18n_filter, load_catalogs};

use crate::{i18n::langs_filter, utils::furigana_filter};

mod prelude;

#[derive(Parser)]
#[command(author, version, about, long_about = None)]
#[command(propagate_version = true)]
struct Args {
    #[command(subcommand)]
    cmd: Option<Command>,
}

#[derive(Subcommand)]
enum Command {
    LoadLegacy,
}

#[tokio::main]
async fn main() {
    dotenv::dotenv().expect("Failed to load .env file");

    let args = Args::parse();

    match &args.cmd {
        Some(cmd) => match cmd {
            Command::LoadLegacy => {
                if Database::file_exists() {
                    println!("Cannot load legacy submissions to an existing database");
                    return;
                }
                let http = http();
                load_database()
                    .load_legacy(&http).await
                    .expect("Failed to load legacy submissions");
            },
        },
        None => {
            rocket().await.expect("Failed to launch rocket");
        },
    }
}

fn load_database() -> Database {
    Database::new(false).expect("Failed to load database")
}

fn http() -> Http {
    let token = env::var("DISCORD_TOKEN").expect("Expected a token in the environment");
    Http::new(&token)
}

async fn rocket() -> Result<Rocket<Ignite>, rocket::Error> {
    let http = http();

    let config = rocket::Config::figment().merge(("port", 1313)).merge((
        "secret_key",
        env::var("SECRET")
            .expect("Must have SECRET defined in .env for private cookie persistence"),
    ));

    rocket::custom(config)
        .manage(Settings::new(&http).await.unwrap())
        .manage(http)
        .manage(load_database())
        .mount(
            "/",
            routes![get_challenge, get_guilds, get_user, login, post_login, success, logout, testing],
        )
        .mount("/css", FileServer::from(relative!("styles/css")))
        .mount("/", FileServer::from(relative!("assets")).rank(2))
        .mount("/", FileServer::from(relative!("static")).rank(1))
        .attach(Template::custom(move |engines| {
            use tera::Value;
            let (catalogs, langs) = load_catalogs().unwrap();
            engines.tera.register_filter(
                "i18n",
                move |value: &Value, args: &HashMap<String, Value>| {
                    i18n_filter(value, args, &catalogs)
                },
            );
            engines.tera.register_filter(
                "langs",
                move |value: &Value, args: &HashMap<String, Value>| {
                    langs_filter(value, args, &langs)
                },
            );
            engines.tera.register_filter(
                "furigana",
                move |value: &Value, args: &HashMap<String, Value>| {
                    furigana_filter(value, args)
                },
            )
        }))
        .attach(SassFairing::default())
        .ignite().await
        .unwrap()
        .launch().await
}