use tiny_http::{Header, Response, StatusCode};

use tiny_http::{Response, StatusCode};

/// Create a 200 OK response with application/octet-stream.
pub fn ok_bin(data: Vec<u8>) -> HttpResponse {
    Response::from_data(data)
        .with_status_code(StatusCode(200))
        .with_header(Header::from_bytes("Content-Type", "application/octet-stream").unwrap())

macro_rules! header {
    ($name:expr, $value:expr) => {
        tiny_http::Header::from_bytes(&$name.as_bytes()[..], &$value.as_bytes()[..])
            .expect("Header should be created from bytes")
    };

/// Create a 200 OK response with text/plain.
pub fn ok_text(s: String) -> HttpResponse {
    Response::from_data(s)
        .with_status_code(StatusCode(200))
        .with_header(Header::from_bytes("Content-Type", "text/plain").unwrap())

/// Create a 200 OK response with application/octet-stream.
pub fn binary(d: Vec<u8>) -> HttpResponse {
    Response::from_data(d).with_header(header!("Content-Type", "application/octet-stream"))

pub fn ok_json(s: &str) -> HttpResponse {
    Response::from_string(s)
        .with_status_code(StatusCode(200))
        .with_header(Header::from_bytes("Content-Type", "application/json").unwrap())
}
/// Create a 400 Bad Request response.
pub fn bad_request() -> HttpResponse {
    Response::from_string("bad request\n").with_status_code(StatusCode(400))

pub fn json(s: &str) -> HttpResponse {
    Response::from_string(s).with_header(header!("Content-Type", "application/json"))

/// Create a 404 Not Found response with a message.
///
/// Returned when:
/// - Requested change/tag file doesn't exist
/// - Channel doesn't exist
/// - Path doesn't start with `.pijul`
/// - Hash validation fails
pub fn not_found(msg: &str) -> HttpResponse {
    Response::from_string(format!("{msg}\n")).with_status_code(StatusCode(404))
}

/// Return status code with default reason phrase
pub fn status_code(code: u16) -> HttpResponse {
    let c = StatusCode::from(code);

/// Create a 500 Internal Server Error response.
pub fn internal_error() -> HttpResponse {
    Response::from_string("internal error\n").with_status_code(StatusCode(500))

    Response::from_string(c.default_reason_phrase()).with_status_code(c)

pub fn serve_file(path: &Path, content_type: &str) -> HttpResponse {

pub fn file(path: &Path, content_type: &str) -> HttpResponse {

            .with_status_code(StatusCode(200))
            .with_header(Header::from_bytes("Content-Type", content_type).unwrap())
            .with_header(
                Header::from_bytes("Cache-Control", "public, max-age=31536000, immutable").unwrap(),
            ),
        Err(_) => not_found("not found"),

            .with_header(header!("Content-Type", content_type))
            .with_header(header!(
                "Cache-Control",
                "public, max-age=31536000, immutable"
            )),
        Err(_) => status_code(404),

    fn get_status(resp: &HttpResponse) -> u16 {
        resp.status_code().0
    }

    fn test_header_macro() {
        let h = header!("Content-Type", "text/plain");
        assert_eq!(h.field.as_str().as_str(), "Content-Type");
        assert_eq!(h.value.as_str(), "text/plain");
    }
    #[test]

        let resp = ok_bin(data);
        assert_eq!(get_status(&resp), 200);

        let resp = super::binary(data);
        assert_eq!(resp.status_code().0, 200);

    }
    #[test]
    fn test_ok_text() {
        let resp = ok_text("hello world".to_string());
        assert_eq!(get_status(&resp), 200);
        assert_eq!(get_header(&resp, "Content-Type"), Some("text/plain"));

        let resp = ok_json(r#"{"key": "value"}"#);
        assert_eq!(get_status(&resp), 200);

        let resp = super::json(r#"{"key": "value"}"#);
        assert_eq!(resp.status_code().0, 200);

    }
    #[test]
    fn test_bad_request() {
        let resp = bad_request();
        assert_eq!(get_status(&resp), 400);
    }
    #[test]
    fn test_not_found() {
        let resp = not_found("resource missing");
        assert_eq!(get_status(&resp), 404);

    fn test_internal_error() {
        let resp = internal_error();
        assert_eq!(get_status(&resp), 500);
    }
    #[test]

        let resp = serve_file(Path::new("/nonexistent/path/file.txt"), "text/plain");
        assert_eq!(get_status(&resp), 404);

        let resp = super::file(std::path::Path::new("/nonexistent/path/file.txt"), "text/plain");
        assert_eq!(resp.status_code().0, 404);

        let resp = serve_file(&file.path(), "text/plain");
        assert_eq!(get_status(&resp), 200);

        let resp = super::file(&file.path(), "text/plain");
        assert_eq!(resp.status_code().0, 200);

use tiny_http::Response;

use crate::responses::{HttpResponse, not_found, ok_json, ok_text, serve_file};

use crate::responses::{self, HttpResponse};

            ok_json(&json)

            responses::json(&json)

        None => not_found("channel not found"),

        None => Response::from_string("channel not found").with_status_code(400),

    ok_text(output)

    Response::from_string(&output)

        return not_found("invalid change hash");

        return Response::from_string("invalid change hash").with_status_code(404);

    serve_file(&path, "application/octet-stream")

    responses::file(&path, "application/octet-stream")

        Some((pos, merkle, tag_merkle)) => ok_text(format!("{} {} {}", pos, merkle, tag_merkle)),
        None => ok_text("-".to_string()), // Spec says return "-" if not found

        Some((pos, merkle, tag_merkle)) => Response::from_string(format!("{} {} {}", pos, merkle, tag_merkle)),
        None => responses::status_code(400)

    ok_json(r#"{"id":[],"rev":0}"#)

    responses::json(r#"{"id":[],"rev":0}"#)

    ok_json(&out)

    responses::json(&out)

use pijul_srv_lite::responses::{HttpResponse, bad_request, not_found};

use pijul_srv_lite::responses::{self, HttpResponse};

        return not_found("not found");

        return responses::status_code(404);

    let reader = PristineReader {};

    let reader = match PristineReader::open(repo_path) {
        Ok(r) => r,
        Err(_) => return responses::status_code(500),
    };

        Operation::Info => serve_info(&reader),

        Operation::Invalid => bad_request(),

        Operation::NoCommandSpecified => Response::from_string("No command specified\n").with_status_code(404),
        Operation::Invalid => responses::status_code(500),