use std::fmt;
use serde::de::Error as _;
use serde::{Deserialize, Deserializer, Serialize};
use crate::error::{VcpError, VcpResult};
const MAX_PERSONAL_WIRE_CHARS: usize = 8_192;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PersonalDimensionKind {
CognitiveState,
EmotionalTone,
EnergyLevel,
PerceivedUrgency,
BodySignals,
}
impl PersonalDimensionKind {
pub fn symbol(self) -> &'static str {
match self {
Self::CognitiveState => "\u{1F9E0}", Self::EmotionalTone => "\u{1F4AD}", Self::EnergyLevel => "\u{1F50B}", Self::PerceivedUrgency => "\u{26A1}", Self::BodySignals => "\u{1FA7A}", }
}
pub fn from_symbol(s: &str) -> Option<Self> {
match s {
"\u{1F9E0}" => Some(Self::CognitiveState),
"\u{1F4AD}" => Some(Self::EmotionalTone),
"\u{1F50B}" => Some(Self::EnergyLevel),
"\u{26A1}" => Some(Self::PerceivedUrgency),
"\u{1FA7A}" => Some(Self::BodySignals),
_ => None,
}
}
pub fn valid_values(self) -> &'static [&'static str] {
match self {
Self::CognitiveState => &["focused", "distracted", "overloaded", "foggy", "reflective"],
Self::EmotionalTone => &["calm", "tense", "frustrated", "neutral", "uplifted"],
Self::EnergyLevel => &["rested", "low_energy", "fatigued", "wired", "depleted"],
Self::PerceivedUrgency => &["unhurried", "time_aware", "pressured", "critical"],
Self::BodySignals => &["neutral", "discomfort", "pain", "unwell", "recovering"],
}
}
}
impl fmt::Display for PersonalDimensionKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let label = match self {
Self::CognitiveState => "cognitive_state",
Self::EmotionalTone => "emotional_tone",
Self::EnergyLevel => "energy_level",
Self::PerceivedUrgency => "perceived_urgency",
Self::BodySignals => "body_signals",
};
f.write_str(label)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct PersonalDimension {
pub value: String,
pub intensity: u8,
#[serde(skip_serializing_if = "Option::is_none")]
pub extended: Option<String>,
}
impl PersonalDimension {
const MAX_VALUE_CHARS: usize = 64;
const MAX_EXTENDED_CHARS: usize = 256;
fn validate(value: &str, intensity: u8, extended: Option<&str>) -> VcpResult<()> {
let valid_value = !value.is_empty()
&& value.chars().count() <= Self::MAX_VALUE_CHARS
&& value
.bytes()
.next()
.is_some_and(|byte| byte.is_ascii_lowercase())
&& value
.chars()
.all(|character| character.is_ascii_lowercase() || character == '_');
if !valid_value {
return Err(VcpError::ParseError(
"personal value must match [a-z][a-z_]{0,63}".to_string(),
));
}
if !(1..=5).contains(&intensity) {
return Err(VcpError::InvalidIntensity(intensity));
}
if let Some(extended) = extended {
if extended.is_empty()
|| extended.chars().count() > Self::MAX_EXTENDED_CHARS
|| extended.chars().any(|character| {
character.is_control() || matches!(character, '[' | ']' | '|' | '\u{2016}')
})
{
return Err(VcpError::ParseError(
"extended personal value is empty, oversized, or wire-ambiguous".to_string(),
));
}
}
Ok(())
}
pub fn new(value: impl Into<String>, intensity: u8) -> VcpResult<Self> {
let value = value.into();
Self::validate(&value, intensity, None)?;
Ok(Self {
value,
intensity,
extended: None,
})
}
pub fn with_extended(
value: impl Into<String>,
intensity: u8,
extended: impl Into<String>,
) -> VcpResult<Self> {
let value = value.into();
let extended = extended.into();
Self::validate(&value, intensity, Some(&extended))?;
Ok(Self {
value,
intensity,
extended: Some(extended),
})
}
pub fn to_wire(&self) -> String {
let mut s = format!("{}:{}", self.value, self.intensity);
if let Some(ref ext) = self.extended {
s.push('[');
s.push_str(ext);
s.push(']');
}
s
}
pub fn from_wire(wire: &str) -> VcpResult<Self> {
let (main, extended) = if let Some(bracket_start) = wire.find('[') {
if !wire.ends_with(']') {
return Err(VcpError::ParseError(format!(
"unterminated bracket in personal dimension: {wire}"
)));
}
let ext = &wire[bracket_start + 1..wire.len() - 1];
(&wire[..bracket_start], Some(ext.to_string()))
} else {
(wire, None)
};
let parts: Vec<&str> = main.split(':').collect();
if parts.len() != 2 {
return Err(VcpError::ParseError(format!(
"personal dimension must be value:intensity, got: {wire}"
)));
}
let value = parts[0].to_string();
let intensity: u8 = parts[1]
.parse()
.map_err(|_| VcpError::ParseError(format!("invalid intensity: {}", parts[1])))?;
Self::validate(&value, intensity, extended.as_deref())?;
Ok(Self {
value,
intensity,
extended,
})
}
}
impl<'de> Deserialize<'de> for PersonalDimension {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct WireDimension {
value: String,
#[serde(default)]
intensity: Option<u8>,
#[serde(default)]
extended: Option<String>,
}
let wire = WireDimension::deserialize(deserializer)?;
let intensity = wire.intensity.unwrap_or(3);
PersonalDimension::validate(&wire.value, intensity, wire.extended.as_deref())
.map_err(D::Error::custom)?;
Ok(PersonalDimension {
value: wire.value,
intensity,
extended: wire.extended,
})
}
}
impl fmt::Display for PersonalDimension {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.to_wire())
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct PersonalState {
#[serde(skip_serializing_if = "Option::is_none")]
pub cognitive: Option<PersonalDimension>,
#[serde(skip_serializing_if = "Option::is_none")]
pub emotional: Option<PersonalDimension>,
#[serde(skip_serializing_if = "Option::is_none")]
pub energy: Option<PersonalDimension>,
#[serde(skip_serializing_if = "Option::is_none")]
pub urgency: Option<PersonalDimension>,
#[serde(skip_serializing_if = "Option::is_none")]
pub body: Option<PersonalDimension>,
}
impl PersonalState {
pub fn has_any(&self) -> bool {
self.cognitive.is_some()
|| self.emotional.is_some()
|| self.energy.is_some()
|| self.urgency.is_some()
|| self.body.is_some()
}
pub fn to_wire(&self) -> String {
let mut parts = Vec::new();
let dims: [(PersonalDimensionKind, &Option<PersonalDimension>); 5] = [
(PersonalDimensionKind::CognitiveState, &self.cognitive),
(PersonalDimensionKind::EmotionalTone, &self.emotional),
(PersonalDimensionKind::EnergyLevel, &self.energy),
(PersonalDimensionKind::PerceivedUrgency, &self.urgency),
(PersonalDimensionKind::BodySignals, &self.body),
];
for (kind, dim_opt) in &dims {
if let Some(dim) = dim_opt {
parts.push(format!("{}{}", kind.symbol(), dim.to_wire()));
}
}
parts.join("|")
}
pub fn from_wire(wire: &str) -> VcpResult<Self> {
let mut state = PersonalState::default();
if wire.is_empty() {
return Ok(state);
}
if wire.chars().count() > MAX_PERSONAL_WIRE_CHARS {
return Err(VcpError::ParseError(format!(
"personal state exceeds {MAX_PERSONAL_WIRE_CHARS} characters"
)));
}
for segment in wire.split('|') {
if segment.is_empty() {
return Err(VcpError::ParseError(
"personal state contains an empty dimension segment".to_string(),
));
}
let (symbol, rest) = split_leading_emoji(segment)?;
let kind = PersonalDimensionKind::from_symbol(symbol).ok_or_else(|| {
VcpError::ParseError(format!("unknown personal dimension symbol: {symbol}"))
})?;
let dim = PersonalDimension::from_wire(rest)?;
let slot = match kind {
PersonalDimensionKind::CognitiveState => &mut state.cognitive,
PersonalDimensionKind::EmotionalTone => &mut state.emotional,
PersonalDimensionKind::EnergyLevel => &mut state.energy,
PersonalDimensionKind::PerceivedUrgency => &mut state.urgency,
PersonalDimensionKind::BodySignals => &mut state.body,
};
if slot.is_some() {
return Err(VcpError::ParseError(format!(
"duplicate personal dimension: {kind}"
)));
}
*slot = Some(dim);
}
Ok(state)
}
}
impl fmt::Display for PersonalState {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.to_wire())
}
}
fn split_leading_emoji(s: &str) -> VcpResult<(&str, &str)> {
static SYMBOLS: &[&str] = &[
"\u{1F9E0}", "\u{1F4AD}", "\u{1F50B}", "\u{1FA7A}", "\u{26A1}", ];
for sym in SYMBOLS {
if let Some(rest) = s.strip_prefix(sym) {
return Ok((sym, rest));
}
}
let first_char_len = s
.chars()
.next()
.ok_or_else(|| VcpError::ParseError("empty segment".into()))?
.len_utf8();
Ok((&s[..first_char_len], &s[first_char_len..]))
}
#[cfg(test)]
mod tests {
use super::*;
use pretty_assertions::assert_eq;
#[test]
fn dimension_new_valid() {
let d = PersonalDimension::new("focused", 4).unwrap();
assert_eq!(d.value, "focused");
assert_eq!(d.intensity, 4);
assert_eq!(d.extended, None);
}
#[test]
fn dimension_new_invalid_intensity() {
assert!(PersonalDimension::new("focused", 0).is_err());
assert!(PersonalDimension::new("focused", 6).is_err());
}
#[test]
fn dimension_constructors_reject_invalid_or_wire_ambiguous_text() {
for invalid in ["", "Focused", "two words", "focused:calm", "focused|calm"] {
assert!(
PersonalDimension::new(invalid, 3).is_err(),
"accepted {invalid:?}"
);
}
assert!(PersonalDimension::new("x".repeat(65), 3).is_err());
for invalid_extended in [
"",
"nested[detail]",
"one|two",
"one\u{2016}two",
"one\0two",
] {
assert!(PersonalDimension::with_extended("pain", 4, invalid_extended).is_err());
}
assert!(PersonalDimension::with_extended("pain", 4, "x".repeat(257)).is_err());
}
#[test]
fn dimension_with_extended() {
let d = PersonalDimension::with_extended("pain", 4, "migraine").unwrap();
assert_eq!(d.extended.as_deref(), Some("migraine"));
assert_eq!(d.to_wire(), "pain:4[migraine]");
}
#[test]
fn dimension_wire_roundtrip() {
let cases = vec!["focused:4", "calm:3", "pain:4[migraine]", "rested:1"];
for case in cases {
let d = PersonalDimension::from_wire(case).unwrap();
assert_eq!(d.to_wire(), case);
}
}
#[test]
fn dimension_wire_error_missing_colon() {
assert!(PersonalDimension::from_wire("focused").is_err());
}
#[test]
fn dimension_wire_error_bad_intensity() {
assert!(PersonalDimension::from_wire("focused:0").is_err());
assert!(PersonalDimension::from_wire("focused:9").is_err());
}
#[test]
fn personal_wire_rejects_empty_and_duplicate_segments() {
let duplicate = "\u{1F9E0}focused:4|\u{1F9E0}reflective:3";
for malformed in ["|", "\u{1F9E0}focused:4|", duplicate] {
assert!(
PersonalState::from_wire(malformed).is_err(),
"accepted {malformed:?}"
);
}
assert!(PersonalDimension::from_wire("pain:4[]").is_err());
let oversized = format!("🧠{}:3", "a".repeat(MAX_PERSONAL_WIRE_CHARS));
assert!(PersonalState::from_wire(&oversized)
.unwrap_err()
.to_string()
.contains("8192 characters"));
}
#[test]
fn personal_state_empty() {
let ps = PersonalState::default();
assert!(!ps.has_any());
assert_eq!(ps.to_wire(), "");
}
#[test]
fn personal_state_wire_roundtrip() {
let ps = PersonalState {
cognitive: Some(PersonalDimension::new("focused", 4).unwrap()),
emotional: Some(PersonalDimension::new("calm", 3).unwrap()),
..Default::default()
};
let wire = ps.to_wire();
assert!(wire.contains("focused:4"));
assert!(wire.contains("calm:3"));
let parsed = PersonalState::from_wire(&wire).unwrap();
assert_eq!(parsed.cognitive.as_ref().unwrap().value, "focused");
assert_eq!(parsed.cognitive.as_ref().unwrap().intensity, 4);
assert_eq!(parsed.emotional.as_ref().unwrap().value, "calm");
assert_eq!(parsed.emotional.as_ref().unwrap().intensity, 3);
}
#[test]
fn personal_state_all_dimensions() {
let ps = PersonalState {
cognitive: Some(PersonalDimension::new("overloaded", 5).unwrap()),
emotional: Some(PersonalDimension::new("tense", 4).unwrap()),
energy: Some(PersonalDimension::new("depleted", 4).unwrap()),
urgency: Some(PersonalDimension::new("critical", 5).unwrap()),
body: Some(PersonalDimension::with_extended("pain", 4, "migraine").unwrap()),
};
let wire = ps.to_wire();
let parsed = PersonalState::from_wire(&wire).unwrap();
assert_eq!(parsed.cognitive.as_ref().unwrap().value, "overloaded");
assert_eq!(parsed.emotional.as_ref().unwrap().value, "tense");
assert_eq!(parsed.energy.as_ref().unwrap().value, "depleted");
assert_eq!(parsed.urgency.as_ref().unwrap().value, "critical");
assert_eq!(parsed.body.as_ref().unwrap().value, "pain");
assert_eq!(
parsed.body.as_ref().unwrap().extended.as_deref(),
Some("migraine")
);
}
#[test]
fn dimension_kind_symbols() {
for kind in [
PersonalDimensionKind::CognitiveState,
PersonalDimensionKind::EmotionalTone,
PersonalDimensionKind::EnergyLevel,
PersonalDimensionKind::PerceivedUrgency,
PersonalDimensionKind::BodySignals,
] {
let sym = kind.symbol();
assert_eq!(PersonalDimensionKind::from_symbol(sym), Some(kind));
}
}
#[test]
fn dimension_kind_valid_values() {
assert!(PersonalDimensionKind::CognitiveState
.valid_values()
.contains(&"focused"));
assert!(PersonalDimensionKind::PerceivedUrgency
.valid_values()
.contains(&"critical"));
}
#[test]
fn serde_roundtrip() {
let ps = PersonalState {
cognitive: Some(PersonalDimension::new("focused", 4).unwrap()),
body: Some(PersonalDimension::with_extended("pain", 3, "headache").unwrap()),
..Default::default()
};
let json = serde_json::to_string(&ps).unwrap();
let parsed: PersonalState = serde_json::from_str(&json).unwrap();
assert_eq!(ps, parsed);
}
#[test]
fn serde_cannot_bypass_personal_dimension_invariants() {
for malformed in [
r#"{"value":"focused","intensity":0}"#,
r#"{"value":"focused","intensity":6}"#,
r#"{"value":"","intensity":3}"#,
r#"{"value":"focused|calm","intensity":3}"#,
r#"{"value":"focused","intensity":3,"extended":""}"#,
r#"{"value":"focused","intensity":3,"unknown":true}"#,
] {
assert!(
serde_json::from_str::<PersonalDimension>(malformed).is_err(),
"accepted {malformed}"
);
}
for defaulted in [
r#"{"value":"focused"}"#,
r#"{"value":"focused","intensity":null}"#,
] {
assert_eq!(
serde_json::from_str::<PersonalDimension>(defaulted)
.unwrap()
.intensity,
3
);
}
}
}