use std::str::FromStr;

use axum::{

    body::Body,

    extract::{Request, State},

    http::{

        HeaderValue, Method, StatusCode, Uri,

        header::{CONTENT_LENGTH, CONTENT_TYPE, HOST},

        uri::PathAndQuery,

    },

    middleware::Next,

    response::Response,

};

use lyquor_hosting::ProcessManagerHandle;

use lyquor_primitives::{Bytes, LyquidID};

use super::jsonrpc;

const SPECIAL_API_PATH: &str = "/lyquid/api";

const SPECIAL_WS_PATH: &str = "/lyquid/ws";

#[derive(Clone)]

pub(super) struct LyquidSiteRouteState {

    node_dns_label: String,

    jsonrpc_state: jsonrpc::JsonRpcRouteState,

    process_manager: ProcessManagerHandle,

}

impl LyquidSiteRouteState {

    pub(super) fn new(

        node_dns_label: String, jsonrpc_state: jsonrpc::JsonRpcRouteState, process_manager: ProcessManagerHandle,

    ) -> Self {

        Self {

            node_dns_label: node_dns_label.to_ascii_lowercase(),

            jsonrpc_state,

            process_manager,

        }

    }

}

pub(super) async fn route(State(state): State<LyquidSiteRouteState>, mut req: Request, next: Next) -> Response {

    let Some(lyquid_id) = lyquid_id_from_request_host(&req, &state.node_dns_label) else {

        return next.run(req).await;

    };

    match req.uri().path() {

        SPECIAL_API_PATH => {

            rewrite_request_path(&mut req, "/api");

            jsonrpc::api_route(req, state.jsonrpc_state).await

        }

        SPECIAL_WS_PATH => {

            rewrite_request_path(&mut req, "/ws");

            jsonrpc::ws_route(req, state.jsonrpc_state).await

        }

        path if path.starts_with("/lyquid/") => text_response(StatusCode::NOT_FOUND, "Not found"),

        _ => serve_asset(req, state, lyquid_id).await,

    }

}

async fn serve_asset(req: Request, state: LyquidSiteRouteState, lyquid_id: LyquidID) -> Response {

    let method = req.method().clone();

    if method != Method::GET && method != Method::HEAD {

        return text_response(StatusCode::METHOD_NOT_ALLOWED, "Method not allowed");

    }

    let Some(asset_name) = normalize_asset_path(req.uri().path()) else {

        return text_response(StatusCode::NOT_FOUND, "Not found");

    };

    let lyquid = match state.process_manager.get_lyquid(lyquid_id).await {

        Ok(Some(lyquid)) => lyquid,

        Ok(None) => return text_response(StatusCode::NOT_FOUND, "Not found"),

        Err(err) => {

            tracing::warn!(

                %lyquid_id,

                error = ?err,

                "Failed to resolve hosted Lyquid for static asset request"

            );

            return text_response(StatusCode::INTERNAL_SERVER_ERROR, "Internal server error");

        }

    };

    match lyquid.load_asset(&asset_name) {

        Some(asset) => asset_response(&asset_name, asset, method == Method::HEAD),

        None => text_response(StatusCode::NOT_FOUND, "Not found"),

    }

}

fn lyquid_id_from_request_host(req: &Request, node_dns_label: &str) -> Option<LyquidID> {

    let host = req

        .headers()

        .get(HOST)

        .and_then(|host| host.to_str().ok())

        .or_else(|| req.uri().authority().map(|authority| authority.as_str()))?;

    lyquid_id_from_host(host, node_dns_label)

}

fn lyquid_id_from_host(host: &str, node_dns_label: &str) -> Option<LyquidID> {

    let host = host

        .split_once(':')

        .map(|(host, _)| host)

        .unwrap_or(host)

        .trim_end_matches('.')

        .to_ascii_lowercase();

    let mut labels = host.split('.');

    let lyquid_label = labels.next()
?0
;

    let node_label = labels.next()
?0
;

    if node_label != node_dns_label {

        return None;

    }

    // Match only `<lyquid_id>.<node_id>` and intentionally leave the DNS suffix

    // unconstrained. ACME/DNS publication for a configured suffix is optional,

    // and operators may serve the same node under a different canonical FQDN.

    // Network-wide suffix enforcement belongs to the sequence/UPC layer, not

    // this HTTP host routing path.

    lyquid_id_from_dns_label(lyquid_label)

}

fn lyquid_id_from_dns_label(label: &str) -> Option<LyquidID> {

    LyquidID::from_str(&format!("Lyquid-{label}")).ok()

}

fn normalize_asset_path(path: &str) -> Option<String> {

    let path = path.strip_prefix('/')
?0
;

    let asset_name = if path.is_empty() {

        "index.html".to_owned()

    } else if path.ends_with('/') {

        format!("{path}index.html")

    } else {

        path.to_owned()

    };

    if asset_name.contains('\\') ||

        asset_name

            .split('/')

            .
any5
(|segment| segment.is_empty() || 
segment == "."7
 || 
segment == ".."7
)

    {

        return None;

    }

    Some(asset_name)

}

fn rewrite_request_path(req: &mut Request, path: &'static str) {

    let mut parts = req.uri().clone().into_parts();

    let path_and_query = match req.uri().query() {

        Some(query) => format!("{path}?{query}"),

        None => path.to_owned(),

    };

    parts.path_and_query =

        Some(PathAndQuery::from_str(&path_and_query).expect("rewritten Lyquid special path should be valid"));

    *req.uri_mut() = Uri::from_parts(parts).expect("rewritten Lyquid special URI should be valid");

}

fn asset_response(asset_name: &str, asset: Bytes, head: bool) -> Response {

    let content_type = content_type_for_asset(asset_name);

    let length = asset.len().to_string();

    let body = if head { Body::empty() } else { Body::from(asset) };

    Response::builder()

        .status(StatusCode::OK)

        .header(CONTENT_TYPE, content_type)

        .header(CONTENT_LENGTH, length)

        .body(body)

        .expect("asset response should be valid")

}

fn content_type_for_asset(asset_name: &str) -> HeaderValue {

    let content_type = match asset_name.rsplit('.').next().unwrap_or_default() {

        "css" => "text/css; charset=utf-8",

        "gif" => "image/gif",

        "html" | "htm" => "text/html; charset=utf-8",

        "ico" => "image/x-icon",

        "jpeg" | "jpg" => "image/jpeg",

        "js" | "mjs" => "text/javascript; charset=utf-8",

        "json" => "application/json; charset=utf-8",

        "map" => "application/json; charset=utf-8",

        "png" => "image/png",

        "svg" => "image/svg+xml",

        "txt" => "text/plain; charset=utf-8",

        "wasm" => "application/wasm",

        "webp" => "image/webp",

        _ => "application/octet-stream",

    };

    HeaderValue::from_static(content_type)

}

fn text_response(status: StatusCode, body: &'static str) -> Response {

    Response::builder()

        .status(status)

        .header(CONTENT_TYPE, "text/plain; charset=utf-8")

        .body(Body::from(body))

        .expect("text response should be valid")

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn host_parser_accepts_raw_lyquid_labels() {

        let id = LyquidID::from(42_u64);

        let node = "node-label";

        let raw_host = format!("{}.{}.example.test", id.as_dns_label(), node);

        let prefixed_host = format!("lyquid-{}.{}.example.test", id.as_dns_label(), node);

        assert_eq!(lyquid_id_from_host(&raw_host, node), Some(id));

        assert_eq!(lyquid_id_from_host(&prefixed_host, node), None);

        assert_eq!(lyquid_id_from_host(&raw_host, "other-node"), None);

    }

    #[test]

    fn asset_paths_are_normalized_without_traversal() {

        assert_eq!(normalize_asset_path("/"), Some("index.html".to_owned()));

        assert_eq!(normalize_asset_path("/src/app.js"), Some("src/app.js".to_owned()));

        assert_eq!(normalize_asset_path("/docs/"), Some("docs/index.html".to_owned()));

        assert_eq!(normalize_asset_path("/../secret"), None);

        assert_eq!(normalize_asset_path("/src//app.js"), None);

        assert_eq!(normalize_asset_path(r"/src\app.js"), None);

    }

}