use super::{with_timeout, SmartSearchEngine, GATE_BAIDU, GATE_BING, GATE_SOGOU};
use crate::domain::models::search_result::SearchResult;
use crate::search::dedup::ResultDeduplicator;
use crate::search::engine_trait::{SearchEngine, SearchRequest};
use crate::search::error::SearchError;
use crate::search::response::{Response, ResponseItem};
use crate::search::types::SearchEngineType;
use log::{info, warn};
pub(super) type EngineSearchResult = Result<Response<ResponseItem>, SearchError>;
impl SmartSearchEngine {
pub(super) async fn fan_out_engines(
&self,
base_request: &SearchRequest,
) -> (
EngineSearchResult,
EngineSearchResult,
EngineSearchResult,
Option<EngineSearchResult>,
) {
macro_rules! engine_with_timeout {
($gate:expr, $fut:expr) => {{
self.gates[$gate].wait_turn().await;
with_timeout(self.engine_timeout, $fut).await
}};
}
let extra_future = async {
match &self.extra_engine {
Some(engine) => {
Some(with_timeout(self.engine_timeout, engine.search(base_request)).await)
}
None => None,
}
};
tokio::join!(
async { engine_with_timeout!(GATE_BING, self.bing_engine.search(base_request)) },
async { engine_with_timeout!(GATE_BAIDU, self.baidu_engine.search(base_request)) },
async { engine_with_timeout!(GATE_SOGOU, self.sogou_engine.search(base_request)) },
extra_future,
)
}
}
pub(super) fn collect_named_results(label: &str, result: EngineSearchResult) -> Vec<SearchResult> {
match result {
Ok(response) => {
info!("{} returned {} results", label, response.items.len());
response
.items
.iter()
.map(SmartSearchEngine::item_to_search_result)
.collect()
}
Err(e) => {
warn!("{} search failed: {}", label, e);
Vec::new()
}
}
}
pub(super) fn collect_extra_results(
engine: &SmartSearchEngine,
extra_result: Option<EngineSearchResult>,
) -> Vec<SearchResult> {
let Some(result) = extra_result else {
return Vec::new();
};
let label = engine
.extra_engine
.as_ref()
.map(|e| e.name())
.unwrap_or("extra engine");
match result {
Ok(response) => {
info!("{} returned {} results", label, response.items.len());
response
.items
.iter()
.map(SmartSearchEngine::item_to_search_result)
.collect()
}
Err(e) => {
warn!("{} search failed: {}", label, e);
Vec::new()
}
}
}
pub(super) fn dedup_engine_results(
deduplicator: &mut ResultDeduplicator,
results: Vec<SearchResult>,
) -> Vec<SearchResult> {
let deduped = deduplicator.deduplicate(results);
deduplicator.reset();
deduped
}
pub(super) fn to_response_items(fused: Vec<SearchResult>) -> Vec<ResponseItem> {
fused
.into_iter()
.map(|r| {
let engine_type =
SearchEngineType::from_name(&r.engine).unwrap_or(SearchEngineType::Smart);
ResponseItem {
title: r.title,
url: r.url,
description: r.description.unwrap_or_default(),
engine: engine_type,
}
})
.collect()
}