use alloc::string::{String, ToString};
use alloc::vec::Vec;
use crate::tlv_builders::{name, value_u32, value_u8, BuildError};
use crate::{type_code, Opt, Tlv};
pub const MAX_FIELD_DEPTH: usize = 8;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FieldMode {
Scalar,
Element,
Wildcard,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FieldLevel {
pub name: String,
pub index: Option<u32>,
pub mode: FieldMode,
}
impl FieldLevel {
pub fn scalar(name: &str) -> FieldLevel {
FieldLevel {
name: name.to_string(),
index: None,
mode: FieldMode::Scalar,
}
}
pub fn indexed(name: &str, index: u32) -> FieldLevel {
FieldLevel {
name: name.to_string(),
index: Some(index),
mode: FieldMode::Element,
}
}
pub fn append(name: &str) -> FieldLevel {
FieldLevel {
name: name.to_string(),
index: None,
mode: FieldMode::Element,
}
}
pub fn wildcard(name: &str) -> FieldLevel {
FieldLevel {
name: name.to_string(),
index: None,
mode: FieldMode::Wildcard,
}
}
}
pub fn parse_field(field: &str) -> Result<Vec<FieldLevel>, BuildError> {
let body = field.strip_prefix(':').unwrap_or(field);
if body.is_empty() {
return Err(BuildError::InvalidField);
}
let mut levels = Vec::new();
for part in body.split('.') {
levels.push(parse_level(part)?);
if levels.len() > MAX_FIELD_DEPTH {
return Err(BuildError::TooManySegments);
}
}
Ok(levels)
}
fn parse_level(part: &str) -> Result<FieldLevel, BuildError> {
match part.find('[') {
None => {
if part.is_empty() {
return Err(BuildError::InvalidField);
}
Ok(FieldLevel::scalar(part))
}
Some(br) => {
if !part.ends_with(']') {
return Err(BuildError::InvalidField);
}
let name = &part[..br];
if name.is_empty() {
return Err(BuildError::InvalidField);
}
let inner = &part[br + 1..part.len() - 1];
if inner == "*" {
Ok(FieldLevel::wildcard(name))
} else if inner.is_empty() {
Ok(FieldLevel::append(name))
} else {
let index: u32 = inner.parse().map_err(|_| BuildError::InvalidField)?;
Ok(FieldLevel::indexed(name, index))
}
}
}
}
pub fn field_tlv(levels: &[FieldLevel]) -> Result<Tlv, BuildError> {
if levels.is_empty() {
return Err(BuildError::InvalidField);
}
if levels.len() > MAX_FIELD_DEPTH {
return Err(BuildError::TooManySegments);
}
let mut children = Vec::new();
for level in levels {
children.push(name(&level.name)?);
match level.mode {
FieldMode::Wildcard => children.push(value_u8(2)),
FieldMode::Element => {
if let Some(index) = level.index {
children.push(value_u32(index));
}
children.push(value_u8(1));
}
FieldMode::Scalar => {}
}
}
Ok(Tlv {
type_code: type_code::FIELD,
opt: Opt::structured(),
payload: Vec::new(),
children,
trailer: None,
})
}
pub fn encode_field(field: &str) -> Result<Tlv, BuildError> {
field_tlv(&parse_field(field)?)
}
pub fn parse_field_tlv(tlv: &Tlv) -> Result<Vec<FieldLevel>, BuildError> {
if tlv.type_code != type_code::FIELD {
return Err(BuildError::TypeMismatch);
}
let mut levels = Vec::new();
let mut i = 0;
let ch = &tlv.children;
while i < ch.len() {
if ch[i].type_code != type_code::NAME {
return Err(BuildError::TypeMismatch);
}
let name = ch[i].payload_str()?.to_string();
i += 1;
let mut index: Option<u32> = None;
let mut mode = FieldMode::Scalar;
if i < ch.len() && ch[i].type_code == type_code::VALUE && ch[i].payload.len() >= 2 {
index = Some(ch[i].payload_uint() as u32);
i += 1;
}
if i < ch.len() && ch[i].type_code == type_code::VALUE && ch[i].payload.len() == 1 {
mode = match ch[i].payload[0] {
2 => FieldMode::Wildcard,
1 => FieldMode::Element,
_ => FieldMode::Scalar,
};
i += 1;
}
levels.push(FieldLevel { name, index, mode });
}
Ok(levels)
}