use crate::{Store, StoreError, new_id, now_ms};
use griz_core::{
ChangeKind, Confidence, DiskSource, Edit, FileChange, Op, Plan, Problem, Source, build_plan,
};
use rusqlite::params;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use std::{
collections::{BTreeMap, BTreeSet},
path::{Path, PathBuf},
};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
pub struct FileRecord {
pub path: PathBuf,
pub kind: ChangeKind,
pub before_hash: Option<String>,
pub after_hash: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
pub struct PlanRecord {
pub id: String,
pub purpose: String,
pub selected_from: Option<String>,
pub ops: Vec<Op>,
pub edits: Vec<Edit>,
pub problems: Vec<Problem>,
pub files: Vec<FileRecord>,
pub confidence: Confidence,
pub created_at: i64,
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
pub struct Selection {
#[serde(default)]
pub paths: Vec<PathBuf>,
#[serde(default)]
pub edits: Vec<String>,
pub min_confidence: Option<Confidence>,
}
impl Store {
pub fn save_plan(
&self,
purpose: &str,
ops: Vec<Op>,
plan: Plan,
) -> Result<PlanRecord, StoreError> {
self.store_plan(purpose, ops, plan, None)
}
fn store_plan(
&self,
purpose: &str,
ops: Vec<Op>,
plan: Plan,
selected_from: Option<String>,
) -> Result<PlanRecord, StoreError> {
let files = plan
.files
.iter()
.map(|file| self.file_record(file))
.collect::<Result<_, _>>()?;
let record = PlanRecord {
id: new_id("plan"),
purpose: purpose.to_string(),
selected_from,
confidence: plan.confidence(),
ops,
edits: plan.edits,
problems: plan.problems,
files,
created_at: now_ms(),
};
self.insert_plan(&record)?;
Ok(record)
}
fn file_record(&self, file: &FileChange) -> Result<FileRecord, StoreError> {
if let Some(text) = &file.before {
self.put_blob(text)?;
}
if let Some(text) = &file.after {
self.put_blob(text)?;
}
Ok(FileRecord {
path: file.path.clone(),
kind: file.kind,
before_hash: file.before_hash.clone(),
after_hash: file.after_hash.clone(),
})
}
fn insert_plan(&self, record: &PlanRecord) -> Result<(), StoreError> {
let body = serde_json::to_string(record)?;
self.with(|conn| {
conn.execute(
"INSERT INTO plans (id, created_at, body) VALUES (?1, ?2, ?3)",
params![record.id, record.created_at, body],
)?;
Ok(())
})
}
pub fn plan(&self, id: &str) -> Result<PlanRecord, StoreError> {
let sql = "SELECT body FROM plans WHERE id = ?1";
let body = self.with(|conn| crate::body_by_id(conn, sql, id))?;
let body = body.ok_or_else(|| StoreError::NotFound(format!("plan {id}")))?;
Ok(serde_json::from_str(&body)?)
}
pub fn plan_changes(&self, record: &PlanRecord) -> Result<Vec<FileChange>, StoreError> {
record
.files
.iter()
.map(|file| {
Ok(FileChange {
path: file.path.clone(),
kind: file.kind,
before: self.text(file.before_hash.as_deref())?,
before_hash: file.before_hash.clone(),
after: self.text(file.after_hash.as_deref())?,
after_hash: file.after_hash.clone(),
})
})
.collect()
}
fn text(&self, hash: Option<&str>) -> Result<Option<String>, StoreError> {
hash.map(|hash| self.get_blob(hash)).transpose()
}
pub fn select(
&self,
id: &str,
selection: &Selection,
purpose: &str,
) -> Result<PlanRecord, StoreError> {
let original = self.plan(id)?;
let ops: Vec<Op> = original
.ops
.iter()
.enumerate()
.filter(|(index, op)| keeps(&original, selection, *index, op))
.map(|(_, op)| op.clone())
.collect();
let recorded = self.plan_changes(&original)?;
let source = Recorded {
files: recorded
.into_iter()
.map(|change| (change.path, change.before))
.collect(),
};
let plan = build_plan(&ops, &source);
self.store_plan(purpose, ops, plan, Some(original.id))
}
}
fn keeps(plan: &PlanRecord, selection: &Selection, index: usize, op: &Op) -> bool {
let edits: Vec<&Edit> = plan.edits.iter().filter(|edit| edit.op == index).collect();
let touched: BTreeSet<&Path> = std::iter::once(op.path().as_path())
.chain(edits.iter().map(|edit| edit.path.as_path()))
.collect();
let by_path = selection.paths.is_empty()
|| selection
.paths
.iter()
.any(|path| touched.contains(path.as_path()));
let by_edit =
selection.edits.is_empty() || edits.iter().any(|edit| selection.edits.contains(&edit.id));
let by_confidence = selection
.min_confidence
.is_none_or(|min| edits.iter().all(|edit| edit.confidence >= min));
by_path && by_edit && by_confidence
}
struct Recorded {
files: BTreeMap<PathBuf, Option<String>>,
}
impl Source for Recorded {
fn read(&self, path: &Path) -> Result<Option<String>, String> {
match self.files.get(path) {
Some(text) => Ok(text.clone()),
None => DiskSource.read(path),
}
}
}