use std::collections::HashMap;
use ankit::{AnkiClient, NoteBuilder};
use crate::error::{Error, Result};
use crate::schema::DeckDefinition;
pub struct ConnectImporter {
definition: DeckDefinition,
client: AnkiClient,
}
#[derive(Debug, Clone)]
pub struct ImportResult {
pub decks_created: usize,
pub notes_created: usize,
pub notes_skipped: usize,
pub errors: HashMap<usize, String>,
}
impl ConnectImporter {
pub fn new(definition: DeckDefinition) -> Self {
Self {
definition,
client: AnkiClient::new(),
}
}
pub fn with_client(definition: DeckDefinition, client: AnkiClient) -> Self {
Self { definition, client }
}
pub async fn import(&self) -> Result<ImportResult> {
let mut result = ImportResult {
decks_created: 0,
notes_created: 0,
notes_skipped: 0,
errors: HashMap::new(),
};
let existing_decks = self.client.decks().names().await?;
for deck in &self.definition.decks {
if !existing_decks.contains(&deck.name) {
self.client.decks().create(&deck.name).await?;
result.decks_created += 1;
}
}
let existing_models = self.client.models().names().await?;
for model in &self.definition.models {
if !existing_models.contains(&model.name) {
return Err(Error::ModelNotFound(format!(
"Model '{}' does not exist in Anki. Create it manually first.",
model.name
)));
}
}
for (i, note_def) in self.definition.notes.iter().enumerate() {
let mut builder = NoteBuilder::new(¬e_def.deck, ¬e_def.model);
let markdown_fields = self
.definition
.get_model(¬e_def.model)
.map(|m| m.markdown_fields.clone())
.unwrap_or_default();
let fields = note_def.fields_as_html(&markdown_fields);
for (field, value) in &fields {
builder = builder.field(field, value);
}
for tag in ¬e_def.tags {
builder = builder.tag(tag);
}
let note = builder.build();
match self.client.notes().add(note).await {
Ok(_) => {
result.notes_created += 1;
}
Err(e) => {
result.notes_skipped += 1;
result.errors.insert(i, e.to_string());
}
}
}
Ok(result)
}
pub async fn import_batch(&self) -> Result<ImportResult> {
let mut result = ImportResult {
decks_created: 0,
notes_created: 0,
notes_skipped: 0,
errors: HashMap::new(),
};
let existing_decks = self.client.decks().names().await?;
for deck in &self.definition.decks {
if !existing_decks.contains(&deck.name) {
self.client.decks().create(&deck.name).await?;
result.decks_created += 1;
}
}
let existing_models = self.client.models().names().await?;
for model in &self.definition.models {
if !existing_models.contains(&model.name) {
return Err(Error::ModelNotFound(format!(
"Model '{}' does not exist in Anki. Create it manually first.",
model.name
)));
}
}
let notes: Vec<_> = self
.definition
.notes
.iter()
.map(|note_def| {
let mut builder = NoteBuilder::new(¬e_def.deck, ¬e_def.model);
let markdown_fields = self
.definition
.get_model(¬e_def.model)
.map(|m| m.markdown_fields.clone())
.unwrap_or_default();
let fields = note_def.fields_as_html(&markdown_fields);
for (field, value) in &fields {
builder = builder.field(field, value);
}
for tag in ¬e_def.tags {
builder = builder.tag(tag);
}
builder.build()
})
.collect();
let results = self.client.notes().add_many(¬es).await?;
for (i, note_result) in results.iter().enumerate() {
match note_result {
Some(_) => result.notes_created += 1,
None => {
result.notes_skipped += 1;
result.errors.insert(i, "Failed to add note".to_string());
}
}
}
Ok(result)
}
pub async fn validate_models(&self) -> Result<Vec<String>> {
let existing_models = self.client.models().names().await?;
let missing: Vec<String> = self
.definition
.models
.iter()
.filter(|m| !existing_models.contains(&m.name))
.map(|m| m.name.clone())
.collect();
Ok(missing)
}
pub async fn validate_decks(&self) -> Result<Vec<String>> {
let existing_decks = self.client.decks().names().await?;
let missing: Vec<String> = self
.definition
.decks
.iter()
.filter(|d| !existing_decks.contains(&d.name))
.map(|d| d.name.clone())
.collect();
Ok(missing)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_import_result_default() {
let result = ImportResult {
decks_created: 0,
notes_created: 0,
notes_skipped: 0,
errors: HashMap::new(),
};
assert_eq!(result.decks_created, 0);
}
}