use std::collections::HashMap;
use anyhow::Result;
use chrono::{DateTime, Utc};
use rusqlite::{OptionalExtension, Transaction, params_from_iter};
use uuid::Uuid;
use super::SqliteStore;
use crate::schema::{Memory, Relation, RelationType, Tier};
const MAX_CHAIN: usize = 64;
#[derive(Debug, Clone)]
pub struct Corrected {
pub memory: Memory,
pub replayed: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CorrectRefusal {
NotFound,
Retired,
AlreadyCorrected {
current: Uuid,
},
IdTaken,
}
impl SqliteStore {
pub fn correct_memory(
&self,
old_id: Uuid,
mut replacement: Memory,
evidence: &str,
) -> Result<Result<Corrected, CorrectRefusal>> {
self.with_txn(|tx| {
let Some(old) = Self::memory_on_tx(tx, old_id)? else {
return Ok(Err(CorrectRefusal::NotFound));
};
if old.superseded_by == Some(replacement.id) {
let memory = Self::memory_on_tx(tx, replacement.id)?.unwrap_or(replacement);
return Ok(Ok(Corrected {
memory,
replayed: true,
}));
}
if let Some(by) = old.superseded_by {
return Ok(Err(CorrectRefusal::AlreadyCorrected {
current: Self::current_replacement(tx, by)?,
}));
}
if old.tier == Tier::Archived {
return Ok(Err(CorrectRefusal::Retired));
}
if Self::memory_on_tx(tx, replacement.id)?.is_some()
|| Self::tombstoned(tx, replacement.id)?
{
return Ok(Err(CorrectRefusal::IdTaken));
}
replacement.project_path = old.project_path.clone();
self.store_memory_on_tx(tx, &replacement)?;
self.supersede_on_tx(tx, old_id, replacement.id)?;
self.store_relation_on_tx(
tx,
&Relation {
from_id: replacement.id,
to_id: old_id,
relation_type: RelationType::Supersedes,
strength: 1.0,
context: Some(evidence.to_string()),
},
)?;
Ok(Ok(Corrected {
memory: replacement,
replayed: false,
}))
})
}
pub fn corrected_at(&self, ids: &[Uuid]) -> Result<HashMap<Uuid, DateTime<Utc>>> {
if ids.is_empty() {
return Ok(HashMap::new());
}
let marks = vec!["?"; ids.len()].join(",");
let conn = self.reader();
let mut stmt = conn.prepare(&format!(
"SELECT DISTINCT m.id, m.created_at FROM relations r \
JOIN memories m ON m.id = r.from_id \
WHERE r.relation_type = 'supersedes' AND r.from_id IN ({marks})"
))?;
let rows = stmt.query_map(params_from_iter(ids.iter().map(Uuid::to_string)), |r| {
Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?))
})?;
let mut out = HashMap::new();
for row in rows {
let (id, at) = row?;
if let (Ok(id), Ok(at)) = (Uuid::parse_str(&id), DateTime::parse_from_rfc3339(&at)) {
out.insert(id, at.with_timezone(&Utc));
}
}
Ok(out)
}
pub fn correction_evidence(&self, replacement: Uuid) -> Result<Option<String>> {
let conn = self.reader();
let context: Option<Option<String>> = conn
.query_row(
"SELECT context FROM relations WHERE from_id = ?1 AND relation_type = 'supersedes'",
[replacement.to_string()],
|r| r.get(0),
)
.optional()?;
Ok(context.flatten())
}
fn current_replacement(tx: &Transaction<'_>, mut id: Uuid) -> Result<Uuid> {
for _ in 0..MAX_CHAIN {
match Self::memory_on_tx(tx, id)?.and_then(|m| m.superseded_by) {
Some(next) => id = next,
None => break,
}
}
Ok(id)
}
}