use axum::{
    extract::{Path, State},
    http::{header, StatusCode},
    response::{Html, IntoResponse},
    routing::get,
    Router,
};
use clap::Parser;
use markdown::ParseOptions;
use std::{collections::HashMap, path::PathBuf, sync::Arc};
use syntect::{
    highlighting::{Theme, ThemeSet},
    html::highlighted_html_for_string,
    parsing::{SyntaxSet, SyntaxSetBuilder},
};
use two_face::theme::EmbeddedLazyThemeSet;

// #[derive(Debug)]
struct BlogState {
    templates: HashMap<String, Cached<Template>>,
    posts: HashMap<String, Cached<Post>>,

    ps: SyntaxSet,
    ts: EmbeddedLazyThemeSet,

    config: Config,
}
type AppState = State<Arc<BlogState>>;

#[derive(Debug)]
struct Cached<S> {
    data: S,
    path: PathBuf,
    // TODO
    // last_read: NaiveDateTime,
}

impl<S: From<String>> Cached<S> {
    fn data(&self) -> std::io::Result<S> {
        let contents = std::fs::read_to_string(&self.path)?;
        Ok(S::from(contents))

        // TODO
        //if self.last_read + Duration::minutes(30) > now {
        //    let contents = std::fs::read_to_string(&self.path)?;
        //
        //    self.last_read = now;
        //    self.data = S::from(contents);
        //
        //    Ok(&self.data)
        //} else {
        //    Ok(&self.data)
        //}
    }

    fn from_file_path(path: PathBuf) -> std::io::Result<Self> {
        let contents = std::fs::read_to_string(&path)?;

        Ok(Self {
            data: S::from(contents),
            path,
            // last_read: Utc::now().naive_utc(),
        })
    }
}

#[derive(Debug)]
struct Template {
    index: usize,
    content: String,
}

impl From<String> for Template {
    fn from(value: String) -> Self {
        let index = value.find("%%%").unwrap_or_default();

        Self {
            index,
            content: value,
        }
    }
}

#[derive(Debug)]
struct Post {
    content: String,
    embed_template_name: Option<String>,
}

trait ToHtml {
    fn is_directive(&self) -> bool;
    fn to_html(&self, ps: &SyntaxSet, theme: &Theme) -> String;
    fn template(&self) -> Option<String>;
}

impl ToHtml for markdown::mdast::Node {
    fn to_html(&self, ps: &SyntaxSet, theme: &Theme) -> String {
        let mut s = String::new();

        if self.is_directive() {
            return s;
        }

        match self {
            markdown::mdast::Node::Root(root) => {
                for child in &root.children {
                    s += &child.to_html(ps, theme);
                }
            }
            markdown::mdast::Node::Blockquote(block_quote) => {
                s += "<blockquote>";
                for child in &block_quote.children {
                    s += &child.to_html(ps, theme);
                }
                s += "</blockquote>";
            }
            markdown::mdast::Node::FootnoteDefinition(_) => {}
            markdown::mdast::Node::MdxJsxFlowElement(_) => {}
            markdown::mdast::Node::List(list) => {
                s += "<ul>";
                for child in &list.children {
                    s += &child.to_html(ps, theme);
                }
                s += "</ul>";
            }
            markdown::mdast::Node::MdxjsEsm(_) => {}
            markdown::mdast::Node::Toml(_) => {}
            markdown::mdast::Node::Yaml(_) => {}
            markdown::mdast::Node::Break(_) => {}
            markdown::mdast::Node::InlineCode(inline_code) => {
                s += &format!(
                    "<code>{}</code>",
                    &ansi_to_html::convert(&inline_code.value).unwrap()
                );
            }
            markdown::mdast::Node::InlineMath(_) => {}
            markdown::mdast::Node::Delete(_) => {}
            markdown::mdast::Node::Emphasis(emphasis) => {
                s += "<em>";
                for child in &emphasis.children {
                    s += &child.to_html(ps, theme);
                }
                s += "</em>";
            }
            markdown::mdast::Node::MdxTextExpression(_) => {}
            markdown::mdast::Node::FootnoteReference(_) => {}
            markdown::mdast::Node::Html(_) => {}
            markdown::mdast::Node::Image(image) => {
                if image.url.ends_with(".mp4") {
                    s += &format!("<video controls src={}>", image.url);
                } else {
                    s += &format!("<img src={}>", image.url);
                }
            }
            markdown::mdast::Node::ImageReference(_) => {}
            markdown::mdast::Node::MdxJsxTextElement(_) => {}
            markdown::mdast::Node::Link(link) => {
                s += &format!("<a href={}>", link.url);
                for child in &link.children {
                    s += &child.to_html(ps, theme);
                }
                s += "</a>";
            }
            markdown::mdast::Node::LinkReference(_) => {}
            markdown::mdast::Node::Strong(strong) => {
                s += "<b>";
                for child in &strong.children {
                    s += &child.to_html(ps, theme);
                }
                s += "</b>";
            }
            markdown::mdast::Node::Text(text) => s += &ansi_to_html::convert(&text.value).unwrap(),
            markdown::mdast::Node::Code(code) => {
                if let Some(syntax) = code
                    .lang
                    .as_ref()
                    .and_then(|lang| ps.find_syntax_by_extension(&lang))
                {
                    println!("{:?}", code.lang);
                    let escaped = highlighted_html_for_string(&code.value, &ps, syntax, theme)
                        .expect("generate html");

                    s += &escaped;
                } else {
                    s += "<pre><code>";
                    s += &ansi_to_html::convert(&code.value).unwrap();
                    s += "</code></pre>";
                }
            }
            markdown::mdast::Node::Math(_) => {}
            markdown::mdast::Node::MdxFlowExpression(_) => {}
            markdown::mdast::Node::Heading(heading) => {
                s += &format!("<h{}>", heading.depth);
                for child in &heading.children {
                    s += &child.to_html(ps, theme);
                }
                s += &format!("</h{}>", heading.depth);
            }
            markdown::mdast::Node::Table(_) => {}
            markdown::mdast::Node::ThematicBreak(_) => {
                s += "<hr>";
            }
            markdown::mdast::Node::TableRow(_) => {}
            markdown::mdast::Node::TableCell(_) => {}
            markdown::mdast::Node::ListItem(item) => {
                s += "<li>";
                for child in &item.children {
                    s += &child.to_html(ps, theme);
                }
                s += "</li>";
            }
            markdown::mdast::Node::Definition(_) => {}
            markdown::mdast::Node::Paragraph(paragraph) => {
                s += "<p>";
                for child in &paragraph.children {
                    s += &child.to_html(ps, theme);
                }
                s += "</p>";
            }
        }

        s
    }

    fn is_directive(&self) -> bool {
        self.children()
            .and_then(|children| children.first())
            .map(|first| match first {
                markdown::mdast::Node::Text(text) => {
                    if text.value.starts_with("%{") && text.value.ends_with("}") {
                        text.value.chars().filter(|x| *x == '}').count() == 1
                    } else {
                        false
                    }
                }
                _ => false,
            })
            .is_some_and(|x| x)
    }

    fn template(&self) -> Option<String> {
        self.children()
            .and_then(|children| children.first())
            .and_then(|first| match first {
                markdown::mdast::Node::Paragraph(_) => first.template(),
                markdown::mdast::Node::Text(text) => {
                    if text.value.starts_with("%{") {
                        text.value[2..].split('}').next().map(String::from)
                    } else {
                        None
                    }
                }
                _ => None,
            })
    }
}

impl Post {
    fn to_html(
        &self,
        templates: &HashMap<String, Cached<Template>>,
        ps: &SyntaxSet,
        ts: &Theme,
    ) -> String {
        let mut s = String::with_capacity(self.content.len());

        let ast = markdown::to_mdast(&self.content, &ParseOptions::default()).unwrap();
        let template_name = ast.template();

        if let Some(template) = template_name.and_then(|name| templates.get(&name)) {
            if template.data.index > 0 {
                s += &template.data.content[0..template.data.index];
            }

            s += &ast.to_html(ps, ts);

            if template.data.index > 0 {
                s += &template.data.content[template.data.index + 3..]
            }
        } else {
            s += &ast.to_html(ps, ts);
        }

        s
    }
}

impl From<String> for Post {
    fn from(value: String) -> Self {
        let template_name = if value.starts_with("%{") {
            // value[2..].split('}').next().map(Into::into)
            None
        } else {
            None
        };

        Self {
            content: if template_name.is_some() {
                value.lines().skip(1).collect::<Vec<_>>().join("\n")
            } else {
                value
            },
            embed_template_name: template_name,
        }
    }
}

#[derive(clap::Parser, Debug)]
struct Config {
    #[clap(env, short, long)]
    port: u16,
    #[clap(env, short, long)]
    blog_dir: String,
}

#[tokio::main]
async fn main() {
    let config = Config::parse();

    let mut builder = two_face::syntax::extra_newlines().into_builder();
    builder
        .add_from_folder(format!("{}/syntaxes", &config.blog_dir), true)
        .expect("load syntaxes");
    let ps = builder.build();

    let mut blog_state = BlogState {
        templates: HashMap::new(),
        posts: HashMap::new(),
        ps,
        ts: two_face::theme::extra(),
        config,
    };

    for dir in std::fs::read_dir(&blog_state.config.blog_dir)
        .unwrap()
        .flatten()
    {
        if dir.file_type().unwrap().is_file() {
            let file_name = dir.file_name().into_string().unwrap();
            let Some((file_name, extension)) = file_name.split_once('.') else {
                continue;
            };

            match extension {
                "html.template" => {
                    blog_state.templates.insert(
                        file_name.to_string(),
                        Cached::from_file_path(dir.path()).unwrap(),
                    );
                }
                "md" => {
                    blog_state.posts.insert(
                        file_name.to_string(),
                        Cached::from_file_path(dir.path()).unwrap(),
                    );
                }
                _ => {}
            }
        }
    }

    let port = blog_state.config.port;
    let app = Router::new()
        .route("/", get(home_page))
        .route("/:post", get(blog_post))
        .route("/images/:image", get(image))
        .with_state(Arc::new(blog_state));
    let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{}", port))
        .await
        .unwrap();

    axum::serve(listener, app).await.unwrap();
}

async fn home_page(State(state): AppState) -> Result<Html<String>, Html<String>> {
    match state.posts.get("home") {
        Some(post) => match post.data() {
            Ok(content) => Ok(Html(
                content.to_html(
                    &state.templates,
                    &state.ps,
                    state
                        .ts
                        .get(two_face::theme::EmbeddedThemeName::GruvboxDark),
                ),
            )),
            Err(e) => Err(Html(e.to_string())),
        },
        None => Err(Html("<h1>404 - Not Found</h1>".to_string())),
    }
}

async fn blog_post(
    State(state): AppState,
    Path(post): Path<String>,
) -> Result<Html<String>, Html<String>> {
    match state.posts.get(&post) {
        Some(post) => match post.data() {
            Ok(content) => Ok(Html(
                content.to_html(
                    &state.templates,
                    &state.ps,
                    state
                        .ts
                        .get(two_face::theme::EmbeddedThemeName::GruvboxDark),
                ),
            )),
            Err(e) => Err(Html(e.to_string())),
        },
        None => Err(not_found_page(state)),
    }
}

async fn image(State(state): AppState, Path(image_path): Path<String>) -> impl IntoResponse {
    match std::fs::read(format!("{}/images/{image_path}", state.config.blog_dir)) {
        Ok(contents) => Ok(([(header::CONTENT_TYPE, "image/png;video/mp4")], contents)),
        Err(e) => {
            eprintln!("{e:#?}");
            Err(StatusCode::NOT_FOUND)
        }
    }
}

fn not_found_page(state: Arc<BlogState>) -> Html<String> {
    match state.posts.get("404") {
        Some(post) => match post.data() {
            Ok(content) => Html(
                content.to_html(
                    &state.templates,
                    &state.ps,
                    state
                        .ts
                        .get(two_face::theme::EmbeddedThemeName::GruvboxDark),
                ),
            ),
            Err(e) => Html(e.to_string()),
        },
        None => Html("<h1>404 - Not Found</h1>".to_string()),
    }
}