mini-static 0.20.0

use std::path::Path;
use std::pin::Pin;
use std::task::{Context, Poll};

use bytes::Bytes;
use http_body::{Body, Frame};
use tokio::sync::mpsc::UnboundedReceiver;

use crate::error::StaticError;
use crate::watcher::ChangeEvent;

/// The request path `Server` serves the live-reload SSE stream on when
/// [`crate::Server::with_live_reload`] is enabled.
pub const LIVE_RELOAD_PATH: &str = "/__mini_static_reload";

/// The type of change detected in a watched file.
///
/// Used by live-reload to determine what the browser should do when a file changes:
/// CSS stylesheets are hot-swapped, while scripts and HTML require a full page reload.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ChangeType {
    /// A CSS stylesheet changed.
    Css,
    /// A JavaScript module changed.
    Script,
    /// An HTML page changed.
    Html,
    /// Some other file changed.
    Other,
}

impl ChangeType {
    /// Determine the change type from a file path's extension.
    pub fn from_path(path: &Path) -> Self {
        match path.extension().and_then(|e| e.to_str()) {
            Some("css") => ChangeType::Css,
            Some("js" | "mjs") => ChangeType::Script,
            Some("html" | "htm") => ChangeType::Html,
            _ => ChangeType::Other,
        }
    }

    /// The string representation used in SSE event names and JSON.
    pub fn as_str(&self) -> &'static str {
        match self {
            ChangeType::Css => "css",
            ChangeType::Script => "script",
            ChangeType::Html => "html",
            ChangeType::Other => "other",
        }
    }
}

/// Encode a reload event as an SSE (Server-Sent Events) frame.
///
/// The frame follows the SSE text/event-stream format:
/// ```text
/// event: <change_type>
/// data: {"type": "<change_type>"}
///
/// ```
///
/// This is the single canonical place the SSE frame format is defined.
/// Callers that forward reload events over HTTP (e.g., mini-unified) call this
/// function rather than re-implementing the byte-for-byte format.
///
/// The JSON payload is written directly rather than through a serializer: it is one
/// fixed-shape object whose only value is one of [`ChangeType::as_str`]'s four literals,
/// none of which contain a character JSON would need to escape. Pulling in a JSON
/// dependency to emit eleven constant bytes is not a trade worth making.
pub fn reload_event_frame(change_type: &ChangeType) -> Bytes {
    let name = change_type.as_str();
    Bytes::from(format!("event: {name}\ndata: {{\"type\":\"{name}\"}}\n\n"))
}

/// An `http_body::Body` that streams live-reload SSE frames to a single connected
/// client, one [`ChangeEvent`] at a time, for as long as the underlying broadcast
/// channel stays open.
pub struct SseBody {
    rx: UnboundedReceiver<ChangeEvent>,
}

impl SseBody {
    pub(crate) fn new(rx: UnboundedReceiver<ChangeEvent>) -> Self {
        SseBody { rx }
    }
}

impl Body for SseBody {
    type Data = Bytes;
    type Error = StaticError;

    fn poll_frame(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>> {
        match self.rx.poll_recv(cx) {
            Poll::Ready(Some(event)) => Poll::Ready(Some(Ok(Frame::data(reload_event_frame(
                &event.change_type,
            ))))),
            Poll::Ready(None) => Poll::Ready(None),
            Poll::Pending => Poll::Pending,
        }
    }
}

/// The `<script>` tag `Server` injects into served HTML pages when live-reload is
/// enabled (see [`inject_reload_script`]).
///
/// Opens an `EventSource` to [`LIVE_RELOAD_PATH`]. A `css` event hot-swaps every
/// stylesheet `<link>` (cache-busted via a query param) without a full page reload;
/// `script`, `html`, and `other` events reload the page, since there is no general way
/// to hot-swap those in place.
///
/// # Panics
///
/// Never — the returned string is a fixed literal embedding [`LIVE_RELOAD_PATH`].
fn reload_script_tag() -> String {
    format!(
        "<script>(function(){{\
			var es=new EventSource(\"{LIVE_RELOAD_PATH}\");\
			function reload(){{location.reload();}}\
			es.addEventListener(\"css\",function(){{\
				document.querySelectorAll('link[rel=\"stylesheet\"]').forEach(function(l){{\
					var u=new URL(l.href);u.searchParams.set(\"_mr\",Date.now());l.href=u.toString();\
				}});\
			}});\
			es.addEventListener(\"script\",reload);\
			es.addEventListener(\"html\",reload);\
			es.addEventListener(\"other\",reload);\
		}})();</script>"
    )
}

/// Insert the live-reload client script (see [`reload_script_tag`]) into an HTML
/// document, immediately before the closing `</body>` tag if one is found (checking
/// both `</body>` and `</BODY>`), otherwise appended at the end of the document.
///
/// Operates on raw bytes rather than parsing HTML — `mini-static` has no HTML parser
/// and does not need one for a single fixed-string insertion.
pub(crate) fn inject_reload_script(html: &mut Vec<u8>) {
    let script = reload_script_tag();

    let pos = find_subsequence(html, b"</body>").or_else(|| find_subsequence(html, b"</BODY>"));

    match pos {
        Some(pos) => {
            html.splice(pos..pos, script.into_bytes());
        }
        None => html.extend_from_slice(script.as_bytes()),
    }
}

/// Find the first occurrence of `needle` in `haystack`, if any.
///
/// Shared byte-search helper: both the live-reload and spa-mode script
/// injectors splice a fixed `<script>` immediately before `</body>`, and
/// both need this same substring scan to find it.
pub(crate) fn find_subsequence(haystack: &[u8], needle: &[u8]) -> Option<usize> {
    haystack.windows(needle.len()).position(|w| w == needle)
}

#[cfg(test)]
#[path = "../tests/unit/reload.rs"]
mod tests;