use radicle::cob::automerge::store::Store;

use radicle::cob::common::{Label, Reaction};

use radicle::cob::automerge;

    let cobs = automerge::Store::open(*profile.id(), &repository)?;

use radicle::cob::automerge::patch::{MergeTarget, Patch, PatchId, PatchStore};

use radicle::cob::automerge;

use radicle::cob::automerge::patch::{MergeTarget, Patch, PatchId, PatchStore};

    let cobs = automerge::Store::open(profile.public_key, storage)?;

use radicle::cob::automerge;

    let cobs = automerge::Store::open(*profile.id(), storage)?;

use radicle::cob::automerge::patch::{PatchId, RevisionIx, Verdict};

    let cobs = cob::automerge::Store::open(*profile.id(), &repository)?;

use radicle::cob::common::CommentId;

use radicle::cob::common::Reaction;

pub mod automerge;

pub mod common;

pub use common::*;

pub mod doc;

pub mod issue;

pub mod label;

pub mod patch;

pub mod shared;

pub mod store;

pub mod transaction;

pub mod value;

pub use store::Store;

use std::collections::{HashMap, HashSet};

use std::fmt;

use std::hash::Hash;

use std::ops::Deref;

use std::str::FromStr;

use automerge::{Automerge, AutomergeError, ObjType};

use crate::cob::automerge::value::{FromValue, ValueError};

/// Error decoding a document.

#[derive(thiserror::Error, Debug)]

pub enum DocumentError {

    #[error(transparent)]

    Automerge(#[from] AutomergeError),

    #[error("property '{0}' not found in object")]

    PropertyNotFound(automerge::Prop),

    #[error("error decoding property `{0}`")]

    Property(String),

    #[error("property '{0}' is not an object")]

    NotAnObject(automerge::Prop),

    #[error("Unexpected object type: expected `{expected}`, got `{actual}`")]

    ObjectType {

        expected: automerge::ObjType,

        actual: automerge::ObjType,

    },

    #[error("error decoding value: {0}")]

    Value(#[from] ValueError),

    #[error("list under `{0}` cannot be empty")]

    EmptyList(&'static str),

}

/// Automerge document decoder.

///

/// Wraps a document, providing convenience functions. Derefs to the underlying doc.

#[derive(Copy, Clone)]

pub struct Document<'a> {

    doc: &'a Automerge,

}

impl<'a> Document<'a> {

    /// Create a new document from an automerge document.

    pub fn new(doc: &'a Automerge) -> Self {

        Self { doc }

    }

    /// Get the value of a property of an object.

    pub fn get<O: AsRef<automerge::ObjId>, P: Into<automerge::Prop>, T: FromValue<'a>>(

        &self,

        id: O,

        prop: P,

    ) -> Result<T, DocumentError> {

        let prop = prop.into();

        let (val, _) = Document::get_raw(self, id, prop)?;

        T::from_value(val).map_err(DocumentError::from)

    }

    /// Get an object's raw property.

    pub fn get_raw<O: AsRef<automerge::ObjId>, P: Into<automerge::Prop>>(

        &self,

        id: O,

        prop: P,

    ) -> Result<(automerge::Value<'a>, automerge::ObjId), DocumentError> {

        let prop = prop.into();

        self.doc

            .get(id.as_ref(), prop.clone())?

            .ok_or(DocumentError::PropertyNotFound(prop))

    }

    /// Get the id of an object's property.

    pub fn get_id<O: AsRef<automerge::ObjId>, P: Into<automerge::Prop>>(

        &self,

        id: O,

        prop: P,

    ) -> Result<automerge::ObjId, DocumentError> {

        self.get_raw(id, prop).map(|(_, id)| id)

    }

    /// Get a property using a lookup function.

    pub fn lookup<V, O: AsRef<automerge::ObjId>, P: Into<automerge::Prop>>(

        &self,

        id: O,

        prop: P,

        lookup: fn(Document, &automerge::ObjId) -> Result<V, DocumentError>,

    ) -> Result<V, DocumentError> {

        let obj_id = self.get_id(&id, prop)?;

        lookup(*self, &obj_id)

    }

    /// Get a list-like value from an object.

    pub fn list<V, O: AsRef<automerge::ObjId>, P: Into<automerge::Prop>>(

        &self,

        id: O,

        prop: P,

        item: fn(Document, &automerge::ObjId) -> Result<V, DocumentError>,

    ) -> Result<Vec<V>, DocumentError> {

        let prop = prop.into();

        let id = id.as_ref();

        let Some((list, list_id)) = self.doc.get(id, prop.clone())? else {

            return Err(DocumentError::PropertyNotFound(prop));

        };

        let Some(objtype) = list.to_objtype() else {

            return Err(DocumentError::NotAnObject(prop));

        };

        if objtype != ObjType::List {

            return Err(DocumentError::ObjectType {

                expected: ObjType::List,

                actual: objtype,

            });

        }

        let mut objs: Vec<V> = Vec::new();

        for i in 0..self.length(&list_id) {

            let Some((_, item_id)) = self.doc.get(&list_id, i as usize)? else {

                return Err(DocumentError::PropertyNotFound(prop));

            };

            let item = item(*self, &item_id)?;

            objs.push(item);

        }

        Ok(objs)

    }

    /// Get a map-like value from an object.

    pub fn map<

        V: Default,

        K: Hash + Eq + FromStr,

        O: AsRef<automerge::ObjId>,

        P: Into<automerge::Prop>,

    >(

        &self,

        id: O,

        prop: P,

        mut value: impl FnMut(&mut V),

    ) -> Result<HashMap<K, V>, DocumentError> {

        let prop = prop.into();

        let id = id.as_ref();

        let Some((obj, obj_id)) = self.doc.get(id, prop.clone())? else {

            return Err(DocumentError::PropertyNotFound(prop))?;

        };

        let Some(objtype) = obj.to_objtype() else {

            return Err(DocumentError::NotAnObject(prop));

        };

        if objtype != ObjType::Map {

            return Err(DocumentError::ObjectType {

                expected: ObjType::Map,

                actual: objtype,

            });

        }

        let mut map = HashMap::new();

        for key in self.doc.keys(&obj_id) {

            let key = K::from_str(&key).map_err(|_| DocumentError::Property(key))?;

            let val = map.entry(key).or_default();

            value(val);

        }

        Ok(map)

    }

    /// Get a folded value out of an object.

    pub fn fold<

        T: Default,

        V: FromValue<'a> + fmt::Debug,

        O: AsRef<automerge::ObjId>,

        P: Into<automerge::Prop>,

    >(

        &self,

        id: O,

        prop: P,

        mut f: impl FnMut(&mut T, V),

    ) -> Result<T, DocumentError> {

        let prop = prop.into();

        let id = id.as_ref();

        let Some((obj, obj_id)) = self.doc.get(id, prop.clone())? else {

            return Err(DocumentError::PropertyNotFound(prop));

        };

        let Some(objtype) = obj.to_objtype() else {

            return Err(DocumentError::NotAnObject(prop));

        };

        if objtype != ObjType::List {

            return Err(DocumentError::ObjectType {

                expected: ObjType::List,

                actual: objtype,

            });

        }

        let mut acc = T::default();

        for i in 0..self.doc.length(&obj_id) {

            let Some((item, _)) = self.doc.get(&obj_id, i as usize)? else {

                return Err(DocumentError::PropertyNotFound(prop));

            };

            let val = V::from_value(item)?;

            f(&mut acc, val);

        }

        Ok(acc)

    }

    /// Get the keys of a map-like property.

    pub fn keys<K: Hash + Eq + FromStr, O: AsRef<automerge::ObjId>, P: Into<automerge::Prop>>(

        &self,

        id: O,

        prop: P,

    ) -> Result<HashSet<K>, DocumentError> {

        let prop = prop.into();

        let id = id.as_ref();

        let Some((obj, obj_id)) = self.doc.get(id, prop.clone())? else {

            return Err(DocumentError::PropertyNotFound(prop));

        };

        let Some(objtype) = obj.to_objtype() else {

            return Err(DocumentError::NotAnObject(prop));

        };

        if objtype != ObjType::Map {

            return Err(DocumentError::ObjectType {

                expected: ObjType::Map,

                actual: objtype,

            });

        }

        let mut keys = HashSet::new();

        for key in self.doc.keys(&obj_id) {

            let key = K::from_str(&key).map_err(|_| DocumentError::Property(key))?;

            keys.insert(key);

        }

        Ok(keys)

    }

}

impl<'a> Deref for Document<'a> {

    type Target = Automerge;

    fn deref(&self) -> &Self::Target {

        self.doc

    }

}

#![allow(clippy::large_enum_variant)]

use std::collections::HashSet;

use std::convert::TryFrom;

use std::ops::ControlFlow;

use automerge::{Automerge, ObjType, ScalarValue, Value};

use crate::cob::automerge::doc::{Document, DocumentError};

use crate::cob::automerge::shared;

use crate::cob::automerge::shared::*;

use crate::cob::automerge::store::{Error, Store};

use crate::cob::automerge::transaction::{Transaction, TransactionError};

use crate::cob::automerge::value::{FromValue, ValueError};

use crate::cob::common::*;

use crate::cob::issue::*;

use crate::cob::{Contents, History, ObjectId, Timestamp, TypeName};

use crate::prelude::*;

impl From<State> for ScalarValue {

    fn from(state: State) -> Self {

        match state {

            State::Open => ScalarValue::from("open"),

            State::Closed {

                reason: CloseReason::Solved,

            } => ScalarValue::from("solved"),

            State::Closed {

                reason: CloseReason::Other,

            } => ScalarValue::from("closed"),

        }

    }

}

impl<'a> FromValue<'a> for State {

    fn from_value(value: Value) -> Result<Self, ValueError> {

        let state = value.to_str().ok_or(ValueError::InvalidType)?;

        match state {

            "open" => Ok(Self::Open),

            "closed" => Ok(Self::Closed {

                reason: CloseReason::Other,

            }),

            "solved" => Ok(Self::Closed {

                reason: CloseReason::Solved,

            }),

            _ => Err(ValueError::InvalidValue(value.to_string())),

        }

    }

}

impl FromHistory for Issue {

    fn type_name() -> &'static TypeName {

        &TYPENAME

    }

    fn from_history(history: &History) -> Result<Self, Error> {

        let doc = history.traverse(Automerge::new(), |mut doc, entry| {

            let bytes = entry.contents();

            match automerge::Change::from_bytes(bytes.clone()) {

                Ok(change) => {

                    doc.apply_changes([change]).ok();

                }

                Err(_err) => {

                    // Ignore

                }

            }

            ControlFlow::Continue(doc)

        });

        let issue = Issue::try_from(doc)?;

        Ok(issue)

    }

}

impl TryFrom<&History> for Issue {

    type Error = Error;

    fn try_from(history: &History) -> Result<Self, Self::Error> {

        Issue::from_history(history)

    }

}

impl TryFrom<Automerge> for Issue {

    type Error = DocumentError;

    fn try_from(doc: Automerge) -> Result<Self, Self::Error> {

        let doc = Document::new(&doc);

        let obj_id = doc.get_id(automerge::ObjId::Root, "issue")?;

        let title = doc.get(&obj_id, "title")?;

        let comment_id = doc.get_id(&obj_id, "comment")?;

        let author = doc.get(&obj_id, "author").map(Author::new)?;

        let state = doc.get(&obj_id, "state")?;

        let timestamp = doc.get(&obj_id, "timestamp")?;

        let comment = shared::lookup::comment(doc, &comment_id)?;

        let discussion: Discussion = doc.list(&obj_id, "discussion", shared::lookup::thread)?;

        let labels: HashSet<Label> = doc.keys(&obj_id, "labels")?;

        Ok(Self {

            title,

            state,

            author,

            comment,

            discussion,

            labels,

            timestamp,

        })

    }

}

pub struct IssueStore<'a> {

    store: Store<'a, Issue>,

}

impl<'a> IssueStore<'a> {

    /// Create a new issue store.

    pub fn new(store: Store<'a, Issue>) -> Self {

        Self { store }

    }

    /// Get an issue by id.

    pub fn get(&self, id: &ObjectId) -> Result<Option<Issue>, Error> {

        self.store.get(id)

    }

    /// Create an issue.

    pub fn create<G: Signer>(

        &self,

        title: &str,

        description: &str,

        labels: &[Label],

        signer: &G,

    ) -> Result<IssueId, Error> {

        let author = self.store.author();

        let timestamp = Timestamp::now();

        let contents = events::create(&author, title, description, timestamp, labels)?;

        let cob = self.store.create("Create issue", contents, signer)?;

        Ok(*cob.id())

    }

    /// Remove an issue.

    pub fn remove<G: Signer>(&self, _issue_id: &IssueId, _signer: &G) -> Result<(), Error> {

        todo!()

    }

    /// Comment on an issue.

    pub fn comment<G: Signer>(

        &self,

        issue_id: &IssueId,

        body: &str,

        signer: &G,

    ) -> Result<(), Error> {

        let author = self.store.author();

        let mut issue = self.store.get_raw(issue_id)?;

        let timestamp = Timestamp::now();

        let changes = events::comment(&mut issue, &author, body, timestamp)?;

        self.store

            .update(*issue_id, "Add comment", changes, signer)?;

        Ok(())

    }

    /// Life-cycle an issue, eg. open or close it.

    pub fn lifecycle<G: Signer>(

        &self,

        issue_id: &IssueId,

        state: State,

        signer: &G,

    ) -> Result<(), Error> {

        let author = self.store.author();

        let mut issue = self.store.get_raw(issue_id)?;

        let changes = events::lifecycle(&mut issue, &author, state)?;

        self.store.update(*issue_id, "Lifecycle", changes, signer)?;

        Ok(())

    }

    /// Label an issue.

    pub fn label<G: Signer>(

        &self,

        issue_id: &IssueId,

        labels: &[Label],

        signer: &G,

    ) -> Result<(), Error> {

        let author = self.store.author();

        let mut issue = self.store.get_raw(issue_id)?;

        let changes = events::label(&mut issue, &author, labels)?;

        self.store.update(*issue_id, "Add label", changes, signer)?;

        Ok(())

    }

    /// React to an issue comment.

    pub fn react<G: Signer>(

        &self,

        issue_id: &IssueId,

        comment_id: CommentId,

        reaction: Reaction,

        signer: &G,

    ) -> Result<(), Error> {

        let author = self.store.author();

        let mut issue = self.store.get_raw(issue_id)?;

        let changes = events::react(&mut issue, comment_id, &author, &[reaction])?;

        self.store.update(*issue_id, "React", changes, signer)?;

        Ok(())

    }

    /// Reply to an issue comment.

    pub fn reply<G: Signer>(

        &self,

        issue_id: &IssueId,

        comment_id: CommentId,

        reply: &str,

        signer: &G,

    ) -> Result<(), Error> {

        let author = self.store.author();

        let mut issue = self.store.get_raw(issue_id)?;

        let changes = events::reply(&mut issue, comment_id, &author, reply, Timestamp::now())?;

        self.store.update(*issue_id, "Reply", changes, signer)?;

        Ok(())

    }

    /// Get all issues, sorted by time.

    pub fn all(&self) -> Result<Vec<(IssueId, Issue)>, Error> {

        let mut issues = self.store.list()?;

        issues.sort_by_key(|(_, i)| i.timestamp);

        Ok(issues)

    }

    /// Get the issue count.

    pub fn count(&self) -> Result<usize, Error> {

        let issues = self.store.list()?;

        Ok(issues.len())

    }

}

/// Issue events.

mod events {

    use super::*;

    use automerge::{

        transaction::{CommitOptions, Transactable},

        ObjId,

    };

    pub fn create(

        author: &Author,

        title: &str,

        description: &str,

        timestamp: Timestamp,

        labels: &[Label],

    ) -> Result<Contents, TransactionError> {

        let title = title.trim();

        if title.is_empty() {

            return Err(TransactionError::InvalidValue("title"));

        }

        let mut doc = Automerge::new();

        let _issue = doc

            .transact_with::<_, _, TransactionError, _, ()>(

                |_| CommitOptions::default().with_message("Create issue".to_owned()),

                |tx| {

                    let issue = tx.put_object(ObjId::Root, "issue", ObjType::Map)?;

                    tx.put(&issue, "title", title)?;

                    tx.put(&issue, "author", author)?;

                    tx.put(&issue, "state", State::Open)?;

                    tx.put(&issue, "timestamp", timestamp)?;

                    tx.put_object(&issue, "discussion", ObjType::List)?;

                    let labels_id = tx.put_object(&issue, "labels", ObjType::Map)?;

                    for label in labels {

                        tx.put(&labels_id, label.name().trim(), true)?;

                    }

                    // Nb. The top-level comment doesn't have a `replies` field.

                    let comment_id = tx.put_object(&issue, "comment", ObjType::Map)?;

                    tx.put(&comment_id, "body", description.trim())?;

                    tx.put(&comment_id, "author", author)?;

                    tx.put(&comment_id, "timestamp", timestamp)?;

                    tx.put_object(&comment_id, "reactions", ObjType::Map)?;

                    Ok(issue)

                },

            )

            .map_err(|failure| failure.error)?

            .result;

        Ok(doc.save_incremental())

    }

    pub fn comment(

        issue: &mut Automerge,

        author: &Author,

        body: &str,

        timestamp: Timestamp,

    ) -> Result<Contents, TransactionError> {

        let _comment = issue

            .transact_with::<_, _, TransactionError, _, ()>(

                |_| CommitOptions::default().with_message("Add comment".to_owned()),

                |tx| {

                    let mut tx = Transaction::new(tx);

                    let (_obj, obj_id) = tx.get(ObjId::Root, "issue")?;

                    let (_, discussion_id) = tx.get(&obj_id, "discussion")?;

                    let length = tx.length(&discussion_id);

                    let comment = tx.insert_object(&discussion_id, length, ObjType::Map)?;

                    tx.put(&comment, "author", author)?;

                    tx.put(&comment, "body", body.trim())?;

                    tx.put(&comment, "timestamp", timestamp)?;

                    tx.put_object(&comment, "replies", ObjType::List)?;

                    tx.put_object(&comment, "reactions", ObjType::Map)?;

                    Ok(comment)

                },

            )

            .map_err(|failure| failure.error)?

            .result;

        #[allow(clippy::unwrap_used)]

        let change = issue.get_last_local_change().unwrap().raw_bytes().to_vec();

        Ok(change)

    }

    pub fn lifecycle(

        issue: &mut Automerge,

        author: &Author,

        state: State,

    ) -> Result<Contents, TransactionError> {

        issue

            .transact_with::<_, _, TransactionError, _, ()>(

                |_| CommitOptions::default().with_message(state.lifecycle_message()),

                |tx| {

                    let mut tx = Transaction::new(tx);

                    let (_, obj_id) = tx.get(ObjId::Root, "issue")?;

                    tx.put(&obj_id, "state", state)?;

                    tx.put(&obj_id, "author", author)?;

                    Ok(())

                },

            )

            .map_err(|failure| failure.error)?;

        #[allow(clippy::unwrap_used)]

        let change = issue.get_last_local_change().unwrap().raw_bytes().to_vec();

        Ok(change)

    }

    pub fn label(

        issue: &mut Automerge,

        _author: &Author,

        labels: &[Label],

    ) -> Result<Contents, TransactionError> {

        issue

            .transact_with::<_, _, TransactionError, _, ()>(

                |_| CommitOptions::default().with_message("Label issue".to_owned()),

                |tx| {

                    let mut tx = Transaction::new(tx);

                    let (_, obj_id) = tx.get(ObjId::Root, "issue")?;

                    let (_, labels_id) = tx.get(&obj_id, "labels")?;

                    for label in labels {

                        tx.put(&labels_id, label.name().trim(), true)?;

                    }

                    Ok(())

                },

            )

            .map_err(|failure| failure.error)?;

        #[allow(clippy::unwrap_used)]

        let change = issue.get_last_local_change().unwrap().raw_bytes().to_vec();

        Ok(change)

    }

    pub fn reply(

        issue: &mut Automerge,

        comment_id: CommentId,

        author: &Author,

        body: &str,

        timestamp: Timestamp,

    ) -> Result<Contents, TransactionError> {

        issue

            .transact_with::<_, _, TransactionError, _, ()>(

                |_| CommitOptions::default().with_message("Reply".to_owned()),

                |tx| {

                    let mut tx = Transaction::new(tx);

                    let (_, obj_id) = tx.get(ObjId::Root, "issue")?;

                    let (_, discussion_id) = tx.get(&obj_id, "discussion")?;

                    let (_, comment_id) = tx.get(&discussion_id, usize::from(comment_id))?;

                    let (_, replies_id) = tx.get(&comment_id, "replies")?;

                    let length = tx.length(&replies_id);

                    let reply = tx.insert_object(&replies_id, length, ObjType::Map)?;

                    // Nb. Replies don't themselves have replies.

                    tx.put(&reply, "author", author)?;

                    tx.put(&reply, "body", body.trim())?;

                    tx.put(&reply, "timestamp", timestamp)?;

                    tx.put_object(&reply, "reactions", ObjType::Map)?;

                    Ok(())

                },

            )

            .map_err(|failure| failure.error)?;

        #[allow(clippy::unwrap_used)]

        let change = issue.get_last_local_change().unwrap().raw_bytes().to_vec();

        Ok(change)

    }

    pub fn react(

        issue: &mut Automerge,

        comment_id: CommentId,

        author: &Author,

        reactions: &[Reaction],

    ) -> Result<Contents, TransactionError> {

        issue

            .transact_with::<_, _, TransactionError, _, ()>(

                |_| CommitOptions::default().with_message("React".to_owned()),

                |tx| {

                    let mut tx = Transaction::new(tx);

                    let (_, obj_id) = tx.get(ObjId::Root, "issue")?;

                    let (_, discussion_id) = tx.get(&obj_id, "discussion")?;

                    let (_, comment_id) = if comment_id == CommentId::root() {

                        tx.get(&obj_id, "comment")?

                    } else {

                        tx.get(&discussion_id, usize::from(comment_id) - 1)?

                    };

                    let (_, reactions_id) = tx.get(&comment_id, "reactions")?;

                    for reaction in reactions {

                        let key = reaction.emoji.to_string();

                        let reaction_id = if let Some((_, reaction_id)) =

                            tx.try_get(&reactions_id, key)?

                        {

                            reaction_id

                        } else {

                            tx.put_object(&reactions_id, reaction.emoji.to_string(), ObjType::Map)?

                        };

                        tx.put(&reaction_id, author.id.to_human(), true)?;

                    }

                    Ok(())

                },

            )

            .map_err(|failure| failure.error)?;

        #[allow(clippy::unwrap_used)]

        let change = issue.get_last_local_change().unwrap().raw_bytes().to_vec();

        Ok(change)

    }

}

#[cfg(test)]

mod test {

    use super::*;

    use crate::test;

    #[test]

    fn test_issue_create_and_get() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let store = Store::open(*signer.public_key(), &project).unwrap();

        let issues = store.issues();

        let timestamp = Timestamp::now();

        let issue_id = issues

            .create("My first issue", "Blah blah blah.", &[], &signer)

            .unwrap();

        let issue = issues.get(&issue_id).unwrap().unwrap();

        assert_eq!(issue.title(), "My first issue");

        assert_eq!(issue.author(), &store.author());

        assert_eq!(issue.description(), "Blah blah blah.");

        assert_eq!(issue.comments().len(), 0);

        assert_eq!(issue.state(), State::Open);

        assert!(issue.timestamp() >= timestamp);

    }

    #[test]

    fn test_issue_create_and_change_state() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let store = Store::open(*signer.public_key(), &project).unwrap();

        let issues = store.issues();

        let issue_id = issues

            .create("My first issue", "Blah blah blah.", &[], &signer)

            .unwrap();

        issues

            .lifecycle(

                &issue_id,

                State::Closed {

                    reason: CloseReason::Other,

                },

                &signer,

            )

            .unwrap();

        let issue = issues.get(&issue_id).unwrap().unwrap();

        assert_eq!(

            issue.state(),

            State::Closed {

                reason: CloseReason::Other

            }

        );

        issues.lifecycle(&issue_id, State::Open, &signer).unwrap();

        let issue = issues.get(&issue_id).unwrap().unwrap();

        assert_eq!(issue.state(), State::Open);

    }

    #[test]

    fn test_issue_react() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let store = Store::open(*signer.public_key(), &project).unwrap();

        let issues = store.issues();

        let issue_id = issues

            .create("My first issue", "Blah blah blah.", &[], &signer)

            .unwrap();

        let reaction = Reaction::new('🥳').unwrap();

        issues

            .react(&issue_id, CommentId::root(), reaction, &signer)

            .unwrap();

        let issue = issues.get(&issue_id).unwrap().unwrap();

        let count = issue.reactions()[&reaction];

        // TODO: Test multiple reactions from same author and different authors

        assert_eq!(count, 1);

    }

    #[test]

    fn test_issue_reply() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let store = Store::open(*signer.public_key(), &project).unwrap();

        let issues = store.issues();

        let issue_id = issues

            .create("My first issue", "Blah blah blah.", &[], &signer)

            .unwrap();

        issues.comment(&issue_id, "Ho ho ho.", &signer).unwrap();

        issues

            .reply(&issue_id, CommentId::root(), "Hi hi hi.", &signer)

            .unwrap();

        issues

            .reply(&issue_id, CommentId::root(), "Ha ha ha.", &signer)

            .unwrap();

        let issue = issues.get(&issue_id).unwrap().unwrap();

        let reply1 = &issue.comments()[0].replies[0];

        let reply2 = &issue.comments()[0].replies[1];

        assert_eq!(reply1.body, "Hi hi hi.");

        assert_eq!(reply2.body, "Ha ha ha.");

    }

    #[test]

    fn test_issue_label() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let store = Store::open(*signer.public_key(), &project).unwrap();

        let issues = store.issues();

        let issue_id = issues

            .create("My first issue", "Blah blah blah.", &[], &signer)

            .unwrap();

        let bug_label = Label::new("bug").unwrap();

        let wontfix_label = Label::new("wontfix").unwrap();

        issues

            .label(&issue_id, &[bug_label.clone()], &signer)

            .unwrap();

        issues

            .label(&issue_id, &[wontfix_label.clone()], &signer)

            .unwrap();

        let issue = issues.get(&issue_id).unwrap().unwrap();

        let labels = issue.labels();

        assert!(labels.contains(&bug_label));

        assert!(labels.contains(&wontfix_label));

    }

    #[test]

    fn test_issue_comment() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let store = Store::open(*signer.public_key(), &project).unwrap();

        let issues = store.issues();

        let now = Timestamp::now();

        let author = *signer.public_key();

        let issue_id = issues

            .create("My first issue", "Blah blah blah.", &[], &signer)

            .unwrap();

        issues.comment(&issue_id, "Ho ho ho.", &signer).unwrap();

        issues.comment(&issue_id, "Ha ha ha.", &signer).unwrap();

        let issue = issues.get(&issue_id).unwrap().unwrap();

        let c1 = &issue.comments()[0];

        let c2 = &issue.comments()[1];

        assert_eq!(&c1.body, "Ho ho ho.");

        assert_eq!(c1.author.id(), &author);

        assert_eq!(&c2.body, "Ha ha ha.");

        assert_eq!(c2.author.id(), &author);

        assert!(c1.timestamp >= now);

    }

    #[test]

    fn test_issue_state_serde() {

        assert_eq!(

            serde_json::to_value(State::Open).unwrap(),

            serde_json::json!({ "status": "open" })

        );

        assert_eq!(

            serde_json::to_value(State::Closed {

                reason: CloseReason::Solved

            })

            .unwrap(),

            serde_json::json!({ "status": "closed", "reason": "solved" })

        );

    }

    #[test]

    fn test_issue_all() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let store = Store::open(*signer.public_key(), &project).unwrap();

        let issues = store.issues();

        let author = store.author();

        let contents =

            events::create(&author, "First", "Blah blah.", Timestamp::new(0), &[]).unwrap();

        issues

            .store

            .create("Create issue", contents, &signer)

            .unwrap();

        let contents =

            events::create(&author, "Second", "Blah blah.", Timestamp::new(1), &[]).unwrap();

        issues

            .store

            .create("Create issue", contents, &signer)

            .unwrap();

        let contents =

            events::create(&author, "Third", "Blah blah.", Timestamp::new(2), &[]).unwrap();

        issues

            .store

            .create("Create issue", contents, &signer)

            .unwrap();

        let issues = issues.all().unwrap();

        assert_eq!(issues.len(), 3);

        // Issues are sorted by timestamp.

        assert_eq!(issues[0].1.title(), "First");

        assert_eq!(issues[1].1.title(), "Second");

        assert_eq!(issues[2].1.title(), "Third");

    }

}

#![allow(clippy::large_enum_variant)]

use std::convert::TryFrom;

use std::ops::ControlFlow;

use std::str::FromStr;

use automerge::{Automerge, ObjType};

use once_cell::sync::Lazy;

use serde::{Deserialize, Serialize};

use crate::cob::automerge::doc::Document;

use crate::cob::automerge::shared::FromHistory;

use crate::cob::automerge::store::{Error, Store};

use crate::cob::automerge::transaction::TransactionError;

use crate::cob::common::*;

use crate::cob::{Contents, History, ObjectId, Timestamp, TypeName};

use crate::prelude::*;

pub static TYPENAME: Lazy<TypeName> =

    Lazy::new(|| FromStr::from_str("xyz.radicle.label").expect("type name is valid"));

/// Identifier for a label.

pub type LabelId = ObjectId;

/// Describes a label.

#[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]

pub struct Label {

    pub name: String,

    pub description: String,

    pub color: Color,

}

impl FromHistory for Label {

    fn type_name() -> &'static TypeName {

        &TYPENAME

    }

    fn from_history(history: &History) -> Result<Self, Error> {

        Label::try_from(history)

    }

}

impl TryFrom<&History> for Label {

    type Error = Error;

    fn try_from(history: &History) -> Result<Self, Self::Error> {

        let doc = history.traverse(Automerge::new(), |mut doc, entry| {

            let bytes = entry.contents();

            match automerge::Change::from_bytes(bytes.clone()) {

                Ok(change) => {

                    doc.apply_changes([change]).ok();

                }

                Err(_err) => {

                    // Ignore

                }

            }

            ControlFlow::Continue(doc)

        });

        let label = Label::try_from(doc)?;

        Ok(label)

    }

}

impl TryFrom<Automerge> for Label {

    type Error = Error;

    fn try_from(doc: Automerge) -> Result<Self, Self::Error> {

        let doc = Document::new(&doc);

        let obj_id = doc.get_id(automerge::ObjId::Root, "label")?;

        let name = doc.get(&obj_id, "name")?;

        let description = doc.get(&obj_id, "description")?;

        let color = doc.get(&obj_id, "color")?;

        Ok(Self {

            name,

            description,

            color,

        })

    }

}

pub struct LabelStore<'a> {

    store: Store<'a, Label>,

}

impl<'a> LabelStore<'a> {

    pub fn new(store: Store<'a, Label>) -> Self {

        Self { store }

    }

    pub fn create<G: Signer>(

        &self,

        name: &str,

        description: &str,

        color: &Color,

        signer: &G,

    ) -> Result<LabelId, Error> {

        let author = self.store.author();

        let _timestamp = Timestamp::now();

        let contents = events::create(&author, name, description, color)?;

        let cob = self.store.create("Create label", contents, signer)?;

        Ok(*cob.id())

    }

    pub fn get(&self, id: &LabelId) -> Result<Option<Label>, Error> {

        self.store.get(id)

    }

}

mod events {

    use super::*;

    use automerge::{

        transaction::{CommitOptions, Transactable},

        ObjId,

    };

    pub fn create(

        _author: &Author,

        name: &str,

        description: &str,

        color: &Color,

    ) -> Result<Contents, TransactionError> {

        let name = name.trim();

        if name.is_empty() {

            return Err(TransactionError::InvalidValue("name"));

        }

        let mut doc = Automerge::new();

        doc.transact_with::<_, _, TransactionError, _, ()>(

            |_| CommitOptions::default().with_message("Create label".to_owned()),

            |tx| {

                let label = tx.put_object(ObjId::Root, "label", ObjType::Map)?;

                tx.put(&label, "name", name)?;

                tx.put(&label, "description", description)?;

                tx.put(&label, "color", color.to_string())?;

                Ok(label)

            },

        )

        .map_err(|failure| failure.error)?;

        Ok(doc.save_incremental())

    }

}

#[cfg(test)]

mod test {

    use super::*;

    use crate::test;

    #[test]

    fn test_label_create_and_get() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let store = Store::open(*signer.public_key(), &project).unwrap();

        let labels = store.labels();

        let label_id = labels

            .create(

                "bug",

                "Something that doesn't work",

                &Color::from_str("#ff0000").unwrap(),

                &signer,

            )

            .unwrap();

        let label = labels.get(&label_id).unwrap().unwrap();

        assert_eq!(label.name, "bug");

        assert_eq!(label.description, "Something that doesn't work");

        assert_eq!(label.color.to_string(), "#ff0000");

    }

}

#![allow(clippy::too_many_arguments)]

use std::collections::{HashMap, HashSet};

use std::convert::TryFrom;

use std::ops::{ControlFlow, Deref};

use std::sync::Arc;

use automerge::transaction::Transactable;

use automerge::{Automerge, AutomergeError, ObjType, ScalarValue, Value};

use nonempty::NonEmpty;

use crate::cob::automerge::doc::{Document, DocumentError};

use crate::cob::automerge::shared;

use crate::cob::automerge::shared::*;

use crate::cob::automerge::store::{Error, Store};

use crate::cob::automerge::transaction::{Transaction, TransactionError};

use crate::cob::automerge::value::{FromValue, ValueError};

use crate::cob::common::*;

use crate::cob::{Contents, History, ObjectId, Timestamp, TypeName};

use crate::git;

use crate::prelude::*;

// Re-export generic patch.

pub use crate::cob::patch::*;

impl TryFrom<Document<'_>> for Patch {

    type Error = DocumentError;

    fn try_from(doc: Document) -> Result<Self, Self::Error> {

        let obj_id = doc.get_id(automerge::ObjId::Root, "patch")?;

        let title = doc.get(&obj_id, "title")?;

        let author = doc.get(&obj_id, "author")?;

        let state = doc.get(&obj_id, "state")?;

        let target = doc.get(&obj_id, "target")?;

        let timestamp = doc.get(&obj_id, "timestamp")?;

        let revisions = doc.list(&obj_id, "revisions", lookup::revision)?;

        let labels: HashSet<Label> = doc.keys(&obj_id, "labels")?;

        let revisions =

            NonEmpty::from_vec(revisions).ok_or(DocumentError::EmptyList("revisions"))?;

        let author: Author = Author::new(author);

        Ok(Self {

            author,

            title,

            state,

            target,

            labels,

            revisions,

            timestamp,

        })

    }

}

pub struct PatchStore<'a> {

    store: Store<'a, Patch>,

}

impl<'a> Deref for PatchStore<'a> {

    type Target = Store<'a, Patch>;

    fn deref(&self) -> &Self::Target {

        &self.store

    }

}

impl<'a> PatchStore<'a> {

    /// Create a new patch store.

    pub fn new(store: Store<'a, Patch>) -> Self {

        Self { store }

    }

    /// Get a patch by id.

    pub fn get(&self, id: &ObjectId) -> Result<Option<Patch>, Error> {

        self.store.get(id)

    }

    /// Create a patch.

    pub fn create<G: Signer>(

        &self,

        title: &str,

        description: &str,

        target: MergeTarget,

        base: impl Into<git::Oid>,

        oid: impl Into<git::Oid>,

        labels: &[Label],

        signer: &G,

    ) -> Result<PatchId, Error> {

        let author = self.author();

        let timestamp = Timestamp::now();

        let revision = Revision::new(

            author.clone(),

            base.into(),

            oid.into(),

            description.to_owned(),

            timestamp,

        );

        let contents = events::create(&author, title, &revision, target, timestamp, labels)?;

        let cob = self.store.create("Create patch", contents, signer)?;

        Ok(*cob.id())

    }

    /// Comment on a patch.

    pub fn comment<G: Signer>(

        &self,

        patch_id: &PatchId,

        revision_ix: RevisionIx,

        body: &str,

        signer: &G,

    ) -> Result<(), Error> {

        let author = self.author();

        let mut patch = self.store.get_raw(patch_id)?;

        let timestamp = Timestamp::now();

        let changes = events::comment(&mut patch, revision_ix, &author, body, timestamp)?;

        self.store

            .update(*patch_id, "Add comment", changes, signer)?;

        Ok(())

    }

    /// Update a patch with new code. Creates a new revision.

    pub fn update<G: Signer>(

        &self,

        patch_id: &PatchId,

        comment: impl ToString,

        base: impl Into<git::Oid>,

        oid: impl Into<git::Oid>,

        signer: &G,

    ) -> Result<RevisionIx, Error> {

        let author = self.author();

        let timestamp = Timestamp::now();

        let revision = Revision::new(

            author,

            base.into(),

            oid.into(),

            comment.to_string(),

            timestamp,

        );

        let mut patch = self.get_raw(patch_id)?;

        let (revision_ix, changes) = events::update(&mut patch, revision)?;

        self.store

            .update(*patch_id, "Update patch", changes, signer)?;

        Ok(revision_ix)

    }

    /// Reply to a patch comment.

    pub fn reply<G: Signer>(

        &self,

        patch_id: &PatchId,

        revision_ix: RevisionIx,

        comment_id: CommentId,

        reply: &str,

        signer: &G,

    ) -> Result<(), Error> {

        let author = self.author();

        let mut patch = self.get_raw(patch_id)?;

        let changes = events::reply(

            &mut patch,

            revision_ix,

            comment_id,

            &author,

            reply,

            Timestamp::now(),

        )?;

        self.store.update(*patch_id, "Reply", changes, signer)?;

        Ok(())

    }

    /// Review a patch revision.

    pub fn review<G: Signer>(

        &self,

        patch_id: &PatchId,

        revision_ix: RevisionIx,

        verdict: Option<Verdict>,

        comment: impl Into<String>,

        inline: Vec<CodeComment>,

        signer: &G,

    ) -> Result<(), Error> {

        let timestamp = Timestamp::now();

        let review = Review::new(self.author(), verdict, comment, inline, timestamp);

        let mut patch = self.get_raw(patch_id)?;

        let (_, changes) = events::review(&mut patch, revision_ix, review)?;

        self.store

            .update(*patch_id, "Review patch", changes, signer)?;

        Ok(())

    }

    /// Merge a patch revision.

    pub fn merge<G: Signer>(

        &self,

        patch_id: &PatchId,

        revision_ix: RevisionIx,

        commit: git::Oid,

        signer: &G,

    ) -> Result<Merge, Error> {

        let timestamp = Timestamp::now();

        let merge = Merge {

            node: *signer.public_key(),

            commit,

            timestamp,

        };

        let mut patch = self.get_raw(patch_id)?;

        let changes = events::merge(&mut patch, revision_ix, &merge)?;

        self.store

            .update(*patch_id, "Merge revision", changes, signer)?;

        Ok(merge)

    }

    /// Get the patch count.

    pub fn count(&self) -> Result<usize, Error> {

        let cobs = self.store.list()?;

        Ok(cobs.len())

    }

    /// Get all patches for this project.

    pub fn all(&self) -> Result<Vec<(PatchId, Patch)>, Error> {

        let mut patches = self.store.list()?;

        patches.sort_by_key(|(_, p)| p.timestamp);

        Ok(patches)

    }

    /// Get proposed patches.

    pub fn proposed(&self) -> Result<impl Iterator<Item = (PatchId, Patch)>, Error> {

        let all = self.all()?;

        Ok(all.into_iter().filter(|(_, p)| p.is_proposed()))

    }

    /// Get patches proposed by the given key.

    pub fn proposed_by<'b>(

        &'b self,

        who: &'b PublicKey,

    ) -> Result<impl Iterator<Item = (PatchId, Patch)> + '_, Error> {

        Ok(self.proposed()?.filter(move |(_, p)| p.author.id() == who))

    }

}

impl From<State> for ScalarValue {

    fn from(state: State) -> Self {

        match state {

            State::Proposed => ScalarValue::from("proposed"),

            State::Draft => ScalarValue::from("draft"),

            State::Archived => ScalarValue::from("archived"),

        }

    }

}

impl<'a> FromValue<'a> for State {

    fn from_value(value: Value<'a>) -> Result<Self, ValueError> {

        let state = value.to_str().ok_or(ValueError::InvalidType)?;

        match state {

            "proposed" => Ok(Self::Proposed),

            "draft" => Ok(Self::Draft),

            "archived" => Ok(Self::Archived),

            _ => Err(ValueError::InvalidValue(value.to_string())),

        }

    }

}

impl Revision {

    /// Put this object into an automerge document.

    fn put<'a>(

        &self,

        mut tx: impl AsMut<automerge::transaction::Transaction<'a>>,

        id: &automerge::ObjId,

    ) -> Result<(), AutomergeError> {

        assert!(

            self.merges.is_empty(),

            "Cannot put revision with non-empty merges"

        );

        assert!(

            self.reviews.is_empty(),

            "Cannot put revision with non-empty reviews"

        );

        assert!(

            self.discussion.is_empty(),

            "Cannot put revision with non-empty discussion"

        );

        let tx = tx.as_mut();

        tx.put(id, "id", self.id.to_string())?;

        tx.put(id, "oid", self.oid.to_string())?;

        tx.put(id, "base", self.base.to_string())?;

        self.comment.put(tx, id)?;

        tx.put_object(id, "discussion", ObjType::List)?;

        tx.put_object(id, "reviews", ObjType::Map)?;

        tx.put_object(id, "merges", ObjType::List)?;

        tx.put(id, "timestamp", self.timestamp)?;

        Ok(())

    }

}

impl From<Verdict> for ScalarValue {

    fn from(verdict: Verdict) -> Self {

        #[allow(clippy::unwrap_used)]

        let s = serde_json::to_string(&verdict).unwrap(); // Cannot fail.

        ScalarValue::from(s)

    }

}

impl<'a> FromValue<'a> for Verdict {

    fn from_value(value: Value) -> Result<Self, ValueError> {

        let verdict = value.to_str().ok_or(ValueError::InvalidType)?;

        serde_json::from_str(verdict).map_err(|e| ValueError::Other(Arc::new(e)))

    }

}

impl Review {

    /// Put this object into an automerge document.

    fn put<'a>(

        &self,

        mut tx: impl AsMut<automerge::transaction::Transaction<'a>>,

        id: &automerge::ObjId,

    ) -> Result<(), AutomergeError> {

        assert!(

            self.inline.is_empty(),

            "Cannot put review with non-empty inline comments"

        );

        let tx = tx.as_mut();

        tx.put(id, "author", &self.author)?;