use crate::config::SETTINGS;
use crate::core::{all, server};
use crate::core::theme::{Markup, html};
use crate::core::response::page::{Page, PageAssets, PageComponent};
use crate::base::component::Chunck;

/// Los temas deben implementar este "trait".
pub trait Theme: Send + Sync {
    fn name(&self) -> &'static str;

    fn fullname(&self) -> String;

    fn description(&self) -> String {
        "".to_string()
    }

    #[allow(unused_variables)]
    fn configure_theme(&self, cfg: &mut server::web::ServiceConfig) {
    }

    #[allow(unused_variables)]
    fn before_render_page(&self, page: &mut Page) {
    }

    fn render_page_head(&self, page: &mut Page) -> Markup {
        let title = page.title();
        let title = if title.is_empty() {
            SETTINGS.app.name.to_string()
        } else {
            [SETTINGS.app.name.to_string(), title.to_string()].join(" | ")
        };
        let description = page.description();
        let viewport = "width=device-width, initial-scale=1, shrink-to-fit=no";
        html! {
            head {
                meta charset="utf-8";

                title { (title) }

                @if !description.is_empty() {
                    meta name="description" content=(description);
                }

                meta http-equiv="X-UA-Compatible" content="IE=edge";
                meta name="viewport" content=(viewport);

                (page.assets().render())
            }
        }
    }

    fn render_page_body(&self, page: &mut Page) -> Markup {
        html! {
            body class=(page.body_classes()) {
                @match page.template() {
                    "admin" => {
                        @for region in &["top-menu", "side-menu", "content"] {
                            #(region) {
                                (page.render_region(region))
                            }
                        }
                    },
                    _ => {
                        #content {
                            (page.render_region("content"))
                        }
                    }
                }
            }
        }
    }

    #[allow(unused_variables)]
    fn render_component(
        &self,
        component: &dyn PageComponent,
        assets: &mut PageAssets
    ) -> Option<Markup> {
        None
    /*
        Cómo usarlo:

        match component.name() {
            "block" => {
                let block = component.downcast_mut::<Block>().unwrap();
                match block.template() {
                    "default" => Some(block_default(block)),
                    _ => None
                }
            },
            _ => None
        }
    */
    }

    fn render_error_page(&self, s: server::http::StatusCode) -> server::Result<Markup> {
        Page::prepare()
            .with_title(format!("Error {}", s.as_str()).as_str())
            .add_to("content", Chunck::markup(html! {
                div {
                    h1 { (s) }
                }
            }))
            .render()
    }
}

pub fn register_theme(t: &'static (dyn Theme + 'static)) {
    all::THEMES.write().unwrap().push(t);
}

pub fn find_theme(name: &str) -> Option<&'static (dyn Theme + 'static)> {
    let themes = all::THEMES.write().unwrap();
    match themes.iter().find(|t| t.name() == name) {
        Some(theme) => Some(*theme),
        _ => None,
    }
}