use std::collections::BTreeMap;
use crate::load_naming::_helpers::numbering::{repeat_of, shown};
use crate::load_naming::main::loaded_name::loaded_name;
use crate::load_naming::models::{
ColumnName, LoadedColumn, NameChange, NameRules, NumberedName, RenameColumn,
};
use crate::load_naming::types::RenameFunction;
pub(crate) fn named_columns(
columns: &[ColumnName],
rules: &NameRules,
rename: RenameFunction<'_>,
) -> (Vec<LoadedColumn>, Vec<String>) {
let given: Vec<RenameColumn> = columns
.iter()
.map(|column| RenameColumn {
position: column.position,
source: column.source.clone(),
default: loaded_name(rules.naming, &column.source, rules.max_length),
})
.collect();
let (renamed, problems) = renamed_positions(&given, rules, rename);
let loaded: Vec<LoadedColumn> = given
.iter()
.zip(columns)
.map(|(column, read)| loaded_column(column, read, renamed.get(&column.position)))
.collect();
(loaded, problems)
}
fn renamed_positions(
given: &[RenameColumn],
rules: &NameRules,
rename: RenameFunction<'_>,
) -> (BTreeMap<usize, String>, Vec<String>) {
let mut renamed: BTreeMap<usize, String> = given
.iter()
.filter_map(|column| Some((column.position, mapped_name(column, rules)?)))
.collect();
let mut problems: Vec<String> = Vec::new();
match rename(given) {
Ok(returned) => {
for (position, name) in returned {
match given.iter().any(|column| column.position == position) {
true => {
renamed.insert(position, name);
}
false => problems.push(format!(
"rename returned position {position}, which is not one of the table's columns"
)),
}
}
}
Err(problem) => problems.push(problem),
}
problems.extend(
given
.iter()
.filter(|column| renamed_empty(&renamed, column.position))
.map(|column| format!("rename gives column {:?} an empty name", column.source)),
);
(renamed, problems)
}
fn renamed_empty(renamed: &BTreeMap<usize, String>, position: usize) -> bool {
renamed
.get(&position)
.is_some_and(|name| name.trim().is_empty())
}
fn mapped_name(column: &RenameColumn, rules: &NameRules) -> Option<String> {
rules
.renamed
.get(&column.source)
.or_else(|| rules.renamed.get(&column.default))
.cloned()
}
fn loaded_column(
column: &RenameColumn,
read: &ColumnName,
renamed: Option<&String>,
) -> LoadedColumn {
let (loaded, change) = match renamed {
Some(name) => (name.clone(), Some(NameChange::Renamed)),
None => (
column.default.clone(),
(column.default != column.source).then_some(NameChange::Named),
),
};
LoadedColumn {
position: column.position,
source: column.source.clone(),
read_as: read.read_as.clone(),
loaded,
change,
}
}
pub(crate) fn rename_clashes(loaded: &[LoadedColumn], kept: &[NumberedName]) -> Vec<String> {
loaded
.iter()
.filter(|column| column.change == Some(NameChange::Renamed))
.filter_map(|column| rename_clash(column, loaded, kept))
.collect()
}
fn rename_clash(
column: &LoadedColumn,
loaded: &[LoadedColumn],
kept: &[NumberedName],
) -> Option<String> {
let other = loaded.iter().find(|other| {
other.position != column.position
&& kept_or_loaded(other, loaded, kept).eq_ignore_ascii_case(&column.loaded)
&& (other.position > column.position || other.change != Some(NameChange::Renamed))
})?;
Some(format!(
"rename gives column {} the name {}, which column {} loads as too; give each a name of its own",
shown(column, loaded),
column.loaded,
shown(other, loaded)
))
}
fn kept_or_loaded(column: &LoadedColumn, loaded: &[LoadedColumn], kept: &[NumberedName]) -> String {
let repeat = repeat_of(column, loaded);
kept.iter()
.find(|kept| kept.source == column.source && kept.repeat == repeat)
.filter(|_| column.change != Some(NameChange::Renamed))
.map_or_else(|| column.loaded.clone(), |kept| kept.column.clone())
}