use crate::structs::*;
use lazy_static::lazy_static;
use regex::Regex;
use slug::slugify;
use sqlx::{sqlite::Sqlite, Acquire, Done, Executor, Transaction};
use std::collections::HashSet;
use std::cmp;

type SqlResult<T> = sqlx::Result<T>;

//  ___     _          _
// | _ \_ _(_)_ ____ _| |_ ___
// |  _/ '_| \ 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.

lazy_static! {
	static ref SELECT_PAGE_BY_TITLE_SQL: String = str::replace(
		include_str!("sql/select_notes_by_parameter.sql"),
		"QUERYPARAMETER",
		"notes.content"
	);
}

lazy_static! {
	static ref SELECT_PAGE_BY_ID_SQL: String = str::replace(
		include_str!("sql/select_notes_by_parameter.sql"),
		"QUERYPARAMETER",
		"notes.id"
	);
}


lazy_static! {
	static ref SELECT_NOTES_BACKREFERENCING_PAGE_SQL: &'static str =
		include_str!("sql/select_notes_backreferencing_page.sql");
}

//  ___             _
// | _ \___ ___ ___| |_
// |   / -_|_-</ -_)  _|
// |_|_\___/__/\___|\__|
//

pub(crate) 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(|_| ())
}

//  ___    _      _      _  __        _
// | __|__| |_ __| |_   | |/ /__ _ __| |_ ___ _ _
// | _/ -_)  _/ _| ' \  | ' </ _` (_-<  _/ -_) ' \
// |_|\___|\__\__|_||_| |_|\_\__,_/__/\__\___|_||_|
//

// The next three functions are essentially the same, although the internal
// SQL operations are quite different between the first two and the last.
async fn select_object_by_query<'a, E>(executor: E, query: &str, field: &str) -> SqlResult<Vec<Note>>
where
	E: Executor<'a, Database = Sqlite>,
{
	let r: Vec<RowNote> = sqlx::query_as(query)
		.bind(field)
		.fetch_all(executor)
		.await?;
	Ok(r.into_iter().map(|z| Note::from(z)).collect())
}


// Select the requested page via its id.  This is fairly rare;
// pages should usually be picked up via their title, but if you're
// navigating to an instance, this is how you specify the page in a
// URL.  The return value is an array of Note objects; it is the
// responsibility of client code to restructure these into a tree-like
// object.
//
// Recommended: Clients should update the URL whenever changing
// page.
pub(crate) async fn select_page_by_slug<'a, E>(executor: E, slug: &str) -> SqlResult<Vec<Note>>
where
	E: Executor<'a, Database = Sqlite>,
{
	select_object_by_query(executor, &SELECT_PAGE_BY_ID_SQL, &slug).await
}

// Fetch the page by title.  The return value is an array of Note
// objects; it is the responsibility of client code to restructure
// these into a tree-like object.
pub(crate) async fn select_page_by_title<'a, E>(executor: E, title: &str) -> SqlResult<Vec<Note>>
where
	E: Executor<'a, Database = Sqlite>,
{
	select_object_by_query(executor, &SELECT_PAGE_BY_TITLE_SQL, &title).await
}

// Fetch all backreferences to a page.  The return value is an array
// of arrays, and inside each array is a list from a root page to
// the note that references the give page.  Clients may choose how
// they want to display that collection.
pub(crate) async fn select_backreferences_for_page<'a, E>(
	executor: E,
	page_id: &str,
) -> SqlResult<Vec<Note>>
where
	E: Executor<'a, Database = Sqlite>,
{
	select_object_by_query(executor, &SELECT_NOTES_BACKREFERENCING_PAGE_SQL, &page_id).await
}

//  ___                  _      ___             _  _     _
// |_ _|_ _  ___ ___ _ _| |_   / _ \ _ _  ___  | \| |___| |_ ___
//  | || ' \(_-</ -_) '_|  _| | (_) | ' \/ -_) | .` / _ \  _/ -_)
// |___|_||_/__/\___|_|  \__|  \___/|_||_\___| |_|\_\___/\__\___|
//

// Inserts a single note into the notes table.  That is all.
pub(crate) async fn insert_note<'a, E>(executor: E, note: &NewNote) -> SqlResult<String>
where
	E: Executor<'a, Database = Sqlite>,
{
	let insert_one_note_sql = concat!(
		"INSERT INTO notes (id, content, kind, ",
		"                   creation_date, updated_date, lastview_date) ",
		"VALUES (?, ?, ?, ?, ?, ?);"
	);

	let _ = sqlx::query(insert_one_note_sql)
		.bind(&note.id)
		.bind(&note.content)
		.bind(note.kind.to_string())
		.bind(&note.creation_date)
		.bind(&note.updated_date)
		.bind(&note.lastview_date)
		.execute(executor)
		.await?;
	Ok(note.id.clone())
}

// Inserts a single note into the notes table.  That is all.
pub(crate) async fn bulk_insert_notes<'a, E>(executor: E, notes: &[NewNote]) -> SqlResult<()>
where
	E: Executor<'a, Database = Sqlite>,
{
	if notes.is_empty() {
		return Ok(());
	}
	
	let insert_pattern = "VALUES (?, ?, ?, ?, ?, ?)".to_string();
	let insert_bulk_notes_sql = 
		"INSERT INTO notes (id, content, kind, creation_date, updated_date, lastview_date) ".to_string()
		+ &[insert_pattern.as_str()]
		.repeat(notes.len())
		.join(", ") + &";".to_string();

	let mut request = sqlx::query(&insert_bulk_notes_sql);
	for note in notes {
		request = request
			.bind(&note.id)
			.bind(&note.content)
			.bind(note.kind.to_string())
			.bind(&note.creation_date)
			.bind(&note.updated_date)
			.bind(&note.lastview_date);
	}
	request.execute(executor).await.map(|_| ())
}

//  ___      _ _    _   _  __        _
// | _ )_  _(_) |__| | | |/ /__ _ __| |_ ___ _ _
// | _ \ || | | / _` | | ' </ _` (_-<  _/ -_) ' \
// |___/\_,_|_|_\__,_| |_|\_\__,_/__/\__\___|_||_|
//

// Given a possible slug, find the slug with the highest
// uniquification number, and return that number, if any.
pub(crate) fn find_maximal_slug_number(slugs: &[JustId]) -> 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.id))
		.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.  Right now we're using the slugify operation, which...
// isn't all that.
pub(crate) 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();
		static ref SLUG_FINDER_SQL: String = format!(
			"SELECT id FROM notes WHERE kind = '{}' AND id LIKE '?%';",
			NoteKind::Page.to_string()
		);
	}

	let initial_slug = slugify(title);
	let sample_slug = RE_STRIP_NUM.replace_all(&initial_slug, "");
	let similar_slugs: Vec<JustId> = sqlx::query_as(&SLUG_FINDER_SQL)
		.bind(&*sample_slug)
		.fetch_all(executor)
		.await?;
	let maximal_slug_number = find_maximal_slug_number(&similar_slugs);
	Ok(match maximal_slug_number {
		None => initial_slug,
		Some(slug_number) => format!("{}-{}", initial_slug, slug_number + 1),
	})
}

// A helper function: given a title and a slug, create a PageType
// note.
pub(crate) fn create_page(title: &str, slug: &str) -> NewNote {
	NewNoteBuilder::default()
		.id(slug.to_string())
		.content(title.to_string())
		.kind(NoteKind::Page)
		.build()
		.unwrap()
}

//  _   _          _      _          ___             _  _     _
// | | | |_ __  __| |__ _| |_ ___   / _ \ _ _  ___  | \| |___| |_ ___
// | |_| | '_ \/ _` / _` |  _/ -_) | (_) | ' \/ -_) | .` / _ \  _/ -_)
//  \___/| .__/\__,_\__,_|\__\___|  \___/|_||_\___| |_|\_\___/\__\___|
//       |_|

pub(crate) 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),
	}
}

//  ___    _      _       ___             _  _     _         ___     _      _   _             _    _
// | __|__| |_ __| |_    / _ \ _ _  ___  | \| |___| |_ ___  | _ \___| |__ _| |_(_)___ _ _  __| |_ (_)_ __
// | _/ -_)  _/ _| ' \  | (_) | ' \/ -_) | .` / _ \  _/ -_) |   / -_) / _` |  _| / _ \ ' \(_-< ' \| | '_ \
// |_|\___|\__\__|_||_|  \___/|_||_\___| |_|\_\___/\__\___| |_|_\___|_\__,_|\__|_\___/_||_/__/_||_|_| .__/
//                                                                                                  |_|

pub(crate) async fn select_note_to_note_relationship<'a, E>(
	executor: E,
	parent_id: &str,
	note_id: &str,
) -> SqlResult<NoteRelationship>
where
	E: Executor<'a, Database = Sqlite>,
{
	let get_note_to_note_relationship_sql = concat!(
		"SELECT parent_id, note_id, location, kind ",
		"FROM note_relationships ",
		"WHERE parent_id = ? and note_id = ? ",
		"LIMIT 1"
	);
	let s: NoteRelationshipRow = sqlx::query_as(get_note_to_note_relationship_sql)
		.bind(parent_id)
		.bind(note_id)
		.fetch_one(executor)
		.await?;
	Ok(NoteRelationship::from(s))
}

//  _  _     _         _         _  _     _         ___     _      _   _             _    _
// | \| |___| |_ ___  | |_ ___  | \| |___| |_ ___  | _ \___| |__ _| |_(_)___ _ _  __| |_ (_)_ __ ___
// | .` / _ \  _/ -_) |  _/ _ \ | .` / _ \  _/ -_) |   / -_) / _` |  _| / _ \ ' \(_-< ' \| | '_ (_-<
// |_|\_\___/\__\___|  \__\___/ |_|\_\___/\__\___| |_|_\___|_\__,_|\__|_\___/_||_/__/_||_|_| .__/__/
//                                                                                         |_|

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

	let _ = sqlx::query(insert_note_to_note_relationship_sql)
		.bind(parent_id)
		.bind(note_id)
		.bind(&location)
		.bind(kind.to_string())
		.execute(executor)
		.await?;
	Ok(())
}

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

	let _ = sqlx::query(make_room_for_new_note_sql)
		.bind(&location)
		.bind(parent_id)
		.execute(executor)
		.await?;
	Ok(())
}

pub(crate) async fn determine_max_child_location_for_note<'a, E>(
	executor: E,
	note_id: &str,
	comp_loc: Option<i64>,
) -> SqlResult<i64>
where
	E: Executor<'a, Database = Sqlite>,
{
	let row_count = assert_max_child_location_for_note(executor, note_id).await? + 1;
	Ok(match comp_loc {
		Some(location) => cmp::min(row_count, location),
		None => row_count
	})
}

pub(crate) async fn assert_max_child_location_for_note<'a, E>(
	executor: E,
	note_id: &str,
) -> SqlResult<i64>
where
	E: Executor<'a, Database = Sqlite>,
{
	let assert_max_child_location_for_note_sql =
		"SELECT MAX(location) AS count FROM note_relationships WHERE parent_id = ?;";

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

	Ok(count.count)
}

//  _  _     _         _         _  __        _              ___     _      _   _             _    _
// | \| |___| |_ ___  | |_ ___  | |/ /__ _ __| |_ ___ _ _   | _ \___| |__ _| |_(_)___ _ _  __| |_ (_)_ __ ___
// | .` / _ \  _/ -_) |  _/ _ \ | ' </ _` (_-<  _/ -_) ' \  |   / -_) / _` |  _| / _ \ ' \(_-< ' \| | '_ (_-<
// |_|\_\___/\__\___|  \__\___/ |_|\_\__,_/__/\__\___|_||_| |_|_\___|_\__,_|\__|_\___/_||_/__/_||_|_| .__/__/
//                                                                                                  |_|

pub(crate) async fn insert_bulk_note_to_page_relationships<'a, E>(
	executor: E,
	note_id: &str,
	references: &[String],
) -> SqlResult<()>
where
	E: Executor<'a, Database = Sqlite>,
{
	if references.is_empty() {
		return Ok(());
	}

	let insert_pattern = format!("(?, ?, '{}')", PageRelationshipKind::Page.to_string());
	let insert_note_page_references_sql =
		"INSERT INTO note_page_relationships (note_id, page_id, kind) VALUES ".to_string()
			+ &[insert_pattern.as_str()]
				.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(|_| ())
}

pub(crate) async fn delete_bulk_note_to_page_relationships<'a, E>(
	executor: E,
	note_id: &str,
) -> SqlResult<()>
where
	E: Executor<'a, Database = Sqlite>,
{
	let delete_note_to_page_relationship_sql =
		"DELETE FROM note_page_relationships WHERE and note_id = ?;";
	let _ = sqlx::query(delete_note_to_page_relationship_sql)
		.bind(note_id)
		.execute(executor)
		.await?;
	Ok(())
}

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

//   ___         _           _     _         _  __        _              ___     _      _   _             _    _
//  / __|___ _ _| |_ ___ _ _| |_  | |_ ___  | |/ /__ _ __| |_ ___ _ _   | _ \___| |__ _| |_(_)___ _ _  __| |_ (_)_ __ ___
// | (__/ _ \ ' \  _/ -_) ' \  _| |  _/ _ \ | ' </ _` (_-<  _/ -_) ' \  |   / -_) / _` |  _| / _ \ ' \(_-< ' \| | '_ (_-<
//  \___\___/_||_\__\___|_||_\__|  \__\___/ |_|\_\__,_/__/\__\___|_||_| |_|_\___|_\__,_|\__|_\___/_||_/__/_||_|_| .__/__/
//                                                                                                              |_|

// Returns all the (Id, title) pairs found in the database out of a
// list of titles.  Used by insert_note and update_note_content to
// find the ids of all the references in a given document.
pub(crate) async fn find_all_page_from_list_of_references<'a, E>(
	executor: E,
	references: &[String],
) -> SqlResult<Vec<PageTitle>>
where
	E: Executor<'a, Database = Sqlite>,
{
	if references.is_empty() {
		return Ok(vec![]);
	}

	lazy_static! {
		static ref SELECT_ALL_REFERENCES_FOR_SQL_BASE: String = format!(
			"SELECT id, content FROM notes WHERE kind = '{}' AND content IN (",
			NoteKind::Page.to_string()
		);
	}

	let find_all_references_for_sql = SELECT_ALL_REFERENCES_FOR_SQL_BASE.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
}

//  ___      _     _
// |   \ ___| |___| |_ ___
// | |) / -_) / -_)  _/ -_)
// |___/\___|_\___|\__\___|
//

pub(crate) async fn delete_note_to_note_relationship<'a, E>(
	executor: E,
	parent_id: &str,
	note_id: &str,
) -> 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),
	}
}

pub(crate) async fn delete_note_to_page_relationships<'a, E>(
	executor: E,
	note_id: &str,
) -> SqlResult<()>
where
	E: Executor<'a, Database = Sqlite>,
{
	lazy_static! {
		static ref DELETE_NOTE_TO_PAGE_RELATIONSHIPS_SQL: String = format!(
			"DELETE FROM note_relationships WHERE kind in ('{}', '{}') AND parent_id = ?;",
			PageRelationshipKind::Page.to_string(),
			PageRelationshipKind::Unacked.to_string()
		);
	}

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

pub(crate) async fn delete_note<'a, E>(executor: E, note_id: &str) -> SqlResult<()>
where
	E: Executor<'a, Database = Sqlite>,
{
	let delete_note_sql = "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),
	}
}

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

	let _ = sqlx::query(close_hole_for_deleted_note_sql)
		.bind(&location)
		.bind(parent_id)
		.execute(executor)
		.await?;
	Ok(())
}


// Given a list of references found in the content, generate the
// references that do not previously exist, returning all found
// references.  NOTE: The function signature for this is for a
// transaction, and uses a nested transaction.
pub(crate) async fn validate_or_generate_all_found_references(
	txi: &mut Transaction<'_, Sqlite>,
	references: &[String]
) -> SqlResult<Vec<String>> {
	let mut tx = txi.begin().await?;
	
	let found_references =
		find_all_page_from_list_of_references(&mut tx, &references).await?;
	let new_references = diff_references(&references, &found_references);
	let mut new_page: Vec<NewNote> = vec![];
	for one_reference in new_references.iter() {
		let slug = generate_slug(&mut tx, one_reference).await?;
		new_page.push(create_page(&one_reference, &slug));
	}
	let _ = bulk_insert_notes(&mut tx, &new_page).await?;

	let mut all_reference_ids: Vec<String> = found_references.iter().map(|r| r.id.clone()).collect();
	all_reference_ids.append(&mut new_page.iter().map(|r| r.id.clone()).collect());
	tx.commit().await?;
	Ok(all_reference_ids)
}

//  __  __ _
// |  \/  (_)___ __
// | |\/| | (_-</ _|
// |_|  |_|_/__/\__|
//

// The dreaded miscellaneous!

pub(crate) async fn count_existing_note_relationships<'a, E>(executor: E, note_id: &str) -> SqlResult<i64>
where
	E: Executor<'a, Database = Sqlite>,
{
	let count_existing_note_relationships_sql =
		"SELECT COUNT(*) as count FROM note_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)
}