#[macro_use]
extern crate actix_web;
#[macro_use]
extern crate log;
#[macro_use]
extern crate thiserror;

use std::collections::HashMap;
use std::ops::Deref;

use actix_session::CookieSession;
use actix_web::{web, App, HttpResponse, HttpServer};
use actix_web_static_files;
use actix_web_static_files::ResourceFiles as StaticFiles;
use log::LevelFilter;
use once_cell::sync::Lazy;
use rand::Rng;
use tera::Tera;

use yopa::insert::{InsertObj, InsertRel, InsertValue};
use yopa::{Storage, TypedValue};

use crate::tera_ext::TeraExt;

mod routes;
mod session_ext;
mod tera_ext;
mod utils;

// Embed static files
include!(concat!(env!("OUT_DIR"), "/static_files.rs"));

// Embed templates
static TEMPLATES: include_dir::Dir = include_dir::include_dir!("./resources/templates");

pub(crate) static TERA: Lazy<Tera> = Lazy::new(|| {
    let mut tera = Tera::default();
    tera.add_include_dir_templates(&TEMPLATES).unwrap();

    // Special filter for the TypedValue map
    use serde_json::Value;
    tera.register_filter(
        "print_typed_value",
        |v: &Value, _: &HashMap<String, Value>| -> tera::Result<Value> {
            if v.is_null() {
                return Ok(v.clone());
            }
            if let Value::Object(map) = v {
                if let Some((_, v)) = map.iter().next() {
                    return Ok(v.clone());
                }
            }
            Err(tera::Error::msg("Expected nonenmpty object"))
        },
    );

    // opt(checked=foo.is_checked)
    tera.register_function(
        "opt",
        |args: &HashMap<String, Value>| -> tera::Result<Value> {
            if args.len() != 1 {
                return Err("Expected 1 argument".into());
            }
            match args.iter().nth(0) {
                Some((name, &Value::Bool(true))) => Ok(Value::String(name.clone())),
                Some((_, &Value::Bool(false))) => Ok(Value::Null),
                _ => Err("Expected bool argument".into()),
            }
        },
    );

    // selected(val=foo.color,opt="Red")
    tera.register_function(
        "selected",
        |args: &HashMap<String, Value>| -> tera::Result<Value> {
            match (args.get("val"), args.get("opt")) {
                (Some(v), Some(w)) => {
                    if v == w {
                        Ok(Value::String("selected".into()))
                    } else {
                        Ok(Value::Null)
                    }
                }
                _ => Err("Expected val and opt args".into()),
            }
        },
    );

    // TODO need to inject HttpRequest::url_for() into tera context, but it then can't be accessed by the functions.
    // tera.register_function("url_for", |args: HashMap<String, Value>| -> tera::Result<Value> {
    //     match args.get("name") {
    //         Some(Value::String(s)) => {
    //             let r =
    //         },
    //         _ => Err("Expected string argument".into()),
    //     }
    // });

    tera
});

type YopaStoreWrapper = web::Data<tokio::sync::RwLock<yopa::Storage>>;

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    simple_logging::log_to_stderr(LevelFilter::Debug);

    // Ensure the lazy ref is initialized early (to catch template bugs ASAP)
    let _ = TERA.deref();

    let yopa_store: YopaStoreWrapper = init_yopa()
        .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;

    let mut session_key = [0u8; 32];
    rand::thread_rng().fill(&mut session_key);

    debug!("Session key: {:?}", session_key);

    HttpServer::new(move || {
        let static_files =
            StaticFiles::new("/static", included_static_files()).do_not_resolve_defaults();

        App::new()
            /* Middlewares */
            .wrap(CookieSession::signed(&session_key).secure(false))
            /* Bind shared objects */
            .app_data(yopa_store.clone())
            /* Routes */
            .service(routes::index)
            .service(routes::takeout)
            //
            .service(routes::models::list)
            //
            .service(routes::models::object::create_form)
            .service(routes::models::object::create)
            .service(routes::models::object::update_form)
            .service(routes::models::object::update)
            .service(routes::models::object::delete)
            //
            .service(routes::models::relation::create_form)
            .service(routes::models::relation::create)
            .service(routes::models::relation::update_form)
            .service(routes::models::relation::update)
            .service(routes::models::relation::delete)
            //
            .service(routes::models::property::create_form)
            .service(routes::models::property::create)
            .service(routes::models::property::update_form)
            .service(routes::models::property::update)
            .service(routes::models::property::delete)
            //
            .service(routes::objects::list)
            .service(routes::objects::create_form)
            .service(routes::objects::create)
            .service(routes::objects::detail)
            .service(routes::objects::update_form)
            .service(routes::objects::update)
            .service(routes::objects::delete)
            //
            .service(static_files)
            .default_service(web::to(|| {
                HttpResponse::NotFound().body("File or endpoint not found")
            }))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

fn init_yopa() -> anyhow::Result<YopaStoreWrapper> {
    let mut store = Storage::new_bincode(std::env::current_dir()?.join("yopa-store.dat"));
    store.load()?;

    Ok(web::Data::new(tokio::sync::RwLock::new(store)))
}