mblue/

lib.rs

use std::{sync::{Arc}, fs::{self}, rc::Rc, collections::{HashMap}, println};
use actix_files as afs;
use futures_util::{FutureExt};
use types::{AppSettings};
use uuid::Uuid;

use actix_web::{App, HttpServer, web::{self}, HttpResponse, HttpRequest};

use tera::{Tera, Context};

use crate::{types::AppState, components::load_component_custom_function};

use self::broadcast::Broadcaster;

pub mod types;
pub mod broadcast;
mod components;
mod routes;


pub async fn configure(settings: AppSettings) -> std::io::Result<()>{
    let broadcaster = Broadcaster::create();
    // Create the Actix HTTP server
    HttpServer::new(move || {
        let mut tera = Tera::default();
        //Loading layout
        let layout_content = fs::read_to_string(&settings.master_layout).expect("Error loading layout");
        tera.add_raw_template("layout", &layout_content).expect("Error adding template");
        println!("----------------------------------------------------");
        println!("Starting route listening for {:?}",std::thread::current().id());
        let mut app = App::new();
        app = app.service(routes::state_changed_action);        
        app = app.service(routes::state_changed);        
        app = app.service(routes::component_changed);
        app = app.service(routes::components);
        app = app.service(afs::Files::new(&settings.static_folder, &settings.static_folder).show_files_listing());

        let dynamic_pages = settings.pages.clone();     
        let components = settings.components.clone();

        for (key,comp) in &components {
            let template = comp.template.clone();
            let template_clone = &template;
            tera.add_raw_template(key, template_clone.clone().unwrap().as_str()).expect("Error adding template");
        }

        //Makes sure tera is filled with all templates
        for (key,component) in &components {            
            let component_name = key.clone().to_string();
            let comp = component.clone();
            let custom_function = load_component_custom_function(
                tera.clone()
                ,component_name.clone()
                ,comp.load.clone().unwrap()
            );

            tera.register_function(
                &key,
                custom_function
            );
        }


        app = app.app_data(web::Data::new(AppState {
            broadcaster: Arc::clone(&broadcaster),
            components: components.clone(),
            pages: dynamic_pages.clone(),
            tera: tera.clone()
        }));

        // Add routes to the app
        for route in dynamic_pages {
            let route_cloned = route.clone();
            let route_path = Rc::new(route_cloned.clone().path);
            
            let mut has_action = false;
            let mut has_load = false;

            if route.action.is_some(){
                has_action = true;
            }

            if route.load.is_some() {
                has_load = true;
            }

            if has_action {
                app = app.route(&route_path, web::post().to(move |req: HttpRequest,state: web::Data<AppState>, form: web::Form<HashMap<String, String>>| {
                let app_state = state.clone(); // Clone app_state inside the closure
                let mut result = "".to_string();
                async move {
                    let path = req.path().clone();
                    let mut _page = state.pages.iter().find(|p| p.path == path);
                    if _page.is_some(){
                        let mut context = Context::new();
                        let page = _page.unwrap();
                        let mut tera = app_state.tera.clone();
                        let template = page.template.clone();
                        tera.add_raw_template(&path, &template).expect("Error adding template");
        
                        //First we need to call the action, and then we populate the load
                        let page_action_function = page.action.clone().unwrap();
                        let action_context = page_action_function(
                            Arc::new(req.clone()),
                            Arc::new(context.clone()),
                            form
                        ).await;
                        let load_context =  page.load.clone().unwrap()(
                            Arc::new(req.clone()),
                            action_context
                        ).await;

                        context.extend(Arc::try_unwrap(load_context).expect("Error unwrapping context"));  

                        let body = tera.render(&path, &context).expect("Error rendering template");
                        let mut layout_context = Context::new();
                        layout_context.insert("body", &body);
                        let id = Uuid::new_v4();
                        layout_context.insert("uuid", &id.to_string());
        
                        result = tera.render("layout", &layout_context).expect("Error rendering layout template");
                    }

                    HttpResponse::Ok().body(result)                    
                }.boxed_local()                    
                }));
            }

            if has_load {
                app = app.route(&route_path, web::get().to(move |req: HttpRequest,state: web::Data<AppState>| {
                    let app_state = state.clone(); // Clone app_state inside the closure
                    let mut result = "".to_string();
                    async move {
                        let path = req.path().clone();
                        let mut _page = state.pages.iter().find(|p| p.path == path);
                        if _page.is_some(){
                            let mut context = Context::new();
                            context.insert("state","null");
                            let page = _page.unwrap();
                            let mut tera = app_state.tera.clone();
                            let template = page.template.clone();
                            tera.add_raw_template(&path, &template).expect("Error adding template");
    
                            let page_function = page.load.clone().unwrap();
                            let action_context = page_function(
                                Arc::new(req.clone()),
                                Arc::new(context.clone())
                            ).await;
    
                            context.extend(Arc::try_unwrap(action_context).expect("Error unwrapping context"));  
    
                            let body = tera.render(&path, &context).expect("Error rendering template");
                            let mut layout_context = Context::new();
                            layout_context.insert("body", &body);
                            let id = Uuid::new_v4();
                            layout_context.insert("uuid", &id.to_string());
            
                            result = tera.render("layout", &layout_context).expect("Error rendering layout template");
                        }
    
                        HttpResponse::Ok().body(result)                    
                    }.boxed_local()                    
                    }));
    
                    println!("Listening to {}",&route_path);               
                }
            }


        app
    })
    .bind(format!("{}:{}", settings.address, settings.port)).expect("Error binding server and/or port")
    .run()
    .await
    


}