use crate::config::{Route as ConfigRoute, RouteType};
use crate::{template_args, BunBunError, Route, State};
use arc_swap::ArcSwap;
use axum::body::{boxed, Bytes, Empty, Full};
use axum::extract::Query;
use axum::http::{header, StatusCode};
use axum::response::{Html, IntoResponse, Response};
use axum::Extension;
use handlebars::Handlebars;
use percent_encoding::{utf8_percent_encode, AsciiSet, CONTROLS};
use serde::Deserialize;
use std::borrow::Cow;
use std::collections::HashMap;
use std::path::Path;
use std::process::Command;
use std::sync::Arc;
use tracing::{debug, error};

// https://url.spec.whatwg.org/#fragment-percent-encode-set
const FRAGMENT_ENCODE_SET: &AsciiSet = &CONTROLS
    .add(b' ')
    .add(b'"')
    .add(b'<')
    .add(b'>')
    .add(b'`')
    .add(b'+')
    .add(b'&') // Interpreted as a GET query
    .add(b'#') // Interpreted as a hyperlink section target
    .add(b'\'');

#[allow(clippy::unused_async)]
pub async fn index(
    Extension(data): Extension<Arc<ArcSwap<State>>>,
    Extension(handlebars): Extension<Handlebars<'static>>,
) -> impl IntoResponse {
    handlebars
        .render(
            "index",
            &template_args::hostname(&data.load().public_address),
        )
        .map(Html)
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
}

#[allow(clippy::unused_async)]
pub async fn opensearch(
    Extension(data): Extension<Arc<ArcSwap<State>>>,
    Extension(handlebars): Extension<Handlebars<'static>>,
) -> impl IntoResponse {
    handlebars
        .render(
            "opensearch",
            &template_args::hostname(&data.load().public_address),
        )
        .map(|body| {
            (
                StatusCode::OK,
                [(
                    header::CONTENT_TYPE,
                    "application/opensearchdescription+xml",
                )],
                body,
            )
        })
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
}

#[allow(clippy::unused_async)]
pub async fn list(
    Extension(data): Extension<Arc<ArcSwap<State>>>,
    Extension(handlebars): Extension<Handlebars<'static>>,
) -> impl IntoResponse {
    handlebars
        .render("list", &data.load().groups)
        .map(Html)
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
}

#[derive(Deserialize, Debug)]
pub struct SearchQuery {
    to: String,
}

#[allow(clippy::unused_async)]
pub async fn hop(
    Extension(data): Extension<Arc<ArcSwap<State>>>,
    Extension(handlebars): Extension<Handlebars<'static>>,
    Query(query): Query<SearchQuery>,
) -> impl IntoResponse {
    let data = data.load();

    match resolve_hop(&query.to, &data.routes, data.default_route.as_deref()) {
        RouteResolution::Resolved { route: path, args } => {
            let resolved_template = match path {
                ConfigRoute {
                    route_type: RouteType::Internal,
                    path,
                    ..
                } => resolve_path(Path::new(path), &args),
                ConfigRoute {
                    route_type: RouteType::External,
                    path,
                    ..
                } => Ok(HopAction::Redirect(Cow::Borrowed(path))),
            };

            match resolved_template {
                Ok(HopAction::Redirect(path)) => {
                    let rendered = handlebars
                        .render_template(
                            &path,
                            &template_args::query(utf8_percent_encode(&args, FRAGMENT_ENCODE_SET)),
                        )
                        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
                    Response::builder()
                        .status(StatusCode::FOUND)
                        .header(header::LOCATION, rendered)
                        .body(boxed(Empty::new()))
                }
                Ok(HopAction::Body(body)) => Response::builder()
                    .status(StatusCode::OK)
                    .body(boxed(Full::new(Bytes::from(body)))),
                Err(e) => {
                    error!("Failed to redirect user for {path}: {e}");
                    Response::builder()
                        .status(StatusCode::INTERNAL_SERVER_ERROR)
                        .body(boxed(Full::from("Something went wrong :(\n")))
                }
            }
        }
        RouteResolution::Unresolved => Response::builder()
            .status(StatusCode::NOT_FOUND)
            .body(boxed(Full::from("not found\n"))),
    }
    .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
}

#[derive(Debug, PartialEq)]
enum RouteResolution<'a> {
    Resolved { route: &'a Route, args: String },
    Unresolved,
}

/// Attempts to resolve the provided string into its route and its arguments.
/// If a default route was provided, then this will consider that route before
/// failing to resolve a route.
///
/// The first element in the tuple describes the route, while the second element
/// returns the remaining arguments. If none remain, an empty string is given.
fn resolve_hop<'a>(
    query: &str,
    routes: &'a HashMap<String, Route>,
    default_route: Option<&str>,
) -> RouteResolution<'a> {
    let mut split_args = query.split_ascii_whitespace().peekable();
    let maybe_route = if let Some(command) = split_args.peek() {
        routes.get(*command)
    } else {
        debug!("Found empty query, returning no route.");
        return RouteResolution::Unresolved;
    };

    let args = split_args.collect::<Vec<_>>();
    let arg_count = args.len();

    // Try resolving with a matched command
    if let Some(route) = maybe_route {
        let args = if args.is_empty() { &[] } else { &args[1..] }.join(" ");
        let arg_count = arg_count - 1;
        if check_route(route, arg_count) {
            debug!("Resolved {route} with args {args}");
            return RouteResolution::Resolved { route, args };
        }
    }

    // Try resolving with the default route, if it exists
    if let Some(route) = default_route.and_then(|route| routes.get(route)) {
        if check_route(route, arg_count) {
            let args = args.join(" ");
            debug!("Using default route {route} with args {args}");
            return RouteResolution::Resolved { route, args };
        }
    }

    RouteResolution::Unresolved
}

/// Checks if the user provided string has the correct properties required by
/// the route to be successfully matched.
const fn check_route(route: &Route, arg_count: usize) -> bool {
    if let Some(min_args) = route.min_args {
        if arg_count < min_args {
            return false;
        }
    }

    if let Some(max_args) = route.max_args {
        if arg_count > max_args {
            return false;
        }
    }

    true
}

#[derive(Deserialize, Debug, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
enum HopAction<'a> {
    Redirect(Cow<'a, str>),
    Body(String),
}

/// Runs the executable with the user's input as a single argument. Returns Ok
/// so long as the executable was successfully executed. Returns an Error if the
/// file doesn't exist or bunbun did not have permission to read and execute the
/// file.
fn resolve_path(path: &Path, args: &str) -> Result<HopAction<'static>, BunBunError> {
    let output = Command::new(path.canonicalize()?)
        .args(args.split(' '))
        .output()?;

    if output.status.success() {
        Ok(serde_json::from_slice(&output.stdout)?)
    } else {
        error!(
            "Program exit code for {} was not 0! Dumping standard error!",
            path.display(),
        );
        let error = String::from_utf8_lossy(&output.stderr);
        Err(BunBunError::CustomProgram(error.to_string()))
    }
}

#[cfg(test)]
mod resolve_hop {
    use super::*;
    use anyhow::Result;

    fn generate_route_result<'a>(keyword: &'a Route, args: &str) -> RouteResolution<'a> {
        RouteResolution::Resolved {
            route: keyword,
            args: String::from(args),
        }
    }

    #[test]
    fn empty_routes_no_default_yields_failed_hop() {
        assert_eq!(
            resolve_hop("hello world", &HashMap::new(), None),
            RouteResolution::Unresolved
        );
    }

    #[test]
    fn empty_routes_some_default_yields_failed_hop() {
        assert_eq!(
            resolve_hop("hello world", &HashMap::new(), Some(&"google")),
            RouteResolution::Unresolved
        );
    }

    #[test]
    fn only_default_routes_some_default_yields_default_hop() -> Result<()> {
        let mut map: HashMap<String, Route> = HashMap::new();
        map.insert("google".into(), Route::from("https://example.com"));
        assert_eq!(
            resolve_hop("hello world", &map, Some("google")),
            generate_route_result(&Route::from("https://example.com"), "hello world"),
        );
        Ok(())
    }

    #[test]
    fn non_default_routes_some_default_yields_non_default_hop() -> Result<()> {
        let mut map: HashMap<String, Route> = HashMap::new();
        map.insert("google".into(), Route::from("https://example.com"));
        assert_eq!(
            resolve_hop("google hello world", &map, Some("a")),
            generate_route_result(&Route::from("https://example.com"), "hello world"),
        );
        Ok(())
    }

    #[test]
    fn non_default_routes_no_default_yields_non_default_hop() -> Result<()> {
        let mut map: HashMap<String, Route> = HashMap::new();
        map.insert("google".into(), Route::from("https://example.com"));
        assert_eq!(
            resolve_hop("google hello world", &map, None),
            generate_route_result(&Route::from("https://example.com"), "hello world"),
        );
        Ok(())
    }
}

#[cfg(test)]
mod check_route {
    use super::*;

    fn create_route(
        min_args: impl Into<Option<usize>>,
        max_args: impl Into<Option<usize>>,
    ) -> Route {
        Route {
            description: None,
            hidden: false,
            max_args: max_args.into(),
            min_args: min_args.into(),
            path: String::new(),
            route_type: RouteType::External,
        }
    }

    #[test]
    fn no_min_arg_no_max_arg_counts() {
        assert!(check_route(&create_route(None, None), 0));
        assert!(check_route(&create_route(None, None), usize::MAX));
    }

    #[test]
    fn min_arg_no_max_arg_counts() {
        assert!(!check_route(&create_route(3, None), 0));
        assert!(!check_route(&create_route(3, None), 2));
        assert!(check_route(&create_route(3, None), 3));
        assert!(check_route(&create_route(3, None), 4));
        assert!(check_route(&create_route(3, None), usize::MAX));
    }

    #[test]
    fn no_min_arg_max_arg_counts() {
        assert!(check_route(&create_route(None, 3), 0));
        assert!(check_route(&create_route(None, 3), 2));
        assert!(check_route(&create_route(None, 3), 3));
        assert!(!check_route(&create_route(None, 3), 4));
        assert!(!check_route(&create_route(None, 3), usize::MAX));
    }

    #[test]
    fn min_arg_max_arg_counts() {
        assert!(!check_route(&create_route(2, 3), 1));
        assert!(check_route(&create_route(2, 3), 2));
        assert!(check_route(&create_route(2, 3), 3));
        assert!(!check_route(&create_route(2, 3), 4));
    }
}

#[cfg(test)]
mod resolve_path {
    use crate::error::BunBunError;

    use super::{resolve_path, HopAction};
    use anyhow::Result;
    use std::borrow::Cow;
    use std::env::current_dir;
    use std::io::ErrorKind;
    use std::path::{Path, PathBuf};

    #[test]
    fn invalid_path_returns_err() {
        assert!(resolve_path(&Path::new("/bin/aaaa"), "aaaa").is_err());
    }

    #[test]
    fn valid_path_returns_ok() {
        assert!(resolve_path(&Path::new("/bin/echo"), r#"{"body": "a"}"#).is_ok());
    }

    #[test]
    fn relative_path_returns_ok() -> Result<()> {
        // How many ".." needed to get to /
        let nest_level = current_dir()?.ancestors().count() - 1;
        let mut rel_path = PathBuf::from("../".repeat(nest_level));
        rel_path.push("./bin/echo");
        assert!(resolve_path(&rel_path, r#"{"body": "a"}"#).is_ok());
        Ok(())
    }

    #[test]
    fn no_permissions_returns_err() {
        let result = match resolve_path(&Path::new("/root/some_exec"), "") {
            Err(BunBunError::Io(e)) => e.kind() == ErrorKind::PermissionDenied,
            _ => false,
        };
        assert!(result);
    }

    #[test]
    fn non_success_exit_code_yields_err() {
        // cat-ing a folder always returns exit code 1
        assert!(resolve_path(&Path::new("/bin/cat"), "/").is_err());
    }

    #[test]
    fn return_body() -> Result<()> {
        assert_eq!(
            resolve_path(&Path::new("/bin/echo"), r#"{"body": "a"}"#)?,
            HopAction::Body("a".to_owned())
        );

        Ok(())
    }

    #[test]
    fn return_redirect() -> Result<()> {
        assert_eq!(
            resolve_path(&Path::new("/bin/echo"), r#"{"redirect": "a"}"#)?,
            HopAction::Redirect(Cow::Borrowed("a"))
        );
        Ok(())
    }
}