use axum::extract::State;
use axum::response::IntoResponse;
use axum::routing::get;
use axum::{http::StatusCode, response::Html, serve, Router};
use minijinja::{context, Environment};
use notify::{Config, RecommendedWatcher, RecursiveMode, Watcher};
use std::process::Stdio;
use std::sync::Arc;
use std::{path::PathBuf, str::FromStr, sync::OnceLock};
use tokio::io::{AsyncBufReadExt, BufReader};
use tokio::sync::mpsc::channel;
use tokio::sync::Mutex;
use tower_http::services::ServeDir;
use tower_livereload::{LiveReloadLayer, Reloader};
pub use tracing::{debug, error, event, info, span, warn, Level};

#[derive(Debug)]
struct Berr(Box<dyn std::error::Error>);
type Besult<T> = std::result::Result<T, Berr>;

mod observe {
    pub fn setup_logging() {
        color_eyre::install().expect("Failed to install color_eyre");

        let filter = tracing_subscriber::EnvFilter::builder()
            .with_default_directive(<tracing_subscriber::filter::Directive>::from(
                tracing::level_filters::LevelFilter::TRACE,
            ))
            .parse_lossy("info,lyrs=trace");

        tracing_subscriber::fmt().with_env_filter(filter).init();
    }
}

fn static_file_dir() -> &'static PathBuf {
    static STATIC_FILE_DIR: OnceLock<PathBuf> = OnceLock::new();
    STATIC_FILE_DIR.get_or_init(|| PathBuf::from_str("static").unwrap())
}

#[derive(Clone)]
struct AppState {
    templates: Arc<Mutex<Environment<'static>>>,
}

#[tokio::main]
async fn main() -> Besult<()> {
    // load configuration?
    observe::setup_logging();

    // TODO: only start tailwind if in dev mode?
    tokio::spawn(async move {
        info!("Starting tailwind...");
        match tokio::process::Command::new("tailwindcss")
            .args(["-i", "src/style.css", "-o", "static/style.css", "--watch"])
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .spawn()
        {
            Ok(mut tw) => {
                info!("Tailwind spawned!");
                let mut stdout_reader = BufReader::new(tw.stdout.take().unwrap()).lines();
                tokio::spawn(async move {
                    while let Ok(Some(l)) = stdout_reader.next_line().await {
                        if l.trim().len() > 0 {
                            event!(target: "tailwind::stdout", Level::INFO, "{l}");
                        }
                    }
                });
                let mut stderr_reader = BufReader::new(tw.stderr.take().unwrap()).lines();
                tokio::spawn(async move {
                    while let Ok(Some(l)) = stderr_reader.next_line().await {
                        if l.trim().len() > 0 {
                            event!(target: "tailwind::stderr", Level::INFO, "{l}");
                        }
                    }
                });
            }
            Err(e) => error!("Failed to spawn Tailwind: {e}"),
        }
    });

    let templates = Arc::new(Mutex::new(Environment::new()));
    while let Some(d) = tokio::fs::read_dir("templates").await?.next_entry().await? {
        templates.clone().lock().await.add_template_owned(
            d.file_name().into_string().unwrap(),
            std::fs::read_to_string(d.path())?,
        )?;
    }

    // pulling the watcher into main's scope lets it live until the program dies
    let (rl_layer, _watcher) = live_reload_layer()?;

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    info!("Listening on {listener:#?}");
    let router = Router::new()
        .route("/", get(index))
        .nest_service("/static", ServeDir::new(static_file_dir()))
        .layer(rl_layer)
        .with_state(AppState { templates });

    Ok(serve(listener, router).await?)
}

async fn index(State(state): State<AppState>) -> Besult<Html<String>> {
    Ok(Html(
        state
            .templates
            .lock()
            .await
            .get_template("page.html")?
            .render(context!())?,
    ))
}

fn live_reload_layer() -> Besult<(LiveReloadLayer, RecommendedWatcher)> {
    let rl_layer = LiveReloadLayer::new();
    let rl = rl_layer.reloader();
    let watcher = static_file_watcher(rl)?;
    Ok((rl_layer, watcher))
}

fn static_file_watcher(
    reloader: Reloader,
) -> Result<RecommendedWatcher, Box<dyn std::error::Error>> {
    info!("Creating async watcher...");

    let (tx, mut rx) = channel(1);

    info!("Creating watcher...");
    // watcher needs to move out of scope to live long enough to watch
    let mut watcher = RecommendedWatcher::new(
        move |res| {
            info!("Res from watcher: {res:#?}");
            futures::executor::block_on(async {
                tx.send(res).await.unwrap();
            })
        },
        Config::default(),
    )?;
    info!("Created watcher");

    watcher.watch(static_file_dir(), RecursiveMode::Recursive)?;

    tokio::spawn(async move {
        info!("Recieving...");
        while let Some(res) = rx.recv().await {
            info!("Recieved! {res:#?}");
            match res {
                Ok(event) => {
                    info!("fs event: {event:#?}");
                    reloader.reload()
                }
                Err(e) => println!("watch error: {:?}", e),
            }
        }
    });

    Ok(watcher)
}

impl IntoResponse for Berr {
    fn into_response(self) -> axum::http::Response<axum::body::Body> {
        error!("webserver error: {:?}", self.0);
        (
            StatusCode::INTERNAL_SERVER_ERROR,
            format!("internal server error: {}", self.0),
        )
            .into_response()
    }
}

// This enables using `?` on functions that return `Result<_, anyhow::Error>`
// to turn them into `Result<_, AppError>`. That way you don't need to do that
// manually.
impl<E> From<E> for Berr
where
    E: Into<Box<dyn std::error::Error>>,
{
    fn from(err: E) -> Self {
        Self(err.into())
    }
}