use crate::types::{Address, FileResult, HashAlgos};
use std::collections::HashMap;
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct MergedResult {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub title: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub size: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mimetype: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub lang: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub published: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_seen: Option<String>,
#[serde(default, skip_serializing_if = "HashAlgos::is_empty")]
pub hashes: HashAlgos,
#[serde(default)]
pub providers: Vec<String>,
#[serde(default)]
pub addresses: Vec<Address>,
#[serde(default)]
pub score: f64,
}
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct ResultRef {
#[serde(default = "default_result_ref_version")]
pub version: u32,
#[serde(default)]
pub id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub title: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mimetype: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub size: Option<u64>,
#[serde(default, skip_serializing_if = "HashAlgos::is_empty")]
pub hashes: HashAlgos,
#[serde(default)]
pub addresses: Vec<Address>,
}
fn default_result_ref_version() -> u32 {
ResultRef::VERSION
}
impl ResultRef {
pub const VERSION: u32 = 1;
pub fn from_merged(result: &MergedResult) -> Self {
Self {
version: Self::VERSION,
id: result_id(result),
title: result.title.clone(),
mimetype: result.mimetype.clone(),
size: result.size,
hashes: result.hashes.clone(),
addresses: result.addresses.clone(),
}
}
pub fn is_current(&self) -> bool {
self.version == Self::VERSION
}
pub fn to_merged(&self) -> MergedResult {
MergedResult {
title: self.title.clone(),
size: self.size,
mimetype: self.mimetype.clone(),
hashes: self.hashes.clone(),
addresses: self.addresses.clone(),
..MergedResult::default()
}
}
}
impl From<&MergedResult> for ResultRef {
fn from(result: &MergedResult) -> Self {
Self::from_merged(result)
}
}
impl From<&ResultRef> for MergedResult {
fn from(result_ref: &ResultRef) -> Self {
result_ref.to_merged()
}
}
pub fn result_id(result: &MergedResult) -> String {
for algorithm in ["sha256", "sha1", "infohash", "md5", "cid"] {
if let Some(value) = result.hashes.get(algorithm) {
return format!("{algorithm}:{value}");
}
}
if let (Some(title), Some(size)) = (&result.title, result.size) {
let normalized = normalize(title);
if !normalized.is_empty() {
return format!("name:{normalized}:{size}");
}
}
if let Some(address) = preferred_address(result) {
return format!("uri:{}", address.uri);
}
"anonymous".to_owned()
}
#[derive(Debug, Clone, Default)]
pub struct MergeOptions {
pub provider_weights: HashMap<String, f64>,
}
pub fn merge<I>(results: I, options: &MergeOptions) -> Vec<MergedResult>
where
I: IntoIterator<Item = FileResult>,
{
let mut clusters: Vec<MergedResult> = Vec::new();
let mut index: HashMap<String, usize> = HashMap::new();
for result in results {
let keys = dedup_keys(&result);
let position = match keys.iter().find_map(|key| index.get(key).copied()) {
Some(position) => position,
None => {
clusters.push(MergedResult::default());
clusters.len() - 1
}
};
absorb(&mut clusters[position], result);
for key in keys {
index.insert(key, position);
}
}
for cluster in &mut clusters {
cluster.providers.sort();
cluster.providers.dedup();
cluster.score = score(cluster, &options.provider_weights);
}
clusters.sort_by(|a, b| {
b.score
.total_cmp(&a.score)
.then_with(|| a.title.cmp(&b.title))
});
clusters
}
pub fn suggest_filename(result: &MergedResult) -> String {
let name = result
.title
.as_deref()
.map(sanitize_filename)
.filter(|name| !name.is_empty())
.or_else(|| {
preferred_address(result)
.and_then(|address| uri_basename(&address.uri))
.map(|name| sanitize_filename(&name))
.filter(|name| !name.is_empty())
})
.unwrap_or_else(|| "download.bin".to_owned());
with_mimetype_extension(name, result.mimetype.as_deref())
}
pub(crate) fn preferred_address(result: &MergedResult) -> Option<&Address> {
result
.addresses
.iter()
.min_by_key(|address| address_rank(&address.scheme))
}
pub(crate) fn address_rank(scheme: &str) -> u8 {
match scheme {
"https" => 0,
"http" => 1,
"ipfs" => 2,
"magnet" => 3,
_ => 4,
}
}
fn sanitize_filename(name: &str) -> String {
let cleaned: String = name
.chars()
.map(|character| match character {
'/' | '\\' | '\0' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '_',
character if character.is_control() => '_',
character => character,
})
.collect();
cleaned.trim().trim_end_matches('.').to_owned()
}
fn uri_basename(uri: &str) -> Option<String> {
let without_query = uri.split(['?', '#']).next().unwrap_or(uri);
let after_scheme = without_query
.split_once("://")
.map_or(without_query, |(_, rest)| rest);
let (_authority, path) = after_scheme.split_once('/')?;
let segment = path.trim_end_matches('/').rsplit('/').next()?;
(!segment.is_empty()).then(|| segment.to_owned())
}
fn with_mimetype_extension(name: String, mimetype: Option<&str>) -> String {
if std::path::Path::new(&name).extension().is_some() {
return name;
}
match mimetype.and_then(extension_for_mimetype) {
Some(extension) => format!("{name}.{extension}"),
None => name,
}
}
fn extension_for_mimetype(mimetype: &str) -> Option<&'static str> {
let mimetype = mimetype
.split(';')
.next()
.unwrap_or(mimetype)
.trim()
.to_ascii_lowercase();
match mimetype.as_str() {
"application/pdf" => Some("pdf"),
"application/epub+zip" => Some("epub"),
"application/zip" => Some("zip"),
"application/gzip" | "application/x-gzip" => Some("gz"),
"application/x-tar" => Some("tar"),
"application/json" => Some("json"),
"image/jpeg" | "image/jpg" => Some("jpg"),
"image/png" => Some("png"),
"image/gif" => Some("gif"),
"image/webp" => Some("webp"),
"image/svg+xml" => Some("svg"),
"audio/mpeg" => Some("mp3"),
"audio/ogg" => Some("ogg"),
"video/mp4" => Some("mp4"),
"video/webm" => Some("webm"),
"text/plain" => Some("txt"),
_ => None,
}
}
fn dedup_keys(result: &FileResult) -> Vec<String> {
let mut keys = Vec::new();
if let Some(hashes) = &result.hashes {
for algorithm in ["sha256", "sha1", "infohash", "md5", "cid"] {
if let Some(value) = hashes.get(algorithm) {
keys.push(format!("{algorithm}:{value}"));
}
}
}
if keys.is_empty() {
if let (Some(title), Some(size)) = (&result.title, result.size) {
keys.push(format!("name:{}:{size}", normalize(title)));
}
}
keys
}
fn normalize(title: &str) -> String {
title
.trim()
.to_lowercase()
.split_whitespace()
.collect::<Vec<_>>()
.join(" ")
}
fn absorb(cluster: &mut MergedResult, result: FileResult) {
if cluster.title.is_none() {
cluster.title = result.title;
}
if cluster.size.is_none() {
cluster.size = result.size;
}
if cluster.mimetype.is_none() {
cluster.mimetype = result.mimetype;
}
if cluster.lang.is_none() {
cluster.lang = result.lang;
}
if cluster.published.is_none() {
cluster.published = result.published;
}
if cluster.last_seen.is_none() {
cluster.last_seen = result.last_seen;
}
if let Some(hashes) = result.hashes {
for (algorithm, value) in hashes {
cluster.hashes.entry(algorithm).or_insert(value);
}
}
if !cluster.providers.contains(&result.provider) {
cluster.providers.push(result.provider);
}
for address in result.addresses {
if !cluster
.addresses
.iter()
.any(|existing| existing.uri == address.uri)
{
cluster.addresses.push(address);
}
}
}
fn score(cluster: &MergedResult, weights: &HashMap<String, f64>) -> f64 {
let mut score: f64 = cluster
.providers
.iter()
.map(|provider| weights.get(provider).copied().unwrap_or(1.0))
.sum();
if !cluster.hashes.is_empty() {
score += 0.5;
}
if cluster.mimetype.is_some() {
score += 0.25;
}
if cluster.size.is_some() {
score += 0.25;
}
if cluster.published.is_some() {
score += 0.1;
}
score
}