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

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_KASTEN_BY_TITLE_SQL: String = str::replace(
        include_str!("sql/select_notes_by_parameter.sql"),
        "QUERYPARAMETER",
        "notes.content"
    );
}

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

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

pub(crate) async fn select_kasten_by_slug<'a, E>(executor: E, slug: &str) -> SqlResult<Vec<Note>>
where
    E: Executor<'a, Database = Sqlite>,
{
    let r: Vec<RowNote> = sqlx::query_as(&SELECT_KASTEN_BY_ID_SQL)
        .bind(&slug)
        .fetch_all(executor)
        .await?;
    Ok(r.into_iter().map(|z| Note::from(z)).collect())
}

pub(crate) async fn select_kasten_by_title<'a, E>(executor: E, title: &str) -> SqlResult<Vec<Note>>
where
    E: Executor<'a, Database = Sqlite>,
{
    let r: Vec<RowNote> = sqlx::query_as(&SELECT_KASTEN_BY_TITLE_SQL)
        .bind(&title)
        .fetch_all(executor)
        .await?;
    Ok(r.into_iter().map(|z| Note::from(z)).collect())
}

pub(crate) async fn select_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, 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<'a, E>(executor: E, zettle: &NewNote) -> SqlResult<String>
where
    E: Executor<'a, Database = Sqlite>,
{
    let insert_one_page_sql = concat!(
        "INSERT INTO notes (id, content, kind, ",
        "                   creation_date, updated_date, lastview_date) ",
        "VALUES (?, ?, ?, ?, ?, ?);"
    );

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

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 make_room_for_new_note<'a, E>(executor: E, parent_id: &ParentId, 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 assert_max_child_location_for_note<'a, E>(executor: E, note_id: &ParentId) -> 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_note_to_note_relationship<'a, E>(
    executor: E,
    parent_id: &ParentId,
    note_id: &NoteId,
    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 insert_bulk_note_to_kasten_relationships<'a, E>(
		executor: E,
		note_id: &NoteId,
		references: &[NoteId],
) -> SqlResult<()>
where
    E: Executor<'a, Database = Sqlite>,
{
    if references.is_empty() {
        return Ok(());
    }

	let insert_pattern = format!("(?, ?, 0, {})", RelationshipKind::Kasten.to_string());
	let insert_note_page_references_sql =
		"INSERT INTO note_relationships (parent_id, note_id, location, 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 find_all_kasten_references_for<'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::Kasten.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: &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),
    }
}

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

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

pub(crate) async fn delete_note<'a, E>(executor: E, note_id: &NoteId) -> 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: &ParentId, 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(())
}

pub(crate) async fn count_existing_note_relationships<'a, E>(executor: E, note_id: &NoteId) -> SqlResult<i64>
where
    E: Executor<'a, Database = Sqlite>,
{
    lazy_static! {
        static ref COUNT_EXISTING_NOTE_RELATIONSHIPS_SQL: String = format!(
			"SELECT COUNT(*) as count FROM note_relationships WHERE kind IN ({}, {}, {}) and note_id = ?;",
			RelationshipKind::Direct.to_string(),
			RelationshipKind::Reference.to_string(),
			RelationshipKind::Embed.to_string(),
        );
    }

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

    Ok(count.count)
}

// 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()
}

// 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.
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::Kasten.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),
    })
}

pub(crate) fn create_zettlekasten(title: &str, slug: &str) -> NewNote {
    NewNoteBuilder::default()
        .id(slug.to_string())
        .content(title.to_string())
        .kind(NoteKind::Kasten)
        .build()
        .unwrap()
}