use base64::Engine;
use base64::engine::general_purpose::STANDARD_NO_PAD;
use shake::Shake128;
use shake::{ExtendableOutput, Update, XofReader};
use unicode_properties::{GeneralCategory, UnicodeGeneralCategory};
use crate::load_naming::constants::{DLT_SWAPPED, DLT_TAG_BYTES};
pub(crate) fn snake_case(identifier: &str) -> String {
let mut kept: Vec<char> = Vec::with_capacity(identifier.len());
let mut replacing = false;
for character in identifier.chars() {
let character = DLT_SWAPPED
.iter()
.find(|(from, _)| *from == character)
.map_or(character, |(_, to)| *to);
let allowed = character.is_ascii_alphabetic() || character == '_' || is_digit(character);
if allowed {
kept.push(character);
} else if !replacing {
kept.push('_');
}
replacing = !allowed;
}
let mut words = case_breaks(&title_breaks(&kept));
if words.first().copied().is_some_and(is_digit) {
words.insert(0, '_');
}
let trailing = words
.iter()
.rev()
.take_while(|character| **character == '_')
.count();
words.truncate(words.len() - trailing);
words.extend(std::iter::repeat_n('x', trailing));
let mut snake = String::with_capacity(words.len());
for character in words {
if !(character == '_' && snake.ends_with('_')) {
snake.push(character);
}
}
snake
}
pub(crate) fn shortened(normalized: String, original: &str, max_length: Option<usize>) -> String {
let characters: Vec<char> = normalized.chars().collect();
let Some(max_length) = max_length.filter(|max| *max > 0 && characters.len() > *max) else {
return normalized;
};
let mut hasher = Shake128::default();
hasher.update(original.as_bytes());
let mut digest = [0_u8; DLT_TAG_BYTES];
hasher.finalize_xof().read(&mut digest);
let tag = STANDARD_NO_PAD
.encode(digest)
.replace('/', "a")
.replace('+', "b")
.to_ascii_lowercase();
let remaining = max_length.saturating_sub(tag.len());
let head: String = characters[..remaining / 2 + remaining % 2].iter().collect();
let tail: String = characters[characters.len() - remaining / 2..]
.iter()
.collect();
format!("{head}{tag}{tail}")
}
fn is_digit(character: char) -> bool {
character.is_ascii_digit() || character.general_category() == GeneralCategory::DecimalNumber
}
fn title_breaks(characters: &[char]) -> Vec<char> {
let mut broken = Vec::with_capacity(characters.len() + characters.len() / 2);
let mut index = 0;
while index < characters.len() {
let character = characters[index];
broken.push(character);
let lower = characters
.get(index + 2..)
.unwrap_or_default()
.iter()
.take_while(|next| next.is_ascii_lowercase())
.count();
let capital = characters
.get(index + 1)
.is_some_and(char::is_ascii_uppercase);
if character != '_' && capital && lower > 0 {
broken.push('_');
broken.extend_from_slice(&characters[index + 1..index + 2 + lower]);
index += 2 + lower;
} else {
index += 1;
}
}
broken
}
fn case_breaks(characters: &[char]) -> Vec<char> {
let mut broken = Vec::with_capacity(characters.len() + characters.len() / 2);
for (index, character) in characters.iter().enumerate() {
broken.push(character.to_ascii_lowercase());
let before = character.is_ascii_lowercase() || character.is_ascii_digit();
if before
&& characters
.get(index + 1)
.is_some_and(char::is_ascii_uppercase)
{
broken.push('_');
}
}
broken
}