use crate::{Error, Result};
macro_rules! bail {
($message:expr) => {
return Err(Error::Validation($message.to_string()))
};
}
use base64::{engine::general_purpose::STANDARD, Engine};
use serde_json::Value;
pub fn validate(message: &Value) -> Result<()> {
if message["version"] != "1.0" || message["type"] != "message" {
bail!("Expected a B2A 1.0 message");
}
if !message["source"]
.as_str()
.is_some_and(|v| !v.trim().is_empty() && v.len() <= 128)
{
bail!("A message source is required");
}
let items = message["payload"]["content"]
.as_array()
.ok_or_else(|| Error::Validation("content must be an array".into()))?;
if items.is_empty() || items.len() > 64 {
bail!("content must contain 1–64 blocks");
}
for item in items {
let kind = item["type"]
.as_str()
.filter(|v| !v.is_empty() && v.len() <= 128)
.ok_or_else(|| Error::Validation("A content type is required".into()))?;
if let Some(confidence) = item.get("confidence") {
if !confidence
.as_f64()
.is_some_and(|n| n.is_finite() && (0.0..=1.0).contains(&n))
{
bail!("confidence must be a finite number in [0,1]");
}
}
if let Some(timing) = item.get("timing") {
let start = timing["start_ms"].as_f64().filter(|v| *v >= 0.0);
let end = timing["end_ms"].as_f64();
if start.is_none() || end.is_none() || end < start {
bail!("Invalid content timing");
}
}
if item.get("data").is_some() == item.get("uri").is_some() {
bail!("Provide exactly one of data or uri");
}
if let Some(uri) = item.get("uri") {
let url = url::Url::parse(
uri.as_str()
.ok_or_else(|| Error::Validation("uri must be a string".into()))?,
)
.map_err(|e| Error::Validation(e.to_string()))?;
if !matches!(url.scheme(), "https" | "b2a")
|| !url.username().is_empty()
|| url.password().is_some()
|| url.host_str().is_none()
|| url.fragment().is_some()
{
bail!(
"Resource references require HTTPS or provider-owned b2a URIs without user credentials or fragments"
);
}
}
match kind {
"text" => {
if !item["data"].as_str().is_some_and(|v| !v.is_empty()) {
bail!("text.data must be nonempty text");
}
}
"audio" | "image" | "video" => {
let mime = item["mime_type"].as_str().unwrap_or("");
if !mime.starts_with(&format!("{kind}/"))
|| mime.len() > 128
|| mime.chars().any(char::is_whitespace)
{
bail!("Media requires a matching mime_type");
}
if item.get("data").is_some() {
if item["encoding"] != "base64" {
bail!("Inline media requires encoding: base64");
}
let bytes = STANDARD
.decode(item["data"].as_str().unwrap_or(""))
.map_err(|e| Error::Validation(e.to_string()))?;
if bytes.is_empty() {
bail!("Inline media must not be empty");
}
}
}
"control" => {
if !item["data"].is_object() {
bail!("control.data must be an object");
}
}
"features" => {
if item.get("uri").is_none()
&& !item["data"].is_object()
&& !item["data"].is_array()
{
bail!("features requires structured data or a resource");
}
}
_ => {
if !kind.contains(':') {
bail!("Extension content types must be namespaced, for example vendor:pose");
}
}
}
}
if let Some(stream) = message.get("stream") {
if stream
.get("mode")
.is_some_and(|v| !matches!(v.as_str(), Some("snapshot" | "delta")))
{
bail!("stream.mode must be snapshot or delta");
}
if stream["mode"] == "delta" && (items.len() != 1 || items[0]["type"] != "text") {
bail!("Delta streams require one text block");
}
if !stream["id"]
.as_str()
.is_some_and(|v| !v.is_empty() && v.len() <= 128)
|| stream["index"].as_u64().is_none()
|| !stream["final"].is_boolean()
{
bail!("stream requires id, nonnegative index and final");
}
}
Ok(())
}