use super::{StoreError, Undo};
use chrono::{DateTime, Utc};
use sled::{Db, Transactional, Tree};
use std::{fmt, io::Cursor};
use uuid::Uuid;

#[derive(Clone, Copy, Debug, serde::Deserialize, serde::Serialize)]
pub enum Visibility {
    Public,
    Unlisted,
    Followers,
}

#[derive(Clone, Debug)]
pub struct Submission {
    id: Uuid,
    profile_id: Uuid,
    title: String,
    title_source: Option<String>,
    description: Option<String>,
    description_source: Option<String>,
    files: Vec<Uuid>,
    published: Option<DateTime<Utc>>,
    updated: Option<DateTime<Utc>>,
    visibility: Visibility,
    local_only: bool,
    logged_in_only: bool,
    sensitive: bool,
}

#[derive(Debug)]
pub struct SubmissionChanges {
    id: Uuid,
    title: Option<String>,
    title_source: Option<String>,
    description: Option<String>,
    description_source: Option<String>,
    visibility: Option<Visibility>,
    published: Option<DateTime<Utc>>,
    updated: Option<DateTime<Utc>>,
    local_only: Option<bool>,
    logged_in_only: Option<bool>,
    sensitive: Option<bool>,
    original_files: Vec<Uuid>,
    files: Vec<Uuid>,
}

#[derive(Clone, Debug)]
pub struct Store {
    submission_tree: Tree,
    profile_tree: Tree,
    profile_drafted_tree: Tree,
    published_tree: Tree,
    profile_published_tree: Tree,
    count_tree: Tree,
}

#[derive(Debug, serde::Deserialize, serde::Serialize)]
struct StoredSubmission {
    id: Uuid,
    profile_id: Uuid,
    title: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    title_source: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    description_source: Option<String>,
    files: Vec<Uuid>,
    #[serde(skip_serializing_if = "Option::is_none")]
    published: Option<DateTime<Utc>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    updated: Option<DateTime<Utc>>,
    visibility: Visibility,
    #[serde(default)]
    local_only: bool,
    #[serde(default)]
    logged_in_only: bool,
    #[serde(default)]
    sensitive: bool,
    drafted_at: DateTime<Utc>,
}

impl Submission {
    pub fn update(&self) -> SubmissionChanges {
        SubmissionChanges {
            id: self.id,
            title: None,
            title_source: None,
            description: None,
            description_source: None,
            visibility: None,
            published: self.published,
            updated: None,
            local_only: None,
            logged_in_only: None,
            sensitive: None,
            original_files: self.files.clone(),
            files: self.files.clone(),
        }
    }

    pub fn id(&self) -> Uuid {
        self.id
    }

    pub fn profile_id(&self) -> Uuid {
        self.profile_id
    }

    pub fn title(&self) -> &str {
        &self.title
    }

    pub fn title_source(&self) -> Option<&str> {
        self.title_source.as_deref()
    }

    pub fn description(&self) -> Option<&str> {
        self.description.as_ref().map(|d| d.as_str())
    }

    pub fn description_source(&self) -> Option<&str> {
        self.description_source.as_deref()
    }

    pub fn files(&self) -> &[Uuid] {
        &self.files
    }

    pub fn published(&self) -> Option<DateTime<Utc>> {
        self.published
    }

    pub fn updated(&self) -> Option<DateTime<Utc>> {
        self.updated
    }

    pub fn visibility(&self) -> Visibility {
        self.visibility
    }

    pub fn is_public(&self) -> bool {
        matches!(self.visibility, Visibility::Public)
    }

    pub fn is_unlisted(&self) -> bool {
        matches!(self.visibility, Visibility::Unlisted)
    }

    pub fn is_followers_only(&self) -> bool {
        matches!(self.visibility, Visibility::Followers)
    }

    pub fn is_local_only(&self) -> bool {
        self.local_only
    }

    pub fn is_logged_in_only(&self) -> bool {
        self.logged_in_only
    }

    pub fn is_sensitive(&self) -> bool {
        self.sensitive
    }
}

impl SubmissionChanges {
    pub(crate) fn title(&mut self, title: &str) -> &mut Self {
        self.title = Some(title.to_owned());
        self
    }

    pub(crate) fn title_source(&mut self, title_source: &str) -> &mut Self {
        self.title_source = Some(title_source.to_owned());
        self
    }

    pub(crate) fn description(&mut self, description: &str) -> &mut Self {
        self.description = Some(description.to_owned());
        self
    }

    pub(crate) fn description_source(&mut self, description_source: &str) -> &mut Self {
        self.description_source = Some(description_source.to_owned());
        self
    }

    pub(crate) fn visibility(&mut self, visibility: Visibility) -> &mut Self {
        if self.visibility.is_none() {
            self.visibility = Some(visibility);
        }
        self
    }

    pub(crate) fn published(&mut self, time: Option<DateTime<Utc>>) -> &mut Self {
        if self.published.is_none() {
            self.published = time.or_else(|| Some(Utc::now()));
        }
        self
    }

    pub(crate) fn updated(&mut self, time: DateTime<Utc>) -> &mut Self {
        if self.published.is_some() {
            self.updated = Some(time);
        }
        self
    }

    pub(crate) fn local_only(&mut self, local_only: bool) -> &mut Self {
        if self.published.is_none() {
            self.local_only = Some(local_only);
        }
        self
    }

    pub(crate) fn logged_in_only(&mut self, logged_in_only: bool) -> &mut Self {
        if self.published.is_none() {
            self.logged_in_only = Some(logged_in_only);
        }
        self
    }

    pub(crate) fn sensitive(&mut self, sensitive: bool) -> &mut Self {
        self.sensitive = Some(sensitive);
        self
    }

    pub(crate) fn add_file(&mut self, file_id: Uuid) -> &mut Self {
        self.files.push(file_id);
        self
    }

    pub(crate) fn delete_file(&mut self, file_id: Uuid) -> &mut Self {
        self.files.retain(|id| *id != file_id);
        self
    }

    pub(crate) fn any_changes(&self) -> bool {
        self.title.is_some()
            || self.description.is_some()
            || self.published.is_some()
            || self.updated.is_some()
            || self.visibility.is_some()
            || self.local_only.is_some()
            || self.logged_in_only.is_some()
            || self.sensitive.is_some()
            || self.original_files != self.files
    }
}

impl Store {
    pub fn build(db: &Db) -> Result<Self, sled::Error> {
        Ok(Store {
            submission_tree: db.open_tree("profiles/submissions")?,
            profile_tree: db.open_tree("profiles/submissions/profile")?,
            profile_drafted_tree: db.open_tree("/profiles/submissions/profile/drafted")?,
            published_tree: db.open_tree("/profiles/submission/published")?,
            profile_published_tree: db.open_tree("/profiles/submission/profile/published")?,
            count_tree: db.open_tree("/profiles/submissions/count")?,
        })
    }

    pub fn create(
        &self,
        profile_id: Uuid,
        title: &str,
        visibility: Visibility,
    ) -> Result<Submission, StoreError> {
        let mut id;
        let mut stored_submission;

        let now = Utc::now().into();
        let mut stored_submission_vec = vec![];

        while {
            stored_submission_vec.clear();
            let writer = Cursor::new(&mut stored_submission_vec);
            id = Uuid::new_v4();
            stored_submission = StoredSubmission {
                id,
                profile_id,
                title: title.to_owned(),
                title_source: None,
                description: None,
                description_source: None,
                files: vec![],
                published: None,
                updated: None,
                visibility,
                local_only: false,
                logged_in_only: false,
                drafted_at: now,
                sensitive: false,
            };
            serde_json::to_writer(writer, &stored_submission)?;
            self.submission_tree
                .compare_and_swap(
                    id_submission_key(id).as_bytes(),
                    None as Option<&[u8]>,
                    Some(stored_submission_vec.as_slice()),
                )?
                .is_err()
        } {}

        let res = [
            &self.profile_tree,
            &self.profile_drafted_tree,
            &self.count_tree,
        ]
        .transaction(move |trees| {
            let profile_tree = &trees[0];
            let profile_drafted_tree = &trees[1];
            let count_tree = &trees[2];

            profile_tree.insert(
                profile_id_key(profile_id, id).as_bytes(),
                id.to_string().as_bytes(),
            )?;
            profile_drafted_tree.insert(
                profile_id_drafted_submission_key(profile_id, now, id).as_bytes(),
                id.to_string().as_bytes(),
            )?;

            super::count(
                count_tree,
                &profile_id_submission_count_key(profile_id),
                |c| c.saturating_add(1),
            )?;

            Ok(())
        });

        if let Err(e) = res {
            self.submission_tree
                .remove(id_submission_key(id).as_bytes())?;
            return Err(e.into());
        }

        Ok(stored_submission.into())
    }

    pub fn count(&self, profile_id: Uuid) -> Result<u64, StoreError> {
        match self
            .count_tree
            .get(profile_id_submission_count_key(profile_id))?
        {
            Some(ivec) => Ok(String::from_utf8_lossy(&ivec)
                .parse::<u64>()
                .expect("Count is valid")),
            None => Ok(0),
        }
    }

    pub fn update(&self, changes: &SubmissionChanges) -> Result<Submission, StoreError> {
        let stored_submission_ivec =
            match self.submission_tree.get(id_submission_key(changes.id))? {
                Some(ivec) => ivec,
                None => return Err(StoreError::Missing),
            };

        let mut stored_submission: StoredSubmission =
            serde_json::from_slice(&stored_submission_ivec)?;

        if let Some(updated) = changes.updated {
            if let Some(previously_updated) = stored_submission
                .updated
                .or_else(|| stored_submission.published)
            {
                if updated < previously_updated {
                    return Err(StoreError::Outdated);
                }
            }
        }

        let already_published = stored_submission.published.is_some();

        if let Some(title) = &changes.title {
            stored_submission.title = title.to_owned();
        }
        if let Some(title_source) = &changes.title_source {
            stored_submission.title_source = Some(title_source.clone());
        }
        if let Some(description) = &changes.description {
            stored_submission.description = Some(description.to_owned());
        }
        if let Some(description_source) = &changes.description_source {
            stored_submission.description_source = Some(description_source.clone());
        }
        if let Some(visibility) = changes.visibility {
            stored_submission.visibility = visibility;
        }
        if let Some(local_only) = changes.local_only {
            stored_submission.local_only = local_only;
        }
        if let Some(logged_in_only) = changes.logged_in_only {
            stored_submission.logged_in_only = logged_in_only;
        }
        if let Some(sensitive) = changes.sensitive {
            stored_submission.sensitive = sensitive;
        }
        if stored_submission.published.is_some() {
            if let Some(updated) = changes.updated {
                stored_submission.updated = Some(updated);
            }
        }
        stored_submission.published = changes.published;
        stored_submission.files = changes.files.clone();

        let stored_submission_vec = serde_json::to_vec(&stored_submission)?;

        if self
            .submission_tree
            .compare_and_swap(
                id_submission_key(changes.id),
                Some(&stored_submission_ivec),
                Some(stored_submission_vec.as_slice()),
            )?
            .is_err()
        {
            return Err(StoreError::DoubleStore);
        }

        if !already_published {
            if let Some(published) = changes.published {
                self.profile_drafted_tree
                    .remove(profile_id_drafted_submission_key(
                        stored_submission.profile_id,
                        stored_submission.drafted_at,
                        stored_submission.id,
                    ))?;

                self.published_tree.insert(
                    published_submission_key(published, stored_submission.id),
                    stored_submission.id.to_string().as_bytes(),
                )?;
                self.profile_published_tree.insert(
                    published_profile_submission_key(
                        stored_submission.profile_id,
                        published,
                        stored_submission.id,
                    ),
                    stored_submission.id.to_string().as_bytes(),
                )?;
            }
        }

        Ok(stored_submission.into())
    }

    fn extract<T, F>(&self, submission_id: Uuid, f: F) -> Option<T>
    where
        F: FnOnce(StoredSubmission) -> Option<T>,
    {
        let ivec = self
            .submission_tree
            .get(id_submission_key(submission_id))
            .ok()??;
        let stored_submission: StoredSubmission = serde_json::from_slice(&ivec).ok()?;

        (f)(stored_submission)
    }

    pub fn published(&self) -> impl DoubleEndedIterator<Item = Uuid> {
        self.published_tree
            .scan_prefix(published_prefix())
            .values()
            .filter_map(|res| res.ok())
            .filter_map(uuid_from_ivec)
            .rev()
    }

    fn published_date_range<K>(
        &self,
        range: impl std::ops::RangeBounds<K>,
    ) -> impl DoubleEndedIterator<Item = Uuid>
    where
        K: AsRef<[u8]>,
    {
        self.published_tree
            .range(range)
            .values()
            .filter_map(|res| res.ok())
            .filter_map(uuid_from_ivec)
    }

    pub fn published_newer_than(
        &self,
        submission_id: Uuid,
    ) -> impl DoubleEndedIterator<Item = Uuid> {
        let this = self.clone();

        self.extract(submission_id, |stored_submission| {
            stored_submission.published
        })
        .into_iter()
        .flat_map(move |published| {
            let range_entry = published_submission_range_start(published);
            let range_entry = range_entry.as_bytes().to_vec();
            this.published_date_range(range_entry..)
        })
    }

    pub fn published_older_than(
        &self,
        submission_id: Uuid,
    ) -> impl DoubleEndedIterator<Item = Uuid> {
        let this = self.clone();

        self.extract(submission_id, |stored_submission| {
            stored_submission.published
        })
        .into_iter()
        .flat_map(move |published| {
            let range_entry = published_submission_range_start(published);
            let range_entry = range_entry.as_bytes().to_vec();
            this.published_date_range(..range_entry)
        })
        .rev()
    }

    pub fn drafted_for_profile(&self, profile_id: Uuid) -> impl DoubleEndedIterator<Item = Uuid> {
        self.profile_drafted_tree
            .scan_prefix(profile_id_drafted_prefix(profile_id))
            .values()
            .filter_map(|res| res.ok())
            .filter_map(uuid_from_ivec)
            .rev()
    }

    fn drafted_date_range_for_profile<K>(
        &self,
        range: impl std::ops::RangeBounds<K>,
    ) -> impl DoubleEndedIterator<Item = Uuid>
    where
        K: AsRef<[u8]>,
    {
        self.profile_drafted_tree
            .range(range)
            .values()
            .filter_map(|res| res.ok())
            .filter_map(uuid_from_ivec)
    }

    pub fn drafted_newer_than_for_profile(
        &self,
        id: Uuid,
    ) -> impl DoubleEndedIterator<Item = Uuid> {
        let this = self.clone();

        self.extract(id, |s| Some((s.profile_id, s.drafted_at)))
            .into_iter()
            .flat_map(move |(profile_id, drafted)| {
                let range_end = profile_id_drafted_submission_range_end(profile_id);
                let range_entry = profile_id_drafted_submission_range_entry(profile_id, drafted);
                this.drafted_date_range_for_profile(range_entry..range_end)
            })
    }

    pub fn drafted_older_than_for_profile(
        &self,
        id: Uuid,
    ) -> impl DoubleEndedIterator<Item = Uuid> {
        let this = self.clone();

        self.extract(id, |s| Some((s.profile_id, s.drafted_at)))
            .into_iter()
            .flat_map(move |(profile_id, drafted)| {
                let range_start = profile_id_drafted_submission_range_beginning(profile_id);
                let range_entry = profile_id_drafted_submission_range_entry(profile_id, drafted);
                this.drafted_date_range_for_profile(range_start..range_entry)
            })
            .rev()
    }

    pub fn published_for_profile(&self, profile_id: Uuid) -> impl DoubleEndedIterator<Item = Uuid> {
        self.profile_published_tree
            .scan_prefix(profile_id_published_prefix(profile_id))
            .values()
            .filter_map(|res| res.ok())
            .filter_map(uuid_from_ivec)
            .rev()
    }

    fn published_date_range_for_profile<K>(
        &self,
        range: impl std::ops::RangeBounds<K>,
    ) -> impl DoubleEndedIterator<Item = Uuid>
    where
        K: AsRef<[u8]>,
    {
        self.profile_published_tree
            .range(range)
            .values()
            .filter_map(|res| res.ok())
            .filter_map(uuid_from_ivec)
    }

    pub fn published_newer_than_for_profile(
        &self,
        id: Uuid,
    ) -> impl DoubleEndedIterator<Item = Uuid> {
        let this = self.clone();

        self.extract(id, |s| s.published.map(|p| (s.profile_id, p)))
            .into_iter()
            .flat_map(move |(profile_id, published)| {
                let range_end = profile_id_publshed_submission_range_end(profile_id);
                let range_entry = profile_id_publshed_submission_range_entry(profile_id, published);
                this.published_date_range_for_profile(range_entry..range_end)
            })
    }

    pub fn published_older_than_for_profile(
        &self,
        id: Uuid,
    ) -> impl DoubleEndedIterator<Item = Uuid> {
        let this = self.clone();

        self.extract(id, |s| s.published.map(|p| (s.profile_id, p)))
            .into_iter()
            .flat_map(move |(profile_id, published)| {
                let range_start = profile_id_publshed_submission_range_beginning(profile_id);
                let range_entry = profile_id_publshed_submission_range_entry(profile_id, published);
                this.published_date_range_for_profile(range_start..range_entry)
            })
            .rev()
    }

    pub fn by_id(&self, id: Uuid) -> Result<Option<Submission>, StoreError> {
        let stored_submission_ivec = match self.submission_tree.get(id_submission_key(id))? {
            Some(ivec) => ivec,
            None => return Ok(None),
        };

        let stored_submission: StoredSubmission = serde_json::from_slice(&stored_submission_ivec)?;

        Ok(Some(stored_submission.into()))
    }

    pub fn delete(&self, submission_id: Uuid) -> Result<Option<Undo<Submission>>, StoreError> {
        let stored_submission_ivec =
            match self.submission_tree.get(id_submission_key(submission_id))? {
                Some(ivec) => ivec,
                None => return Ok(None),
            };

        let stored_submission: StoredSubmission = serde_json::from_slice(&stored_submission_ivec)?;

        let id = submission_id;
        let profile_id = stored_submission.profile_id;
        let drafted_at = stored_submission.drafted_at;
        let published = stored_submission.published;

        [
            &self.submission_tree,
            &self.profile_tree,
            &self.profile_drafted_tree,
            &self.published_tree,
            &self.profile_published_tree,
            &self.count_tree,
        ]
        .transaction(move |trees| {
            let submission_tree = &trees[0];
            let profile_tree = &trees[1];
            let profile_drafted_tree = &trees[2];
            let published_tree = &trees[3];
            let profile_published_tree = &trees[4];
            let count_tree = &trees[5];

            submission_tree.remove(id_submission_key(id).as_bytes())?;
            profile_tree.remove(profile_id_key(profile_id, id).as_bytes())?;
            profile_drafted_tree
                .remove(profile_id_drafted_submission_key(profile_id, drafted_at, id).as_bytes())?;

            if let Some(published) = published {
                published_tree.remove(published_submission_key(published, id).as_bytes())?;
                profile_published_tree.remove(
                    published_profile_submission_key(profile_id, published, id).as_bytes(),
                )?;
            }

            super::count(
                count_tree,
                &profile_id_submission_count_key(profile_id),
                |c| c.saturating_sub(1),
            )?;

            Ok(())
        })?;

        Ok(Some(Undo(stored_submission.into())))
    }
}

fn uuid_from_ivec(ivec: sled::IVec) -> Option<Uuid> {
    String::from_utf8_lossy(&ivec).parse().ok()
}

// Used to map id -> Submission
fn id_submission_key(id: Uuid) -> String {
    format!("/submission/{}/data", id)
}

// Used to map profile_id -> id
fn profile_id_key(profile_id: Uuid, id: Uuid) -> String {
    format!("/profile/{}/submission/{}", profile_id, id)
}

fn profile_id_published_prefix(profile_id: Uuid) -> String {
    format!("/profile/{}/published", profile_id)
}

fn profile_id_drafted_prefix(profile_id: Uuid) -> String {
    format!("/profile/{}/drafted", profile_id)
}

// Used to fetch submissions for a given profile in a user-recognizalbe order
fn profile_id_drafted_submission_key(
    profile_id: Uuid,
    drafted_at: DateTime<Utc>,
    id: Uuid,
) -> String {
    format!(
        "/profile/{}/drafted/{}/submission/{}",
        profile_id,
        drafted_at.to_rfc3339(),
        id
    )
}

fn profile_id_drafted_submission_range_beginning(profile_id: Uuid) -> String {
    format!("/profile/{}/drafted/", profile_id)
}

fn profile_id_drafted_submission_range_entry(
    profile_id: Uuid,
    drafted_at: DateTime<Utc>,
) -> String {
    format!(
        "/profile/{}/drafted/{}",
        profile_id,
        drafted_at.to_rfc3339()
    )
}

fn profile_id_drafted_submission_range_end(profile_id: Uuid) -> String {
    format!("/profile/{}/draftee/", profile_id)
}

fn published_profile_submission_key(
    profile_id: Uuid,
    published: DateTime<Utc>,
    id: Uuid,
) -> String {
    format!(
        "/profile/{}/published/{}/submission/{}",
        profile_id,
        published.to_rfc3339(),
        id
    )
}

fn published_submission_key(published: DateTime<Utc>, id: Uuid) -> String {
    format!("/published/{}/submission/{}", published.to_rfc3339(), id)
}

fn published_prefix() -> String {
    "/published".to_owned()
}

fn published_submission_range_start(published: DateTime<Utc>) -> String {
    format!("/published/{}", published.to_rfc3339())
}

fn profile_id_publshed_submission_range_beginning(profile_id: Uuid) -> String {
    format!("/profile/{}/published/", profile_id)
}

fn profile_id_publshed_submission_range_entry(
    profile_id: Uuid,
    published: DateTime<Utc>,
) -> String {
    format!(
        "/profile/{}/published/{}",
        profile_id,
        published.to_rfc3339()
    )
}

fn profile_id_publshed_submission_range_end(profile_id: Uuid) -> String {
    format!("/profile/{}/publishee/", profile_id)
}

fn profile_id_submission_count_key(profile_id: Uuid) -> String {
    format!("/profile/{}/count", profile_id)
}

impl From<StoredSubmission> for Submission {
    fn from(ss: StoredSubmission) -> Self {
        Submission {
            id: ss.id,
            profile_id: ss.profile_id,
            title: ss.title,
            title_source: ss.title_source,
            description: ss.description,
            description_source: ss.description_source,
            files: ss.files,
            published: ss.published,
            updated: ss.updated,
            visibility: ss.visibility,
            local_only: ss.local_only,
            logged_in_only: ss.logged_in_only,
            sensitive: ss.sensitive,
        }
    }
}

impl fmt::Display for Visibility {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Visibility::Public => write!(f, "Public"),
            Visibility::Unlisted => write!(f, "Unlisted"),
            Visibility::Followers => write!(f, "Followers"),
        }
    }
}