use crate::errors::NoteStoreError;
use crate::reference_parser::build_references;
use crate::structs::{
    JustId, JustSlugs, NewNote, NewNoteBuilder, NewPage, NewPageBuilder, NoteRelationship, PageTitles, RawNote,
    RawPage, RowCount,
};
use lazy_static::lazy_static;
use regex::Regex;
use shrinkwraprs::Shrinkwrap;
use slug::slugify;
use sqlx::{
    sqlite::{Sqlite, SqlitePool, SqliteRow},
    Done, Executor, Row,
};
use std::collections::HashMap;
use std::collections::HashSet;
use std::sync::Arc;

#[derive(Shrinkwrap, Copy, Clone)]
struct PageId(i64);

#[derive(Shrinkwrap, Copy, Clone)]
struct NoteId(i64);

#[derive(Shrinkwrap, Copy, Clone)]
struct ParentId(i64);

/// A handle to our Sqlite database.
#[derive(Clone, Debug)]
pub struct NoteStore(Arc<SqlitePool>);

type NoteResult<T> = core::result::Result<T, NoteStoreError>;
type SqlResult<T> = sqlx::Result<T>;

impl NoteStore {
    pub async fn new(url: &str) -> NoteResult<Self> {
        let pool = SqlitePool::connect(url).await?;
        Ok(NoteStore(Arc::new(pool)))
    }

    // Erase all the data in the database and restore it
    // to its original empty form.  Do not use unless you
    // really, really want that to happen.
    pub async fn reset_database(&self) -> NoteResult<()> {
        reset_database(&*self.0).await.map_err(NoteStoreError::DBError)
    }

    /// Fetch page by slug
    ///
    /// Supports the use case of the user navigating to a known place
    /// via a bookmark or other URL.  Since the title isn't clear from
    /// the slug, the slug is insufficient to generate a new page, so
    /// this use case says that in the event of a failure to find the
    /// requested page, return a basic NotFound.
    pub async fn get_page_by_slug(&self, slug: &str) -> NoteResult<(RawPage, Vec<RawNote>)> {
        //		let select_note_collection_for_root = include_str!("sql/select_note_collection_for_root.sql");
        let mut tx = self.0.begin().await?;
        let page = select_page_by_slug(&mut tx, slug).await?;
        let note_id = page.note_id;
        let notes = select_note_collection_from_root(&mut tx, note_id).await?;
        tx.commit().await?;
        Ok((page, notes))
    }

    /// Fetch page by title
    ///
    /// Supports the use case of the user navigating to a page via
    /// the page's formal title.  Since the title is the key reference
    /// of the system, if no page with that title is found, a page with
    /// that title is generated automatically.
    pub async fn get_page_by_title(&self, title: &str) -> NoteResult<(RawPage, Vec<RawNote>)> {
        let mut tx = self.0.begin().await?;
        let (page, notes) = match select_page_by_title(&mut tx, title).await {
            Ok(page) => {
                let note_id = page.note_id;
                (page, select_note_collection_from_root(&mut tx, note_id).await?)
            }
            Err(sqlx::Error::RowNotFound) => {
                let page = {
                    let new_root_note = create_unique_root_note();
                    let new_root_note_id = insert_one_new_note(&mut tx, &new_root_note).await?;
                    let new_page_slug = generate_slug(&mut tx, title).await?;
                    let new_page = create_new_page_for(&title, &new_page_slug, new_root_note_id);
                    let _ = insert_one_new_page(&mut tx, &new_page).await?;
                    select_page_by_title(&mut tx, &title).await?
                };
                let note_id = page.note_id;
                (page, select_note_collection_from_root(&mut tx, note_id).await?)
            }
            Err(e) => return Err(NoteStoreError::DBError(e)),
        };
        tx.commit().await?;
        Ok((page, notes))
    }

    // TODO: Make sure the position is sane.
    /// Insert a note as the child of an existing note, at a set position.
    pub async fn insert_nested_note(
        &self,
        note: &NewNote,
        parent_note_uuid: &str,
        position: i64,
    ) -> NoteResult<String> {
        let mut new_note = note.clone();
        new_note.uuid = friendly_id::create();
        let references = build_references(&note.content);
        let mut tx = self.0.begin().await?;

        // Start by building the note and putting it into its relationship.
        let parent_id: ParentId = select_note_id_for_uuid(&mut tx, parent_note_uuid).await?;
        let parent_max_position = assert_max_child_position_for_note(&mut tx, parent_id).await?;
        let position = if position > parent_max_position {
            parent_max_position + 1
        } else {
            position
        };
        let new_note_id = insert_one_new_note(&mut tx, &new_note).await?;
        let _ = make_room_for_new_note(&mut tx, parent_id, position).await?;
        let _ = insert_note_to_note_relationship(&mut tx, parent_id, new_note_id, position, "note").await?;

        // From the references, make lists of pages that exist, and pages
        // that do not.
        let found_references = find_all_page_references_for(&mut tx, &references).await?;
        let new_references = diff_references(&references, &found_references);
        let mut known_reference_ids: Vec<PageId> = Vec::new();

        // Create the pages that don't exist
        for one_reference in new_references.iter() {
            let new_root_note = create_unique_root_note();
            let new_root_note_id = insert_one_new_note(&mut tx, &new_root_note).await?;
            let new_page_slug = generate_slug(&mut tx, &one_reference).await?;
            let new_page = create_new_page_for(&one_reference, &new_page_slug, new_root_note_id);
            known_reference_ids.push(insert_one_new_page(&mut tx, &new_page).await?)
        }

        // And associate the note with all the pages.
        known_reference_ids.append(&mut found_references.iter().map(|r| PageId(r.id)).collect());
        let _ = insert_note_to_page_relationships(&mut tx, new_note_id, &known_reference_ids).await?;

        tx.commit().await?;
        Ok(new_note.uuid)
    }

    // This doesn't do anything with the references, as those are
    // dependent entirely on the *content*, and not the *position*, of
    // the note and the referenced page.
    //
    // TODO: Ensure the position is sane.
    /// Move a note from one location to another.
    pub async fn move_note(
        &self,
        note_uuid: &str,
        old_parent_uuid: &str,
        new_parent_uuid: &str,
        new_position: i64,
    ) -> NoteResult<()> {
        let all_uuids = vec![note_uuid, old_parent_uuid, new_parent_uuid];
        let mut tx = self.0.begin().await?;

        // This is one of the few cases where we we're getting IDs for
        // notes, but the nature of the ID isn't known at this time.
        // This has to be handled manually, in the next paragraph
        // below.
        let found_id_vec = bulk_select_ids_for_note_uuids(&mut tx, &all_uuids).await?;
        let found_ids: HashMap<String, i64> = found_id_vec.into_iter().collect();
        if found_ids.len() != 3 {
            return Err(NoteStoreError::NotFound);
        }

        let old_parent_id = ParentId(*found_ids.get(old_parent_uuid).unwrap());
        let new_parent_id = ParentId(*found_ids.get(new_parent_uuid).unwrap());
        let note_id = NoteId(*found_ids.get(note_uuid).unwrap());

        let old_note = get_note_to_note_relationship(&mut tx, old_parent_id, note_id).await?;
        let old_note_position = old_note.position;
        let old_note_nature = &old_note.nature;

        let _ = delete_note_to_note_relationship(&mut tx, old_parent_id, note_id).await?;
        let _ = close_hole_for_deleted_note(&mut tx, old_parent_id, old_note_position).await?;
        let parent_max_position = assert_max_child_position_for_note(&mut tx, new_parent_id).await?;
        let new_position = if new_position > parent_max_position {
            parent_max_position + 1
        } else {
            new_position
        };
        let _ = make_room_for_new_note(&mut tx, new_parent_id, new_position).await?;
        let _ =
            insert_note_to_note_relationship(&mut tx, new_parent_id, note_id, new_position, old_note_nature).await?;
        tx.commit().await?;
        Ok(())
    }

    /// Embed or reference a note from a different location.
    pub async fn reference_or_embed_note(
        &self,
        note_uuid: &str,
        new_parent_uuid: &str,
        new_position: i64,
        new_nature: &str,
    ) -> NoteResult<()> {
        let mut tx = self.0.begin().await?;
        let existing_note_id: NoteId = NoteId(select_note_id_for_uuid(&mut tx, note_uuid).await?.0);
        let new_parent_id: ParentId = select_note_id_for_uuid(&mut tx, new_parent_uuid).await?;
        let _ = make_room_for_new_note(&mut tx, new_parent_id, new_position).await?;
        let _ = insert_note_to_note_relationship(&mut tx, new_parent_id, existing_note_id, new_position, new_nature)
            .await?;
        tx.commit().await?;
        Ok(())
    }

    /// Delete a note
    pub async fn delete_note(&self, note_uuid: &str, note_parent_uuid: &str) -> NoteResult<()> {
        let mut tx = self.0.begin().await?;
        let condemned_note_id: NoteId = NoteId(select_note_id_for_uuid(&mut tx, note_uuid).await?.0);
        let note_parent_id: ParentId = select_note_id_for_uuid(&mut tx, note_parent_uuid).await?;
        let _ = delete_note_to_note_relationship(&mut tx, note_parent_id, condemned_note_id);
        if count_existing_note_relationships(&mut tx, condemned_note_id).await? == 0 {
            let _ = delete_note_to_page_relationships(&mut tx, condemned_note_id).await?;
            let _ = delete_note(&mut tx, condemned_note_id).await?;
        }
        tx.commit().await?;
        Ok(())
    }

    /// Update a note's content
    pub async fn update_note_content(&self, note_uuid: &str, content: &str) -> NoteResult<()> {
        let references = build_references(&content);

        let mut tx = self.0.begin().await?;

        let note_id: NoteId = NoteId(select_note_id_for_uuid(&mut tx, note_uuid).await?.0);
        let _ = update_note_content(&mut tx, note_id, &content).await?;

        let found_references = find_all_page_references_for(&mut tx, &references).await?;
        let new_references = diff_references(&references, &found_references);
        let mut known_reference_ids: Vec<PageId> = Vec::new();

        // Create the pages that don't exist
        for one_reference in new_references.iter() {
            let new_root_note = create_unique_root_note();
            let new_root_note_id = insert_one_new_note(&mut tx, &new_root_note).await?;
            let new_page_slug = generate_slug(&mut tx, &one_reference).await?;
            let new_page = create_new_page_for(&one_reference, &new_page_slug, new_root_note_id);
            known_reference_ids.push(insert_one_new_page(&mut tx, &new_page).await?)
        }

        // And associate the note with all the pages.
        known_reference_ids.append(&mut found_references.iter().map(|r| PageId(r.id)).collect());
        let _ = insert_note_to_page_relationships(&mut tx, note_id, &known_reference_ids).await?;

        tx.commit().await?;
        Ok(())
    }
}
//  ___     _          _
// | _ \_ _(_)_ ____ _| |_ ___
// |  _/ '_| \ V / _` |  _/ -_)
// |_| |_| |_|\_/\__,_|\__\___|
//

// I'm putting a lot of faith in Rust's ability to inline stuff.  I'm
// sure this is okay.  But really, this lets the API be clean and
// coherent and easily readable, and hides away the gnarliness of some
// of the SQL queries.

async fn reset_database<'a, E>(executor: E) -> SqlResult<()>
where
    E: Executor<'a, Database = Sqlite>,
{
    let initialize_sql = include_str!("sql/initialize_database.sql");
    sqlx::query(initialize_sql).execute(executor).await.map(|_| ())
}

async fn select_page_by_slug<'a, E>(executor: E, slug: &str) -> SqlResult<RawPage>
where
    E: Executor<'a, Database = Sqlite>,
{
    let select_one_page_by_slug_sql = concat!(
        "SELECT id, title, slug, note_id, creation_date, updated_date, ",
        "lastview_date, deleted_date FROM pages WHERE slug=?;"
    );
    Ok(sqlx::query_as(&select_one_page_by_slug_sql)
        .bind(&slug)
        .fetch_one(executor)
        .await?)
}

async fn select_page_by_title<'a, E>(executor: E, title: &str) -> SqlResult<RawPage>
where
    E: Executor<'a, Database = Sqlite>,
{
    let select_one_page_by_title_sql = concat!(
        "SELECT id, title, slug, note_id, creation_date, updated_date, ",
        "lastview_date, deleted_date FROM pages WHERE title=?;"
    );
    Ok(sqlx::query_as(&select_one_page_by_title_sql)
        .bind(&title)
        .fetch_one(executor)
        .await?)
}

async fn select_note_id_for_uuid<'a, E>(executor: E, uuid: &str) -> SqlResult<ParentId>
where
    E: Executor<'a, Database = Sqlite>,
{
    let select_note_id_for_uuid_sql = "SELECT id FROM notes WHERE uuid = ?";
    let id: JustId = sqlx::query_as(&select_note_id_for_uuid_sql)
        .bind(&uuid)
        .fetch_one(executor)
        .await?;
    Ok(ParentId(id.id))
}

async fn make_room_for_new_note<'a, E>(executor: E, parent_id: ParentId, position: i64) -> SqlResult<()>
where
    E: Executor<'a, Database = Sqlite>,
{
    let make_room_for_new_note_sql = concat!(
        "UPDATE note_relationships ",
        "SET position = position + 1 ",
        "WHERE position >= ? and parent_id = ?;"
    );

    sqlx::query(make_room_for_new_note_sql)
        .bind(&position)
        .bind(&*parent_id)
        .execute(executor)
        .await
        .map(|_| ())
}

async fn insert_note_to_note_relationship<'a, E>(
    executor: E,
    parent_id: ParentId,
    note_id: NoteId,
    position: i64,
    nature: &str,
) -> SqlResult<()>
where
    E: Executor<'a, Database = Sqlite>,
{
    let insert_note_to_note_relationship_sql = concat!(
        "INSERT INTO note_relationships (parent_id, note_id, position, nature) ",
        "values (?, ?, ?, ?)"
    );

    sqlx::query(insert_note_to_note_relationship_sql)
        .bind(&*parent_id)
        .bind(&*note_id)
        .bind(&position)
        .bind(&nature)
        .execute(executor)
        .await
        .map(|_| ())
}

async fn select_note_collection_from_root<'a, E>(executor: E, root: i64) -> SqlResult<Vec<RawNote>>
where
    E: Executor<'a, Database = Sqlite>,
{
    let select_note_collection_from_root_sql = include_str!("sql/select_note_collection_from_root.sql");
    Ok(sqlx::query_as(&select_note_collection_from_root_sql)
        .bind(&root)
        .fetch_all(executor)
        .await?)
}

async fn insert_one_new_note<'a, E>(executor: E, note: &NewNote) -> SqlResult<NoteId>
where
    E: Executor<'a, Database = Sqlite>,
{
    let insert_one_note_sql = concat!(
        "INSERT INTO notes ( ",
        "	   uuid, ",
        "	   content, ",
        "	   notetype, ",
        "	   creation_date, ",
        "	   updated_date, ",
        "	   lastview_date) ",
        "VALUES (?, ?, ?, ?, ?, ?);"
    );

    Ok(NoteId(
        sqlx::query(insert_one_note_sql)
            .bind(&note.uuid)
            .bind(&note.content)
            .bind(&note.notetype)
            .bind(&note.creation_date)
            .bind(&note.updated_date)
            .bind(&note.lastview_date)
            .execute(executor)
            .await?
            .last_insert_rowid(),
    ))
}

// Given a possible slug, find the slug with the highest
// uniquification number, and return that number, if any.
fn find_maximal_slug(slugs: &[JustSlugs]) -> Option<u32> {
    lazy_static! {
        static ref RE_CAP_NUM: Regex = Regex::new(r"-(\d+)$").unwrap();
    }

    if slugs.is_empty() {
        return None;
    }

    let mut slug_counters: Vec<u32> = slugs
        .iter()
        .filter_map(|slug| RE_CAP_NUM.captures(&slug.slug))
        .map(|cap| cap.get(1).unwrap().as_str().parse::<u32>().unwrap())
        .collect();
    slug_counters.sort_unstable();
    slug_counters.pop()
}

// Given an initial string and an existing collection of slugs,
// generate a new slug that does not conflict with the current
// collection.
async fn generate_slug<'a, E>(executor: E, title: &str) -> SqlResult<String>
where
    E: Executor<'a, Database = Sqlite>,
{
    lazy_static! {
        static ref RE_STRIP_NUM: Regex = Regex::new(r"-\d+$").unwrap();
    }

    let initial_slug = slugify(title);
    let sample_slug = RE_STRIP_NUM.replace_all(&initial_slug, "");
    let slug_finder_sql = "SELECT slug FROM pages WHERE slug LIKE '?%';";
    let similar_slugs: Vec<JustSlugs> = sqlx::query_as(&slug_finder_sql)
        .bind(&*sample_slug)
        .fetch_all(executor)
        .await?;
    let maximal_slug = find_maximal_slug(&similar_slugs);
    match maximal_slug {
        None => Ok(initial_slug),
        Some(max_slug) => Ok(format!("{}-{}", initial_slug, max_slug + 1)),
    }
}

async fn insert_one_new_page<'a, E>(executor: E, page: &NewPage) -> SqlResult<PageId>
where
    E: Executor<'a, Database = Sqlite>,
{
    let insert_one_page_sql = concat!(
        "INSERT INTO pages ( ",
        "	   slug, ",
        "	   title, ",
        "	   note_id, ",
        "	   creation_date, ",
        "	   updated_date, ",
        "	   lastview_date) ",
        "VALUES (?, ?, ?, ?, ?, ?);"
    );

    Ok(PageId(
        sqlx::query(insert_one_page_sql)
            .bind(&page.slug)
            .bind(&page.title)
            .bind(&page.note_id)
            .bind(&page.creation_date)
            .bind(&page.updated_date)
            .bind(&page.lastview_date)
            .execute(executor)
            .await?
            .last_insert_rowid(),
    ))
}

async fn insert_note_to_page_relationships<'a, E>(
    executor: E,
    note_id: NoteId,
    references: &[PageId],
) -> SqlResult<()>
where
    E: Executor<'a, Database = Sqlite>,
{
    let insert_note_page_references_sql = "INSERT INTO page_relationships (note_id, page_id) VALUES ".to_string()
        + &["(?, ?)"].repeat(references.len()).join(", ")
        + &";".to_string();

    let mut request = sqlx::query(&insert_note_page_references_sql);
    for reference in references {
        request = request.bind(*note_id).bind(**reference);
    }

    request.execute(executor).await.map(|_| ())
}

// For a given collection of uuids, retrieve the internal ID used by
// the database.
async fn bulk_select_ids_for_note_uuids<'a, E>(executor: E, ids: &[&str]) -> SqlResult<Vec<(String, i64)>>
where
    E: Executor<'a, Database = Sqlite>,
{
    let bulk_select_ids_for_note_uuids_sql = "SELECT uuid, id FROM notes WHERE uuid IN (".to_string()
        + &["?"].repeat(ids.len()).join(",")
        + &");".to_string();

    let mut request = sqlx::query(&bulk_select_ids_for_note_uuids_sql);
    for id in ids.iter() {
        request = request.bind(id);
    }
    Ok(request
        .try_map(|row: SqliteRow| {
            let l = row.try_get::<String, _>(0)?;
            let r = row.try_get::<i64, _>(1)?;
            Ok((l, r))
        })
        .fetch_all(executor)
        .await?
        .into_iter()
        .collect())
}

// Used by move_note to identify the single note to note relationship
// by the original parent and child pair.  Used mostly to find the
// position for recalculation, to create a new gap or close an old
// one.
async fn get_note_to_note_relationship<'a, E>(
    executor: E,
    parent_id: ParentId,
    note_id: NoteId,
) -> SqlResult<NoteRelationship>
where
    E: Executor<'a, Database = Sqlite>,
{
    let get_note_to_note_relationship_sql = concat!(
        "SELECT parent_id, note_id, position, nature ",
        "FROM note_relationships ",
        "WHERE parent_id = ? and note_id = ? ",
        "LIMIT 1"
    );
    sqlx::query_as(get_note_to_note_relationship_sql)
        .bind(&*parent_id)
        .bind(&*note_id)
        .fetch_one(executor)
        .await
}

async fn delete_note_to_note_relationship<'a, E>(executor: E, parent_id: ParentId, note_id: NoteId) -> SqlResult<()>
where
    E: Executor<'a, Database = Sqlite>,
{
    let delete_note_to_note_relationship_sql = concat!(
        "DELETE FROM note_relationships ",
        "WHERE parent_id = ? and note_id = ? "
    );

    let count = sqlx::query(delete_note_to_note_relationship_sql)
        .bind(&*parent_id)
        .bind(&*note_id)
        .execute(executor)
        .await?
        .rows_affected();

    match count {
        1 => Ok(()),
        _ => Err(sqlx::Error::RowNotFound),
    }
}

async fn delete_note_to_page_relationships<'a, E>(executor: E, note_id: NoteId) -> SqlResult<()>
where
    E: Executor<'a, Database = Sqlite>,
{
    let delete_note_to_page_relationships_sql = concat!("DELETE FROM page_relationships ", "WHERE note_id = ? ");

    let _ = sqlx::query(delete_note_to_page_relationships_sql)
        .bind(&*note_id)
        .execute(executor)
        .await?;
    Ok(())
}

async fn delete_note<'a, E>(executor: E, note_id: NoteId) -> SqlResult<()>
where
    E: Executor<'a, Database = Sqlite>,
{
    let delete_note_sql = concat!("DELETE FROM notes WHERE note_id = ?");

    let count = sqlx::query(delete_note_sql)
        .bind(&*note_id)
        .execute(executor)
        .await?
        .rows_affected();

    match count {
        1 => Ok(()),
        _ => Err(sqlx::Error::RowNotFound),
    }
}

async fn count_existing_note_relationships<'a, E>(executor: E, note_id: NoteId) -> SqlResult<i64>
where
    E: Executor<'a, Database = Sqlite>,
{
    let count_existing_note_relationships_sql = "SELECT COUNT(*) as count FROM page_relationships WHERE note_id = ?";

    let count: RowCount = sqlx::query_as(count_existing_note_relationships_sql)
        .bind(&*note_id)
        .fetch_one(executor)
        .await?;

    Ok(count.count)
}

async fn assert_max_child_position_for_note<'a, E>(executor: E, note_id: ParentId) -> SqlResult<i64>
where
    E: Executor<'a, Database = Sqlite>,
{
    let assert_max_child_position_for_note_sql =
        "SELECT MAX(position) as count FROM note_relationships WHERE parent_id = ?";

    let count: RowCount = sqlx::query_as(assert_max_child_position_for_note_sql)
        .bind(&*note_id)
        .fetch_one(executor)
        .await?;

    Ok(count.count)
}

// After removing a note, recalculate the position of all notes under
// the parent note, such that there order is now completely
// sequential.
async fn close_hole_for_deleted_note<'a, E>(executor: E, parent_id: ParentId, position: i64) -> SqlResult<()>
where
    E: Executor<'a, Database = Sqlite>,
{
    let close_hole_for_deleted_note_sql = concat!(
        "UPDATE note_relationships ",
        "SET position = position - 1 ",
        "WHERE position > ? and parent_id = ?;"
    );

    sqlx::query(close_hole_for_deleted_note_sql)
        .bind(&position)
        .bind(&*parent_id)
        .execute(executor)
        .await
        .map(|_| ())
}

async fn find_all_page_references_for<'a, E>(executor: E, references: &[String]) -> SqlResult<Vec<PageTitles>>
where
    E: Executor<'a, Database = Sqlite>,
{
    let find_all_references_for_sql = "SELECT id, title FROM pages WHERE title IN (".to_string()
        + &["?"].repeat(references.len()).join(",")
        + &");".to_string();

    let mut request = sqlx::query_as(&find_all_references_for_sql);
    for id in references.iter() {
        request = request.bind(id);
    }
    request.fetch_all(executor).await
}

async fn update_note_content<'a, E>(executor: E, note_id: NoteId, content: &str) -> SqlResult<()>
where
    E: Executor<'a, Database = Sqlite>,
{
    let update_note_content_sql = "UPDATE notes SET content = ? WHERE note_id = ?";
    let count = sqlx::query(update_note_content_sql)
        .bind(content)
        .bind(&*note_id)
        .execute(executor)
        .await?
        .rows_affected();

    match count {
        1 => Ok(()),
        _ => Err(sqlx::Error::RowNotFound),
    }
}

fn create_unique_root_note() -> NewNote {
    NewNoteBuilder::default()
        .uuid(friendly_id::create())
        .content("".to_string())
        .notetype("root".to_string())
        .build()
        .unwrap()
}

fn create_new_page_for(title: &str, slug: &str, note_id: NoteId) -> NewPage {
    NewPageBuilder::default()
        .slug(slug.to_string())
        .title(title.to_string())
        .note_id(*note_id)
        .build()
        .unwrap()
}

// Given the references supplied, and the references found in the datastore,
// return a list of the references not found in the datastore.
fn diff_references(references: &[String], found_references: &[PageTitles]) -> Vec<String> {
    let all: HashSet<String> = references.iter().cloned().collect();
    let found: HashSet<String> = found_references.iter().map(|r| r.title.clone()).collect();
    all.difference(&found).cloned().collect()
}