ironoxide 4.3.1

use crate::{
    DeviceSigningKeyPair, PolicyCache,
    config::{IronOxideConfig, PolicyCachingConfig},
    crypto::{
        aes::{self, AesEncryptedValue},
        transform,
    },
    internal::{
        self, IronOxideErr, PrivateKey, PublicKey, PublicKeyCache, RequestAuth, WithKey,
        document_api::requests::UserOrGroupWithKey,
        group_api::{GroupId, GroupName},
        take_lock,
        user_api::UserId,
        validate_id, validate_name,
    },
    policy::PolicyGrant,
    proto::transform::{
        EncryptedDek as EncryptedDekP, EncryptedDekData as EncryptedDekDataP,
        EncryptedDeks as EncryptedDeksP, user_or_group::UserOrGroupId as UserOrGroupIdP,
    },
};
use futures::{Future, try_join};
use hex::encode;
use itertools::{Either, Itertools};
use protobuf::Message;
use rand::{self, CryptoRng};
use recrypt::{api::Plaintext, prelude::*};
use requests::{
    DocumentMetaApiResponse, document_create,
    document_list::{DocumentListApiResponse, DocumentListApiResponseItem},
    policy_get::PolicyResponse,
};
use serde::{Deserialize, Serialize};
use std::{
    convert::{TryFrom, TryInto, identity},
    fmt::{Debug, Formatter},
    ops::DerefMut,
    sync::Mutex,
};
use time::OffsetDateTime;

pub mod file_ops;
mod requests;

const DOC_VERSION_HEADER_LENGTH: usize = 1;
const HEADER_META_LENGTH_LENGTH: usize = 2;
const CURRENT_DOCUMENT_ID_VERSION: u8 = 2;

pub(crate) fn parse_header_length(header_prefix: &[u8; 3]) -> Result<usize, IronOxideErr> {
    //We're explicitly erroring on version 1 documents since there are so few of them and it seems extremely unlikely
    //that anybody will use them with this SDK which was released after we went to version 2.
    if header_prefix[0] != CURRENT_DOCUMENT_ID_VERSION {
        return Err(IronOxideErr::DocumentHeaderParseFailure(
            "Document is not a supported version and may not be an encrypted file.".to_string(),
        ));
    }
    //The 2nd and 3rd bytes of the header are a big-endian u16 that tell us how long the subsequent JSON
    //header is in bytes. So we need to convert these two u8s into a single u16.
    let encoded_header_size = header_prefix[1] as usize * 256 + header_prefix[2] as usize;
    Ok(DOC_VERSION_HEADER_LENGTH + HEADER_META_LENGTH_LENGTH + encoded_header_size)
}

/// ID of a document.
///
/// The ID can be validated from a `String` or `&str` using `DocumentId::try_from`.
///
/// # Requirements
/// - Must be unique within the document's segment.
/// - Must match the regex `^[a-zA-Z0-9_.$#|@/:;=+'-]+$`.
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub struct DocumentId(pub(crate) String);
impl DocumentId {
    /// ID of the document.
    pub fn id(&self) -> &str {
        &self.0
    }

    /// Generate a random id for a document
    pub(crate) fn goo_id<R: CryptoRng>(rng: &Mutex<R>) -> DocumentId {
        let mut id = [0u8; 16];
        take_lock(rng).deref_mut().fill_bytes(&mut id);
        DocumentId(encode(id))
    }
}
impl TryFrom<&str> for DocumentId {
    type Error = IronOxideErr;
    fn try_from(id: &str) -> Result<Self, Self::Error> {
        validate_id(id, "document_id").map(DocumentId)
    }
}
impl TryFrom<String> for DocumentId {
    type Error = IronOxideErr;
    fn try_from(doc_id: String) -> Result<Self, Self::Error> {
        doc_id.as_str().try_into()
    }
}

/// Name of a document.
///
/// The name should be human-readable and does not have to be unique.
/// It can be validated from a `String` or `&str` using `DocumentName::try_from`.
///
/// # Requirements
/// - Must be between 1 and 100 characters long.
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub struct DocumentName(pub(crate) String);
impl DocumentName {
    /// Name of the document.
    pub fn name(&self) -> &String {
        &self.0
    }
}
impl TryFrom<&str> for DocumentName {
    type Error = IronOxideErr;
    fn try_from(name: &str) -> Result<Self, Self::Error> {
        validate_name(name, "document_name").map(DocumentName)
    }
}
impl TryFrom<String> for DocumentName {
    type Error = IronOxideErr;
    fn try_from(doc_name: String) -> Result<Self, Self::Error> {
        doc_name.as_str().try_into()
    }
}

/// Binary version of the document header. Appropriate for using in edoc serialization.
pub(crate) struct DocHeaderPacked(pub Vec<u8>);

/// Represents a parsed document header which is decoded from JSON
#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub(crate) struct DocumentHeader {
    #[serde(rename = "_did_")]
    pub document_id: DocumentId,
    #[serde(rename = "_sid_")]
    pub segment_id: usize,
}
impl DocumentHeader {
    pub(crate) fn new(document_id: DocumentId, segment_id: usize) -> DocumentHeader {
        DocumentHeader {
            document_id,
            segment_id,
        }
    }
    /// Generate a documents header given its ID and internal segment ID that is is associated with. Generates
    /// a Vec<u8> which includes the document version, header size, and header JSON as bytes.
    pub(crate) fn pack(&self) -> DocHeaderPacked {
        let mut header_json_bytes =
            serde_json::to_vec(&self).expect("Serialization of DocumentHeader failed."); //Serializing a string and number shouldn't fail
        let header_json_len = header_json_bytes.len();
        //Make header vector with size of header plus 1 byte for version and 2 bytes for header length
        let mut header = Vec::with_capacity(header_json_len + 3);
        header.push(CURRENT_DOCUMENT_ID_VERSION);
        //Push the header length representation as two bytes, most significant digit first (BigEndian)
        header.push((header_json_len >> 8) as u8);
        header.push(header_json_len as u8);
        header.append(&mut header_json_bytes);
        DocHeaderPacked(header)
    }
}

/// Take an encrypted document and extract out the header metadata. Return that metadata as well as the AESEncryptedValue
/// that contains the AES IV and encrypted content. Will fail if the provided document doesn't contain the latest version
/// which contains the header bytes.
fn parse_document_parts(
    encrypted_document: &[u8],
) -> Result<(DocumentHeader, aes::AesEncryptedValue), IronOxideErr> {
    let header_len = parse_header_length(encrypted_document[..3].try_into().map_err(|_| {
        IronOxideErr::DocumentHeaderParseFailure(
            "Document is too short to contain a valid header".to_string(),
        )
    })?)?;
    let header_json_start = DOC_VERSION_HEADER_LENGTH + HEADER_META_LENGTH_LENGTH;
    serde_json::from_slice(&encrypted_document[header_json_start..header_len])
        .map_err(|_| {
            IronOxideErr::DocumentHeaderParseFailure(
                "Unable to parse document header. Header value is corrupted.".to_string(),
            )
        })
        .and_then(|header_json| {
            // Convert the remaining document bytes into an AesEncryptedValue which splits out the IV/data
            Ok((header_json, encrypted_document[header_len..].try_into()?))
        })
}

/// The reason a document can be viewed by the requesting user.
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum AssociationType {
    /// User created the document.
    Owner,
    /// User was directly granted access to the document.
    FromUser,
    /// User was granted access to the document via a group they are a member of.
    FromGroup,
}

/// User who is able to access a document.
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub struct VisibleUser {
    id: UserId,
}
impl VisibleUser {
    /// ID of the user
    pub fn id(&self) -> &UserId {
        &self.id
    }
}

/// Group that is able to access a document.
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub struct VisibleGroup {
    id: GroupId,
    name: Option<GroupName>,
}
impl VisibleGroup {
    /// ID of the group
    pub fn id(&self) -> &GroupId {
        &self.id
    }
    /// Name of the group
    pub fn name(&self) -> Option<&GroupName> {
        self.name.as_ref()
    }
}

/// Abbreviated document metadata.
///
/// Result from [DocumentListResult.result()](struct.DocumentListResult.html#method.result).
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct DocumentListMeta(DocumentListApiResponseItem);
impl DocumentListMeta {
    /// ID of the document
    pub fn id(&self) -> &DocumentId {
        &self.0.id
    }
    /// Name of the document
    pub fn name(&self) -> Option<&DocumentName> {
        self.0.name.as_ref()
    }
    /// How the requesting user has access to the document
    pub fn association_type(&self) -> &AssociationType {
        &self.0.association.typ
    }
    /// Date and time when the document was created
    pub fn created(&self) -> &OffsetDateTime {
        &self.0.created
    }
    /// Date and time when the document was last updated
    pub fn last_updated(&self) -> &OffsetDateTime {
        &self.0.updated
    }
}

/// Metadata for each document the current user has access to.
///
/// Result from [document_list](trait.DocumentOps.html#tymethod.document_list).
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct DocumentListResult {
    result: Vec<DocumentListMeta>,
}
impl DocumentListResult {
    /// Metadata for each document the current user has access to
    pub fn result(&self) -> &Vec<DocumentListMeta> {
        &self.result
    }
}

/// Full metadata for a document.
///
/// Result from [document_get_metadata](trait.DocumentOps.html#tymethod.document_get_metadata) and
/// [document_update_name](trait.DocumentOps.html#tymethod.document_update_name).
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct DocumentMetadataResult(DocumentMetaApiResponse);
impl DocumentMetadataResult {
    /// ID of the document
    pub fn id(&self) -> &DocumentId {
        &self.0.id
    }
    /// Name of the document
    pub fn name(&self) -> Option<&DocumentName> {
        self.0.name.as_ref()
    }
    /// Date and time when the document was created
    pub fn created(&self) -> &OffsetDateTime {
        &self.0.created
    }
    /// Date and time when the document was last updated
    pub fn last_updated(&self) -> &OffsetDateTime {
        &self.0.updated
    }
    /// How the requesting user has access to the document
    pub fn association_type(&self) -> &AssociationType {
        &self.0.association.typ
    }
    /// List of users who have access to the document
    pub fn visible_to_users(&self) -> &Vec<VisibleUser> {
        &self.0.visible_to.users
    }
    /// List of groups that have access to the document
    pub fn visible_to_groups(&self) -> &Vec<VisibleGroup> {
        &self.0.visible_to.groups
    }

    /// Get the encrypted symmetric key (for internal use)
    pub(crate) fn to_encrypted_symmetric_key(
        &self,
    ) -> Result<recrypt::api::EncryptedValue, IronOxideErr> {
        self.0.encrypted_symmetric_key.clone().try_into()
    }
}

/// Full metadata for an unmanaged document.
///
/// Result from [document_get_metadata_unmanaged](trait.DocumentOps.html#tymethod.document_get_metadata_unmanaged)
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct DocumentMetadataUnmanagedResult {
    id: DocumentId,
    user_visibility: Vec<VisibleUser>,
    group_visibility: Vec<VisibleGroup>,
}
impl DocumentMetadataUnmanagedResult {
    /// ID of the document
    pub fn id(&self) -> &DocumentId {
        &self.id
    }
    /// List of users who have access to the document
    pub fn visible_to_users(&self) -> &Vec<VisibleUser> {
        &self.user_visibility
    }
    /// List of groups that have access to the document
    pub fn visible_to_groups(&self) -> &Vec<VisibleGroup> {
        &self.group_visibility
    }
}

/// Encrypted document bytes and metadata.
///
/// Unmanaged encryption does not store document access information with the webservice,
/// but rather returns the access information as `encrypted_deks`. Both the `encrypted_data` and
/// `encrypted_deks` must be used to decrypt the document.
///
/// Result from [document_encrypt_unmanaged](trait.DocumentAdvancedOps.html#tymethod.document_encrypt_unmanaged).
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct DocumentEncryptUnmanagedResult {
    id: DocumentId,
    encrypted_data: Vec<u8>,
    encrypted_deks: Vec<u8>,
    grants: Vec<UserOrGroup>,
    access_errs: Vec<DocAccessEditErr>,
}
impl DocumentEncryptUnmanagedResult {
    fn new(
        encryption_result: EncryptedDoc,
        access_errs: Vec<DocAccessEditErr>,
    ) -> Result<Self, IronOxideErr> {
        let edek_bytes = encryption_result.edek_bytes()?;
        let encrypted_data = encryption_result.edoc_bytes().to_vec();
        Ok(DocumentEncryptUnmanagedResult {
            id: encryption_result.header.document_id,
            access_errs,
            encrypted_data,
            encrypted_deks: edek_bytes,
            grants: encryption_result
                .recryption_result
                .edeks
                .into_iter()
                .map(|edek| edek.grant_to.id)
                .collect(),
        })
    }

    /// Bytes of encrypted document data
    pub fn encrypted_data(&self) -> &[u8] {
        &self.encrypted_data
    }
    /// Bytes of EDEKs of users/groups that have been granted access to `encrypted_data`
    pub fn encrypted_deks(&self) -> &[u8] {
        &self.encrypted_deks
    }
    /// ID of the document
    pub fn id(&self) -> &DocumentId {
        &self.id
    }
    /// Users and groups the document was successfully encrypted to
    pub fn grants(&self) -> &[UserOrGroup] {
        &self.grants
    }
    /// Errors resulting from failure to encrypt
    pub fn access_errs(&self) -> &[DocAccessEditErr] {
        &self.access_errs
    }
}

/// Encrypted document bytes and metadata.
///
/// Result from [document_encrypt](trait.DocumentOps.html#tymethod.document_encrypt) and
/// [document_update_bytes](trait.DocumentOps.html#tymethod.document_update_bytes).
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct DocumentEncryptResult {
    id: DocumentId,
    name: Option<DocumentName>,
    updated: OffsetDateTime,
    created: OffsetDateTime,
    encrypted_data: Vec<u8>,
    grants: Vec<UserOrGroup>,
    access_errs: Vec<DocAccessEditErr>,
}
impl DocumentEncryptResult {
    /// Bytes of encrypted document data
    pub fn encrypted_data(&self) -> &[u8] {
        &self.encrypted_data
    }
    /// ID of the document
    pub fn id(&self) -> &DocumentId {
        &self.id
    }
    /// Name of the document
    pub fn name(&self) -> Option<&DocumentName> {
        self.name.as_ref()
    }
    /// Date and time when the document was created
    pub fn created(&self) -> &OffsetDateTime {
        &self.created
    }
    /// Date and time when the document was last updated
    pub fn last_updated(&self) -> &OffsetDateTime {
        &self.updated
    }
    /// Users and groups the document was successfully encrypted to
    pub fn grants(&self) -> &[UserOrGroup] {
        &self.grants
    }
    /// Errors resulting from failure to encrypt
    pub fn access_errs(&self) -> &[DocAccessEditErr] {
        &self.access_errs
    }
}
/// Decrypted document bytes and metadata.
///
/// Result from [document_decrypt](trait.DocumentOps.html#tymethod.document_decrypt).
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct DocumentDecryptResult {
    id: DocumentId,
    name: Option<DocumentName>,
    updated: OffsetDateTime,
    created: OffsetDateTime,
    decrypted_data: Vec<u8>,
}
impl DocumentDecryptResult {
    /// Bytes of decrypted document data
    pub fn decrypted_data(&self) -> &[u8] {
        &self.decrypted_data
    }
    /// ID of the document
    pub fn id(&self) -> &DocumentId {
        &self.id
    }
    /// Name of the document
    pub fn name(&self) -> Option<&DocumentName> {
        self.name.as_ref()
    }
    /// Date and time when the document was created
    pub fn created(&self) -> &OffsetDateTime {
        &self.created
    }
    /// Date and time when the document was last updated
    pub fn last_updated(&self) -> &OffsetDateTime {
        &self.updated
    }
}

/// Failure to edit a document's access list.
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct DocAccessEditErr {
    /// User or group that was unable to have access granted/revoked.
    pub user_or_group: UserOrGroup,
    /// The error encountered when attempting to grant/revoke access.
    pub err: String,
}
impl DocAccessEditErr {
    pub(crate) fn new(user_or_group: UserOrGroup, err_msg: String) -> DocAccessEditErr {
        DocAccessEditErr {
            user_or_group,
            err: err_msg,
        }
    }
}

/// Successful and failed changes to a document's access list.
///
/// Both grant and revoke support partial success.
///
/// Result from [document_grant_access](trait.DocumentOps.html#tymethod.document_grant_access) and
/// [document_revoke_access](trait.DocumentOps.html#tymethod.document_revoke_access).
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct DocumentAccessResult {
    succeeded: Vec<UserOrGroup>,
    failed: Vec<DocAccessEditErr>,
}
impl DocumentAccessResult {
    pub(crate) fn new(
        succeeded: Vec<UserOrGroup>,
        failed: Vec<DocAccessEditErr>,
    ) -> DocumentAccessResult {
        DocumentAccessResult { succeeded, failed }
    }

    /// Users and groups whose access was successfully changed.
    pub fn succeeded(&self) -> &[UserOrGroup] {
        &self.succeeded
    }

    /// Users and groups whose access failed to be changed.
    pub fn failed(&self) -> &[DocAccessEditErr] {
        &self.failed
    }
}
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
struct DecryptedData(Vec<u8>);

/// Decrypted document bytes and metadata.
///
/// Result from [document_decrypt_unmanaged](trait.DocumentAdvancedOps.html#tymethod.document_decrypt_unmanaged).
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct DocumentDecryptUnmanagedResult {
    id: DocumentId,
    access_via: UserOrGroup,
    decrypted_data: DecryptedData,
}
impl DocumentDecryptUnmanagedResult {
    /// ID of the document
    pub fn id(&self) -> &DocumentId {
        &self.id
    }
    /// User or group that granted access to the encrypted data
    ///
    /// More specifically, the user or group associated with the EDEK that was chosen and transformed by the webservice
    pub fn access_via(&self) -> &UserOrGroup {
        &self.access_via
    }
    /// Bytes of decrypted document data
    pub fn decrypted_data(&self) -> &[u8] {
        &self.decrypted_data.0
    }
}

/// Unmanaged grant result and metadata.
///
/// Result from [document_grant_access_unmanaged](trait.DocumentAdvancedOps.html#tymethod.document_grant_access_unmanaged)
/// and [document_revoke_access_unmanaged](trait.DocumentAdvancedOps.html#tymethod.document_revoke_access_unmanaged)
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct DocumentAccessUnmanagedResult {
    access_via: Option<UserOrGroup>,
    encrypted_deks: Vec<u8>,
    succeeded: Vec<UserOrGroup>,
    failed: Vec<DocAccessEditErr>,
}
impl DocumentAccessUnmanagedResult {
    /// User or group that granted ability to alter access
    ///
    /// More specifically, the user or group associated with the EDEK that was chosen and transformed by the webservice.
    /// `None` for offline operations like revoke that don't require server interaction.
    pub fn access_via(&self) -> Option<&UserOrGroup> {
        self.access_via.as_ref()
    }
    /// Updated EDEKs after the access change.
    pub fn encrypted_deks(&self) -> &[u8] {
        &self.encrypted_deks
    }
    /// Users and groups whose access was successfully changed.
    pub fn succeeded(&self) -> &[UserOrGroup] {
        &self.succeeded
    }
    /// Users and groups whose access failed to be changed.
    pub fn failed(&self) -> &[DocAccessEditErr] {
        &self.failed
    }
}

/// A user or a group.
///
/// Can be created from `UserId`, `&UserId`, `GroupId`, or `&GroupId` with `UserOrGroup::from()`.
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", tag = "type")]
pub enum UserOrGroup {
    User { id: UserId },
    Group { id: GroupId },
}
impl std::fmt::Display for UserOrGroup {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        match self {
            UserOrGroup::User { id } => write!(f, "'{}' [user]", &id.0),
            UserOrGroup::Group { id } => write!(f, "'{}' [group]", &id.0),
        }
    }
}
impl From<UserId> for UserOrGroup {
    fn from(u: UserId) -> Self {
        UserOrGroup::User { id: u }
    }
}
impl From<GroupId> for UserOrGroup {
    fn from(g: GroupId) -> Self {
        UserOrGroup::Group { id: g }
    }
}
impl From<&UserId> for UserOrGroup {
    fn from(u: &UserId) -> Self {
        u.to_owned().into()
    }
}
impl From<&GroupId> for UserOrGroup {
    fn from(g: &GroupId) -> Self {
        g.to_owned().into()
    }
}

/// List all documents that the current user has the ability to see. Either documents that are encrypted
/// to them directly (owner) or documents shared to them via user (fromUser) or group (fromGroup).
pub async fn document_list(auth: &RequestAuth) -> Result<DocumentListResult, IronOxideErr> {
    let DocumentListApiResponse { result } =
        requests::document_list::document_list_request(auth).await?;
    Ok(DocumentListResult {
        result: result.into_iter().map(DocumentListMeta).collect(),
    })
}

/// Get the metadata ane encrypted key for a specific document given its ID.
pub async fn document_get_metadata(
    auth: &RequestAuth,
    id: &DocumentId,
) -> Result<DocumentMetadataResult, IronOxideErr> {
    Ok(DocumentMetadataResult(
        requests::document_get::document_get_request(auth, id).await?,
    ))
}

/// Attempt to parse the provided encrypted document header and extract out the ID if present
pub fn get_id_from_bytes(encrypted_document: &[u8]) -> Result<DocumentId, IronOxideErr> {
    parse_document_parts(encrypted_document).map(|header| header.0.document_id)
}

/// Encrypt a new document and share it with explicit users/groups and with users/groups specified by a policy
pub async fn encrypt_document<R1: rand::CryptoRng, R2: rand::CryptoRng>(
    auth: &RequestAuth,
    config: &IronOxideConfig,
    recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<R1>>,
    user_master_pub_key: &PublicKey,
    rng: &Mutex<R2>,
    plaintext: Vec<u8>,
    document_id: Option<DocumentId>,
    document_name: Option<DocumentName>,
    grant_to_author: bool,
    user_grants: &[UserId],
    group_grants: &[GroupId],
    policy_grant: Option<&PolicyGrant>,
    policy_cache: &PolicyCache,
    public_key_cache: &PublicKeyCache,
) -> Result<DocumentEncryptResult, IronOxideErr> {
    let (dek, doc_sym_key) = transform::generate_new_doc_key(recrypt);
    let doc_id = document_id.unwrap_or_else(|| DocumentId::goo_id(rng));

    let (encrypted_doc, (grants, key_errs)) = try_join!(
        aes::encrypt_async(rng, plaintext, *doc_sym_key.bytes()),
        resolve_keys_for_grants(
            auth,
            config,
            user_grants,
            group_grants,
            policy_grant,
            if grant_to_author {
                Some(user_master_pub_key)
            } else {
                None
            },
            policy_cache,
            public_key_cache
        )
    )?;
    let r = recrypt_document(&auth.signing_private_key, recrypt, dek, &doc_id, grants)?;
    let encryption_errs = r.encryption_errs.clone();
    document_create(
        auth,
        r.into_edoc(
            DocumentHeader::new(doc_id.clone(), auth.segment_id),
            encrypted_doc,
        ),
        doc_id,
        &document_name,
        [key_errs, encryption_errs].concat(),
    )
    .await
}

type UserMasterPublicKey = PublicKey;
/// Get the public keys for a document grant.
///
/// # Arguments
/// `auth`          - info to make webservice requests
/// `user_grants`   - list of user ids to which document access should be granted
/// `group_grants`  - list of groups ids to which document access should be granted
/// `policy_grant`  - policy to apply for document access
/// `maybe_user_master_pub_key`
///                 - if Some, contains the logged in user's master public key for self-grant
///
/// # Returns
/// A Future that will resolve to:
/// (Left)  list of keys for all users and groups that should be granted access to the document
/// (Right) errors for any invalid users/groups that were passed
pub(crate) async fn resolve_keys_for_grants(
    auth: &RequestAuth,
    config: &IronOxideConfig,
    user_grants: &[UserId],
    group_grants: &[GroupId],
    policy_grant: Option<&PolicyGrant>,
    maybe_user_master_pub_key: Option<&UserMasterPublicKey>,
    policy_cache: &PolicyCache,
    public_key_cache: &PublicKeyCache,
) -> Result<(Vec<WithKey<UserOrGroup>>, Vec<DocAccessEditErr>), IronOxideErr> {
    let get_user_keys_f =
        internal::user_api::get_user_keys(auth, user_grants, public_key_cache.user_keys());
    let get_group_keys_f =
        internal::group_api::get_group_keys(auth, group_grants, public_key_cache.group_keys());

    let maybe_policy_grants_f =
        policy_grant.map(|p| (p, requests::policy_get::policy_get_request(auth, p)));

    let policy_grants_f = async {
        if let Some((p, policy_eval_f)) = maybe_policy_grants_f {
            get_cached_policy_or(&config.policy_caching, p, policy_cache, policy_eval_f).await
        } else {
            // No policies were included
            Ok((vec![], vec![]))
        }
    };
    let (users, groups, policy_result) =
        try_join!(get_user_keys_f, get_group_keys_f, policy_grants_f)?;
    let (group_errs, groups_with_key) = process_groups(groups);
    let (user_errs, users_with_key) = process_users(users);
    let explicit_grants = [users_with_key, groups_with_key].concat();

    let (policy_errs, applied_policy_grants) = policy_result;
    let maybe_self_grant = {
        if let Some(user_master_pub_key) = maybe_user_master_pub_key {
            vec![WithKey::new(
                UserOrGroup::User {
                    id: auth.account_id.clone(),
                },
                user_master_pub_key.clone(),
            )]
        } else {
            vec![]
        }
    };

    Ok((
        { [maybe_self_grant, explicit_grants, applied_policy_grants].concat() },
        [group_errs, user_errs, policy_errs].concat(),
    ))
}

/// Get a cached policy or run the given Future to get the evaluated policy from the webservice.
/// Policies that evaluate cleanly with no invalid users or groups are cached for future use.
async fn get_cached_policy_or<F>(
    config: &PolicyCachingConfig,
    grant: &PolicyGrant,
    policy_cache: &PolicyCache,
    get_policy_f: F,
) -> Result<(Vec<DocAccessEditErr>, Vec<WithKey<UserOrGroup>>), IronOxideErr>
where
    F: Future<Output = Result<PolicyResponse, IronOxideErr>>,
{
    // if there's a value in the cache, use it
    if let Some(cached_policy) = policy_cache.pin_owned().get(grant).cloned() {
        Ok((vec![], cached_policy))
    } else {
        // otherwise query the webservice and cache the result if there are no errors
        get_policy_f
            .await
            .map(|policy_resp| {
                let (errs, public_keys) = process_policy(&policy_resp);
                if errs.is_empty() {
                    // TODO(breaking): we should not do this, replacing something would make a lot more sense than
                    //   blowing up their active cache. We also _do_ want things to time expire in case the policy
                    //   structure has updated.
                    //if the cache has grown too large, clear it prior to adding new entries
                    let policy_pin = policy_cache.pin();
                    if policy_cache.len() >= config.max_entries {
                        policy_pin.clear()
                    }
                    policy_pin.insert(grant.clone(), public_keys.clone());
                }
                (errs, public_keys)
            })
            .map_err(|x| match x {
                IronOxideErr::RequestError {
                    http_status: Some(404),
                    ..
                } => IronOxideErr::PolicyDoesNotExist,
                e => e,
            })
    }
}

/// Encrypts a document but does not create the document in the IronCore system.
/// The resultant DocumentDetachedEncryptResult contains both the EncryptedDeks and the AesEncryptedValue
/// Both pieces will be required for decryption.
pub async fn encrypt_document_unmanaged<R1, R2>(
    auth: &RequestAuth,
    recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<R1>>,
    user_master_pub_key: &PublicKey,
    rng: &Mutex<R2>,
    plaintext: Vec<u8>,
    document_id: Option<DocumentId>,
    grant_to_author: bool,
    user_grants: &[UserId],
    group_grants: &[GroupId],
    policy_grant: Option<&PolicyGrant>,
    policy_cache: &PolicyCache,
    public_key_cache: &PublicKeyCache,
) -> Result<DocumentEncryptUnmanagedResult, IronOxideErr>
where
    R1: rand::CryptoRng,
    R2: rand::CryptoRng,
{
    let config = IronOxideConfig::default();

    let (dek, doc_sym_key) = transform::generate_new_doc_key(recrypt);
    let doc_id = document_id.unwrap_or_else(|| DocumentId::goo_id(rng));

    let (doc, (recryption_result, access_errs)) = try_join!(
        aes::encrypt_async(rng, plaintext, *doc_sym_key.bytes()),
        encrypt_dek_to(
            auth,
            recrypt,
            user_master_pub_key,
            grant_to_author,
            user_grants,
            group_grants,
            policy_grant,
            policy_cache,
            public_key_cache,
            config,
            dek,
            &doc_id,
        )
    )?;
    let enc_result = EncryptedDoc {
        header: DocumentHeader::new(doc_id, auth.segment_id),
        doc,
        recryption_result,
    };
    DocumentEncryptUnmanagedResult::new(enc_result, access_errs)
}

async fn encrypt_dek_to<R1>(
    auth: &RequestAuth,
    recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<R1>>,
    user_master_pub_key: &PublicKey,
    grant_to_author: bool,
    user_grants: &[UserId],
    group_grants: &[GroupId],
    policy_grant: Option<&PolicyGrant>,
    policy_cache: &papaya::HashMap<PolicyGrant, Vec<WithKey<UserOrGroup>>>,
    public_key_cache: &PublicKeyCache,
    config: IronOxideConfig,
    dek: Plaintext,
    doc_id: &DocumentId,
) -> Result<(RecryptionResult, Vec<DocAccessEditErr>), IronOxideErr>
where
    R1: rand::CryptoRng,
{
    let (grants, key_errs) = resolve_keys_for_grants(
        auth,
        &config,
        user_grants,
        group_grants,
        policy_grant,
        if grant_to_author {
            Some(user_master_pub_key)
        } else {
            None
        },
        policy_cache,
        public_key_cache,
    )
    .await?;
    let recryption_result =
        recrypt_document(&auth.signing_private_key, recrypt, dek, doc_id, grants)?;
    let access_errs = key_errs
        .into_iter()
        .chain(recryption_result.encryption_errs.clone())
        .collect();
    Ok((recryption_result, access_errs))
}
/// Remove any duplicates in the grant list. Uses ids (not keys) for comparison.
fn dedupe_grants(grants: &[WithKey<UserOrGroup>]) -> Vec<WithKey<UserOrGroup>> {
    grants
        .iter()
        .unique_by(|i| &i.id)
        .map(Clone::clone)
        .collect_vec()
}

/// Encrypt the document using transform crypto (recrypt).
/// Can be called once you have public keys for users/groups that should have access as well as the
/// AES encrypted data.
pub(crate) fn recrypt_document<CR: rand::CryptoRng>(
    signing_keys: &DeviceSigningKeyPair,
    recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
    dek: Plaintext,
    doc_id: &DocumentId,
    grants: Vec<WithKey<UserOrGroup>>,
) -> Result<RecryptionResult, IronOxideErr> {
    // check to make sure that we are granting to something
    if grants.is_empty() {
        Err(IronOxideErr::ValidationError(
            "grants".into(),
            format!(
                "Access must be granted to document {:?} by explicit grant or via a policy",
                &doc_id
            ),
        ))
    } else {
        Ok({
            // encrypt to all the users and groups
            let (encrypt_errs, grants) = transform::encrypt_to_with_key(
                recrypt,
                &dek,
                &signing_keys.into(),
                dedupe_grants(&grants),
            );

            RecryptionResult {
                edeks: grants
                    .into_iter()
                    .map(|(wk, ev)| EncryptedDek {
                        grant_to: wk,
                        encrypted_dek_data: ev,
                    })
                    .collect(),
                encryption_errs: encrypt_errs.into_iter().map(|e| e.into()).collect(),
            }
        })
    }
}

/// An encrypted document encryption key.
///
/// Once decrypted, the DEK serves as a symmetric encryption key.
///
/// It can also be useful to think of an EDEK as representing a "document access grant" to a user/group.
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct EncryptedDek {
    pub(crate) grant_to: WithKey<UserOrGroup>,
    pub(crate) encrypted_dek_data: recrypt::api::EncryptedValue,
}

impl EncryptedDek {
    /// Get the user or group this EDEK was encrypted to
    pub(crate) fn grant_to(&self) -> &UserOrGroup {
        &self.grant_to.id
    }
}

impl TryFrom<&EncryptedDek> for EncryptedDekP {
    type Error = IronOxideErr;
    fn try_from(edek: &EncryptedDek) -> Result<Self, Self::Error> {
        use crate::proto::transform;
        use recrypt::api as re;

        // encode the recrypt EncryptedValue to a edek proto
        let proto_edek_data = match edek.encrypted_dek_data {
            re::EncryptedValue::EncryptedOnceValue {
                ephemeral_public_key,
                encrypted_message,
                auth_hash,
                public_signing_key,
                signature,
            } => Ok(EncryptedDekDataP {
                encryptedBytes: encrypted_message.bytes().to_vec().into(),
                ephemeralPublicKey: Some(PublicKey::from(ephemeral_public_key).into()).into(),
                signature: signature.bytes().to_vec().into(),
                authHash: auth_hash.bytes().to_vec().into(),
                publicSigningKey: public_signing_key.bytes().to_vec().into(),
                ..Default::default()
            }),
            re::EncryptedValue::TransformedValue { .. } => Err(
                IronOxideErr::InvalidRecryptEncryptedValue("Expected".to_string()),
            ),
        }?;

        //convert the grants
        let proto_uog = match edek.grant_to.clone() {
            WithKey {
                id:
                    UserOrGroup::User {
                        id: UserId(user_string),
                    },
                public_key,
            } => {
                let mut proto_uog = transform::UserOrGroup::default();
                proto_uog.set_userId(user_string.into());
                proto_uog.masterPublicKey = Some(public_key.into()).into();
                proto_uog
            }
            WithKey {
                id:
                    UserOrGroup::Group {
                        id: GroupId(group_string),
                    },
                public_key,
            } => {
                let mut proto_uog = transform::UserOrGroup::default();
                proto_uog.set_groupId(group_string.into());
                proto_uog.masterPublicKey = Some(public_key.into()).into();
                proto_uog
            }
        };

        Ok(EncryptedDekP {
            userOrGroup: Some(proto_uog).into(),
            encryptedDekData: Some(proto_edek_data).into(),
            ..Default::default()
        })
    }
}
/// Result of recrypt encryption. Contains the encrypted DEKs and the encrypted (user) data.
/// `RecryptionResult` is an intermediate value as it cannot be serialized to bytes directly.
/// To serialize to bytes, first construct an `EncryptedDoc`
#[derive(Clone, Debug)]
pub(crate) struct RecryptionResult {
    pub edeks: Vec<EncryptedDek>,
    pub encryption_errs: Vec<DocAccessEditErr>,
}

impl RecryptionResult {
    fn into_edoc(self, header: DocumentHeader, doc: AesEncryptedValue) -> EncryptedDoc {
        EncryptedDoc {
            header,
            doc,
            recryption_result: self,
        }
    }
}

/// An ironoxide encrypted document
#[derive(Debug)]
struct EncryptedDoc {
    header: DocumentHeader,
    recryption_result: RecryptionResult,
    doc: AesEncryptedValue,
}

impl EncryptedDoc {
    /// bytes of the encrypted data with the edoc header prepended
    fn edoc_bytes(&self) -> Vec<u8> {
        [&self.header.pack().0[..], &self.doc.bytes()].concat()
    }

    /// associated EncryptedDeks for this EncryptedDoc
    fn edek_vec(&self) -> Vec<EncryptedDek> {
        self.recryption_result.edeks.clone()
    }

    /// binary blob for associated edeks, or error if encoding the edeks failed
    fn edek_bytes(&self) -> Result<Vec<u8>, IronOxideErr> {
        edeks_to_edeks_proto(
            &self.recryption_result.edeks,
            self.header.document_id.id(),
            self.header.segment_id as i32, // okay since the ironcore-ws defines this to be an i32
        )
    }
}

/// Convert EDEKs to bytes for the given document.
pub(crate) fn edeks_to_bytes(
    edeks: &[EncryptedDek],
    document_id: &DocumentId,
    segment_id: usize,
) -> Result<Vec<u8>, IronOxideErr> {
    edeks_to_edeks_proto(edeks, document_id.id(), segment_id as i32)
}

fn edeks_to_edeks_proto(
    edeks: &[EncryptedDek],
    document_id: &str,
    segment_id: i32,
) -> Result<Vec<u8>, IronOxideErr> {
    let proto_edek_vec_results: Result<Vec<_>, _> =
        edeks.iter().map(|edek| edek.try_into()).collect();
    let proto_edek_vec = proto_edek_vec_results?;

    let proto_edeks = EncryptedDeksP {
        edeks: proto_edek_vec,
        documentId: document_id.into(),
        segmentId: segment_id,
        ..Default::default()
    };

    let edek_bytes = proto_edeks.write_to_bytes()?;
    Ok(edek_bytes)
}

async fn document_create(
    auth: &RequestAuth,
    edoc: EncryptedDoc,
    doc_id: DocumentId,
    doc_name: &Option<DocumentName>,
    accum_errs: Vec<DocAccessEditErr>,
) -> Result<DocumentEncryptResult, IronOxideErr> {
    let api_resp =
        document_create::document_create_request(auth, doc_id, doc_name.clone(), edoc.edek_vec())
            .await?;

    Ok(DocumentEncryptResult {
        id: api_resp.id,
        name: api_resp.name,
        created: api_resp.created,
        updated: api_resp.updated,
        encrypted_data: edoc.edoc_bytes(),
        grants: api_resp
            .shared_with
            .into_iter()
            .map(|sw| sw.into())
            .collect(),
        access_errs: [accum_errs, edoc.recryption_result.encryption_errs].concat(),
    })
}

/// Encrypt the provided plaintext using the DEK from the provided document ID but with a new AES IV. Allows updating the encrypted bytes
/// of a document without having to change document access.
pub async fn document_update_bytes<R1: rand::CryptoRng, R2: rand::CryptoRng>(
    auth: &RequestAuth,
    recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<R1>>,
    device_private_key: &PrivateKey,
    rng: &Mutex<R2>,
    document_id: &DocumentId,
    plaintext: Vec<u8>,
) -> Result<DocumentEncryptResult, IronOxideErr> {
    let doc_meta = document_get_metadata(auth, document_id).await?;
    let sym_key = transform::decrypt_as_symmetric_key(
        recrypt,
        doc_meta.0.encrypted_symmetric_key.try_into()?,
        device_private_key.recrypt_key(),
    )?;
    Ok(
        aes::encrypt(rng, plaintext, *sym_key.bytes()).map(move |encrypted_doc| {
            let mut encrypted_payload =
                DocumentHeader::new(document_id.clone(), auth.segment_id()).pack();
            encrypted_payload.0.append(&mut encrypted_doc.bytes());
            DocumentEncryptResult {
                id: doc_meta.0.id,
                name: doc_meta.0.name,
                created: doc_meta.0.created,
                updated: doc_meta.0.updated,
                encrypted_data: encrypted_payload.0,
                grants: vec![],      // grants can't currently change via update
                access_errs: vec![], // no grants, no access errs
            }
        })?,
    )
}

/// Decrypt the provided document with the provided device private key. Return metadata about the document
/// that was decrypted along with its decrypted bytes.
pub async fn decrypt_document<CR: rand::CryptoRng + Send + Sync + 'static>(
    auth: &RequestAuth,
    recrypt: std::sync::Arc<Recrypt<Sha256, Ed25519, RandomBytes<CR>>>,
    device_private_key: &PrivateKey,
    encrypted_doc: &[u8],
) -> Result<DocumentDecryptResult, IronOxideErr> {
    let (doc_header, mut enc_doc) = parse_document_parts(encrypted_doc)?;
    let doc_meta = document_get_metadata(auth, &doc_header.document_id).await?;
    let device_private_key = device_private_key.clone();
    tokio::task::spawn_blocking(move || {
        let sym_key = transform::decrypt_as_symmetric_key(
            &recrypt,
            doc_meta.0.encrypted_symmetric_key.try_into()?,
            device_private_key.recrypt_key(),
        )?;

        Ok(
            aes::decrypt(&mut enc_doc, *sym_key.bytes()).map(move |decrypted_doc| {
                DocumentDecryptResult {
                    id: doc_meta.0.id,
                    name: doc_meta.0.name,
                    created: doc_meta.0.created,
                    updated: doc_meta.0.updated,
                    decrypted_data: decrypted_doc.to_vec(),
                }
            })?,
        )
    })
    .await?
}

/// Decrypt the unmanaged document. The caller must provide both the encrypted data as well as the
/// encrypted DEKs. Most use cases would want `decrypt_document` instead.
pub async fn decrypt_document_unmanaged<CR: rand::CryptoRng>(
    auth: &RequestAuth,
    recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
    device_private_key: &PrivateKey,
    encrypted_doc: &[u8],
    encrypted_deks: &[u8],
) -> Result<DocumentDecryptUnmanagedResult, IronOxideErr> {
    // attempt to parse the proto as fail-fast validation. If it fails decrypt will fail
    let ((proto_edeks, (doc_meta, mut aes_encrypted_value)), transform_resp) = try_join!(
        async {
            Ok((
                EncryptedDeksP::parse_from_bytes(encrypted_deks).map_err(IronOxideErr::from)?,
                parse_document_parts(encrypted_doc)?,
            ))
        },
        requests::edek_transform::edek_transform(auth, encrypted_deks)
    )?;

    edeks_and_header_match_or_err(&proto_edeks, &doc_meta)?;
    let requests::edek_transform::EdekTransformResponse {
        user_or_group,
        encrypted_symmetric_key,
    } = transform_resp;

    let sym_key = transform::decrypt_as_symmetric_key(
        recrypt,
        encrypted_symmetric_key.try_into()?,
        device_private_key.recrypt_key(),
    )?;
    aes::decrypt(&mut aes_encrypted_value, *sym_key.bytes())
        .map_err(|e| e.into())
        .map(move |decrypted_doc| DocumentDecryptUnmanagedResult {
            id: doc_meta.document_id,
            access_via: user_or_group,
            decrypted_data: DecryptedData(decrypted_doc.to_vec()),
        })
}

/// Grant access to an unmanaged document.
/// Cannot be done offline - it needs the IronCore service to determine transform keys.
pub async fn document_grant_access_unmanaged<CR: rand::CryptoRng>(
    auth: &RequestAuth,
    recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
    user_master_pub_key: &PublicKey,
    device_private_key: &PrivateKey,
    encrypted_deks: &[u8],
    users: &[UserId],
    groups: &[GroupId],
    public_key_cache: &PublicKeyCache,
    config: IronOxideConfig,
) -> Result<DocumentAccessUnmanagedResult, IronOxideErr> {
    // attempt to parse the proto as fail-fast validation. If it fails grant will fail
    let (proto_edeks, transform_resp) = try_join!(
        async { EncryptedDeksP::parse_from_bytes(encrypted_deks).map_err(IronOxideErr::from) },
        requests::edek_transform::edek_transform(auth, encrypted_deks)
    )?;
    let document_id = (*proto_edeks.documentId).try_into()?;

    // encrypted_symmetric_key is named that way in the response because previously our only usecase of it was to derive
    // the symmetric key from it, but it's actually an encrypted plaintext
    let requests::edek_transform::EdekTransformResponse {
        user_or_group,
        encrypted_symmetric_key: actually_recrypt_encrypted_plaintext,
    } = transform_resp;

    // decrypt the transformed key
    let dek = recrypt.decrypt(
        actually_recrypt_encrypted_plaintext.try_into()?,
        device_private_key.recrypt_key(),
    )?;

    // encrypt only to explicitly requested grants
    let (recryption_result, access_errs) = encrypt_dek_to(
        auth,
        recrypt,
        user_master_pub_key,
        false,
        users,
        groups,
        None,
        &Default::default(),
        public_key_cache,
        config,
        dek,
        &document_id,
    )
    .await?;

    // collect the identities that were successfully granted
    let succeeded: Vec<UserOrGroup> = recryption_result
        .edeks
        .iter()
        .map(|edek| edek.grant_to.id.clone())
        .collect();

    // convert new edeks to proto entries
    let new_proto_edeks: Vec<EncryptedDekP> = recryption_result
        .edeks
        .iter()
        .map(|edek| edek.try_into())
        .collect::<Result<Vec<_>, _>>()?;

    // remove old edeks that were successfully re-granted, keep the rest
    let mut proto_edeks = proto_edeks;
    proto_edeks.edeks.retain(|edek| {
        let proto_id = edek
            .userOrGroup
            .as_ref()
            .and_then(|uog| uog.UserOrGroupId.as_ref());
        match proto_id {
            Some(UserOrGroupIdP::UserId(u)) => {
                let Ok(uid) = UserId::try_from(u.to_string()) else {
                    return true;
                };
                !succeeded.contains(&UserOrGroup::User { id: uid })
            }
            Some(UserOrGroupIdP::GroupId(g)) => {
                let Ok(gid) = GroupId::try_from(g.to_string()) else {
                    return true;
                };
                !succeeded.contains(&UserOrGroup::Group { id: gid })
            }
            None => true,
        }
    });

    // append new edeks and serialize
    proto_edeks.edeks.extend(new_proto_edeks);
    let encrypted_deks = proto_edeks.write_to_bytes()?;

    Ok(DocumentAccessUnmanagedResult {
        access_via: Some(user_or_group),
        encrypted_deks,
        succeeded,
        failed: access_errs,
    })
}

/// Extracts metadata from the EDEKs bytes produced during document encryption.
/// This operation is fully offline - no server calls are needed.
pub fn document_get_metadata_unmanaged(
    encrypted_deks: &[u8],
) -> Result<DocumentMetadataUnmanagedResult, IronOxideErr> {
    let proto_edeks =
        EncryptedDeksP::parse_from_bytes(encrypted_deks).map_err(IronOxideErr::from)?;
    let doc_id: DocumentId = (*proto_edeks.documentId).try_into()?;

    let (users, groups): (Vec<UserId>, Vec<GroupId>) = proto_edeks
        .edeks
        .iter()
        .filter_map(|edek| edek.userOrGroup.as_ref()?.UserOrGroupId.as_ref())
        .filter_map(|proto_user_or_group| match proto_user_or_group {
            UserOrGroupIdP::UserId(u) => UserId::try_from(u.to_string()).ok().map(Either::Left),
            UserOrGroupIdP::GroupId(g) => GroupId::try_from(g.to_string()).ok().map(Either::Right),
        })
        .partition_map(identity);

    let user_visibility: Vec<_> = users.into_iter().map(|id| VisibleUser { id }).collect();
    let group_visibility: Vec<_> = groups
        .into_iter()
        .map(|id| VisibleGroup { id, name: None })
        .collect();

    Ok(DocumentMetadataUnmanagedResult {
        id: doc_id,
        user_visibility,
        group_visibility,
    })
}

/// Revokes access from the provided users/groups by removing their EDEKs from the proto bytes.
/// This operation is fully offline - no server calls are needed.
pub fn document_revoke_access_unmanaged(
    encrypted_deks: &[u8],
    revoke_list: &[UserOrGroup],
) -> Result<DocumentAccessUnmanagedResult, IronOxideErr> {
    let mut proto_edeks =
        EncryptedDeksP::parse_from_bytes(encrypted_deks).map_err(IronOxideErr::from)?;

    // helper to check if a proto edek's identity matches any entry in the revoke list. If something fails
    // to parse, it's left in the grants
    let should_revoke = |edek: &EncryptedDekP| -> Option<UserOrGroup> {
        let uog = edek.userOrGroup.as_ref()?.UserOrGroupId.as_ref()?;
        match uog {
            UserOrGroupIdP::UserId(u) => {
                let uid = UserId::try_from(u.to_string()).ok()?;
                revoke_list
                    .iter()
                    .find(|revocation| matches!(revocation, UserOrGroup::User { id } if id == &uid))
                    .cloned()
            }
            UserOrGroupIdP::GroupId(g) => {
                let gid = GroupId::try_from(g.to_string()).ok()?;
                revoke_list
                    .iter()
                    .find(
                        |revocation| matches!(revocation, UserOrGroup::Group { id } if id == &gid),
                    )
                    .cloned()
            }
        }
    };

    let (revoked, kept): (Vec<_>, Vec<_>) =
        proto_edeks
            .edeks
            .into_iter()
            .partition_map(|edek| match should_revoke(&edek) {
                Some(revoked_identity) => Either::Left(revoked_identity),
                None => Either::Right(edek),
            });

    // entries from revoke_list not found in any edek
    let failed: Vec<DocAccessEditErr> = revoke_list
        .iter()
        .filter(|r| !revoked.contains(r))
        .map(|r| {
            DocAccessEditErr::new(
                r.clone(),
                "User or group not found in EDEK grants.".to_string(),
            )
        })
        .collect();

    // set the edeks to the pared down kept grants
    proto_edeks.edeks = kept;
    let new_edek_bytes = proto_edeks.write_to_bytes()?;

    Ok(DocumentAccessUnmanagedResult {
        access_via: None,
        encrypted_deks: new_edek_bytes,
        succeeded: revoked,
        failed,
    })
}

/// Check to see if a set of edeks match a document header
pub(crate) fn edeks_and_header_match_or_err(
    edeks: &EncryptedDeksP,
    doc_meta: &DocumentHeader,
) -> Result<(), IronOxideErr> {
    if doc_meta.document_id.id() != edeks.documentId.to_string()
        || doc_meta.segment_id as i32 != edeks.segmentId
    {
        Err(IronOxideErr::UnmanagedDecryptionError(
            edeks.documentId.to_string(),
            edeks.segmentId,
            doc_meta.document_id.clone().0,
            doc_meta.segment_id as i32,
        ))
    } else {
        Ok(())
    }
}

// Update a documents name. Value can be updated to either a new name with a Some or the name value can be cleared out
// by providing a None.
pub async fn update_document_name(
    auth: &RequestAuth,
    id: &DocumentId,
    name: Option<&DocumentName>,
) -> Result<DocumentMetadataResult, IronOxideErr> {
    requests::document_update::document_update_request(auth, id, name)
        .await
        .map(DocumentMetadataResult)
}

pub async fn document_grant_access<CR: rand::CryptoRng>(
    auth: &RequestAuth,
    recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
    id: &DocumentId,
    user_master_pub_key: &PublicKey,
    priv_device_key: &PrivateKey,
    user_grants: &[UserId],
    group_grants: &[GroupId],
    public_key_cache: &PublicKeyCache,
) -> Result<DocumentAccessResult, IronOxideErr> {
    let (doc_meta, users, groups) = try_join!(
        document_get_metadata(auth, id),
        // and the public keys for the users and groups
        internal::user_api::get_user_keys(auth, user_grants, public_key_cache.user_keys()),
        internal::group_api::get_group_keys(auth, group_grants, public_key_cache.group_keys()),
    )?;
    let (grants, other_errs) = {
        // decrypt the dek
        let edek = doc_meta.to_encrypted_symmetric_key()?;
        let dek = recrypt.decrypt(edek, priv_device_key.recrypt_key())?;

        let (group_errs, groups_with_key) = process_groups(groups);
        let (user_errs, users_with_key) = process_users(users);
        let users_and_groups = dedupe_grants(&[&users_with_key[..], &groups_with_key[..]].concat());

        // encrypt to all the users and groups
        let (grant_errs, grants) = transform::encrypt_to_with_key(
            recrypt,
            &dek,
            &auth.signing_private_key().into(),
            users_and_groups,
        );

        // squish all accumulated errors into one list
        let other_errs = group_errs
            .into_iter()
            .chain(user_errs)
            .chain(grant_errs.into_iter().map(|e| e.into()))
            .collect_vec();
        (grants, other_errs)
    };

    let resp =
        requests::document_access::grant_access_request(auth, id, user_master_pub_key, grants)
            .await?;
    Ok(requests::document_access::resp::document_access_api_resp_to_result(resp, other_errs))
}

/// Remove access to a document from the provided list of users and/or groups
pub async fn document_revoke_access(
    auth: &RequestAuth,
    id: &DocumentId,
    revoke_list: &[UserOrGroup],
) -> Result<DocumentAccessResult, IronOxideErr> {
    use requests::document_access::{self, resp};

    let revoke_request_list: Vec<_> = revoke_list
        .iter()
        .map(|entity| match entity {
            UserOrGroup::User { id } => resp::UserOrGroupAccess::User { id: id.0.clone() },
            UserOrGroup::Group { id } => resp::UserOrGroupAccess::Group { id: id.0.clone() },
        })
        .collect();

    let resp = document_access::revoke_access_request(auth, id, revoke_request_list).await?;
    Ok(resp::document_access_api_resp_to_result(resp, vec![]))
}

/// Map the groups that come back from the server into a common value/err structure
fn process_groups(
    (group_errs, groups_with_key): (Vec<GroupId>, Vec<WithKey<GroupId>>),
) -> (Vec<DocAccessEditErr>, Vec<WithKey<UserOrGroup>>) {
    let group_errs = group_errs
        .into_iter()
        .map(|gid| {
            DocAccessEditErr::new(
                UserOrGroup::Group { id: gid },
                "Group could not be found".to_string(),
            )
        })
        .collect();

    let groups_with_key: Vec<WithKey<UserOrGroup>> = groups_with_key
        .into_iter()
        .map(|WithKey { id, public_key }| WithKey {
            id: UserOrGroup::Group { id },
            public_key,
        })
        .collect();

    (group_errs, groups_with_key)
}

/// Map the users that come back from the server into a common value/err structure
fn process_users(
    (user_errs, users_with_key): (Vec<UserId>, Vec<WithKey<UserId>>),
) -> (Vec<DocAccessEditErr>, Vec<WithKey<UserOrGroup>>) {
    let users_with_key: Vec<WithKey<UserOrGroup>> = users_with_key
        .into_iter()
        .map(|WithKey { id, public_key }| WithKey {
            id: UserOrGroup::User { id },
            public_key,
        })
        .collect();

    // convert all user list errors to AccessErr
    let user_errs: Vec<DocAccessEditErr> = user_errs
        .into_iter()
        .map(|uid| {
            DocAccessEditErr::new(
                UserOrGroup::User { id: uid },
                "User could not be found".to_string(),
            )
        })
        .collect();
    (user_errs, users_with_key)
}

/// Extract users/groups + keys from a PolicyResult (Right). Errors from applying the policy are Left.
fn process_policy(
    policy_result: &PolicyResponse,
) -> (Vec<DocAccessEditErr>, Vec<WithKey<UserOrGroup>>) {
    let (pubkey_errs, policy_eval_results): (Vec<DocAccessEditErr>, Vec<WithKey<UserOrGroup>>) =
        policy_result
            .users_and_groups
            .iter()
            .partition_map(|uog| match uog {
                UserOrGroupWithKey::User {
                    id,
                    master_public_key: Some(key),
                } => {
                    let user = UserOrGroup::User {
                        // okay since these came back from the service
                        id: UserId::unsafe_from_string(id.clone()),
                    };

                    Either::from(
                        key.clone()
                            .try_into()
                            .map(|k| WithKey::new(user.clone(), k))
                            .map_err(|_e| {
                                DocAccessEditErr::new(
                                    user,
                                    format!("Error parsing user public key {:?}", &key),
                                )
                            }),
                    )
                }
                UserOrGroupWithKey::Group {
                    id,
                    master_public_key: Some(key),
                } => {
                    let group = UserOrGroup::Group {
                        // okay since these came back from the service
                        id: GroupId::unsafe_from_string(id.clone()),
                    };

                    Either::from(
                        key.clone()
                            .try_into()
                            .map(|k| WithKey::new(group.clone(), k))
                            .map_err(|_e| {
                                DocAccessEditErr::new(
                                    group,
                                    format!("Error parsing group public key {:?}", &key),
                                )
                            }),
                    )
                }

                any => {
                    let uog: UserOrGroup = any.clone().into();
                    let err_msg = format!("{} does not have associated public key", &uog);
                    Either::Left(DocAccessEditErr::new(uog, err_msg))
                }
            });

    (
        pubkey_errs
            .into_iter()
            .chain(policy_result.invalid_users_and_groups.iter().map(|uog| {
                DocAccessEditErr::new(
                    uog.clone(),
                    format!("Policy refers to unknown user or group '{}'", &uog),
                )
            }))
            .collect(),
        policy_eval_results,
    )
}

#[cfg(test)]
mod tests {
    use crate::internal::tests::contains;
    use base64::engine::Engine;
    use base64::prelude::BASE64_STANDARD;
    use galvanic_assert::{
        matchers::{collection::*, *},
        *,
    };

    use super::*;
    use crate::internal::RequestErrorCode;
    use papaya::HashMap;
    use std::borrow::Borrow;

    #[tokio::test]
    async fn get_policy_or() -> Result<(), IronOxideErr> {
        let policy_json = r#"{ "usersAndGroups": [ { "type": "group", "id": "data_recovery_abcABC012_.$#|@/:;=+'-f1e11a54-8aa9-4641-aaf3-fb92079499f0", "masterPublicKey": { "x": "GE5XQYcRDRhBcyDpNwlu79x6tshNi111ym1IfxOTIxk=", "y": "amgLgcCEYIPQ4oxinLoAvsO3VG7XTFdRfkG/3tooaZE=" } } ], "invalidUsersAndGroups": [] }"#;

        let policy_grant = PolicyGrant::default();
        let policy_cache = HashMap::new();
        let config = PolicyCachingConfig::default();
        let policy_resp: PolicyResponse =
            serde_json::from_str(policy_json).expect("json should parse");

        // as a baseline, show that the get_policy_f runs if there is a cache miss
        let err_result = get_cached_policy_or(&config, &policy_grant, &policy_cache, async {
            Err(IronOxideErr::InitializeError("".into()))
        })
        .await;

        assert!(err_result.is_err());

        // now try again, but with a valid get_policy_f that will both return the policy evaluation and cache it
        let policy = get_cached_policy_or(&config, &policy_grant, &policy_cache, async {
            Ok(policy_resp.clone())
        })
        .await?;

        // we've now cached a policy and it's the same as the one that was returned
        assert_eq!(1, policy_cache.len());
        assert_eq!(
            policy.1,
            policy_cache.pin().get(&policy_grant).unwrap().clone()
        );

        // let's get the policy again, but if the policy future executes (cache miss) error
        get_cached_policy_or(&config, &policy_grant, &policy_cache, async {
            Err(IronOxideErr::InitializeError("".into()))
        })
        .await?;
        assert_eq!(1, policy_cache.len());

        Ok(())
    }

    #[tokio::test]
    async fn policy_404_gives_nice_error() -> Result<(), IronOxideErr> {
        let policy_grant = PolicyGrant::default();
        let policy_cache = HashMap::new();
        let config = PolicyCachingConfig::default();

        // show transformation of RequestError - 404 for Policy GET to PolicyDoesNotExist
        let err_result = get_cached_policy_or(&config, &policy_grant, &policy_cache, async {
            Err(IronOxideErr::RequestError {
                message: "".into(),
                code: RequestErrorCode::PolicyGet,
                http_status: Some(404),
            })
        })
        .await;
        assert!(err_result.is_err());
        assert_that!(
            &err_result.unwrap_err(),
            is_variant!(IronOxideErr::PolicyDoesNotExist)
        );

        Ok(())
    }

    #[tokio::test]
    async fn policy_cache_max_size_honored() -> Result<(), IronOxideErr> {
        let policy_json = r#"{ "usersAndGroups": [ { "type": "group", "id": "data_recovery_abcABC012_.$#|@/:;=+'-f1e11a54-8aa9-4641-aaf3-fb92079499f0", "masterPublicKey": { "x": "GE5XQYcRDRhBcyDpNwlu79x6tshNi111ym1IfxOTIxk=", "y": "amgLgcCEYIPQ4oxinLoAvsO3VG7XTFdRfkG/3tooaZE=" } } ], "invalidUsersAndGroups": [] }"#;
        let policy_grant = PolicyGrant::default();
        let policy_cache = HashMap::new();
        let config = PolicyCachingConfig { max_entries: 3 };
        let policy_resp: PolicyResponse =
            serde_json::from_str(policy_json).expect("json should parse");

        get_cached_policy_or(&config, &policy_grant, &policy_cache, async {
            Ok(policy_resp.clone())
        })
        .await?;
        assert_eq!(1, policy_cache.len());

        let policy_grant2 = PolicyGrant::new(Some("foo".try_into()?), None, None, None);
        get_cached_policy_or(&config, &policy_grant2, &policy_cache, async {
            Ok(policy_resp.clone())
        })
        .await?;
        assert_eq!(2, policy_cache.len());

        let policy_grant3 = PolicyGrant::new(Some("bar".try_into()?), None, None, None);
        get_cached_policy_or(&config, &policy_grant3, &policy_cache, async {
            Ok(policy_resp.clone())
        })
        .await?;
        assert_eq!(3, policy_cache.len());

        let policy_grant4 = PolicyGrant::new(Some("baz".try_into()?), None, None, None);
        get_cached_policy_or(&config, &policy_grant4, &policy_cache, async {
            Ok(policy_resp.clone())
        })
        .await?;

        // we should be over the configured max_entries, so the cache should reset prior to storing the value
        assert_eq!(1, policy_cache.len());

        Ok(())
    }

    #[tokio::test]
    async fn policy_cache_unclean_entries_not_cached() -> Result<(), IronOxideErr> {
        // policy with 1 "good" group and one "bad" one
        let policy_json = r#"{ "usersAndGroups": [ { "type": "group", "id": "data_recovery_abcABC012_.$#|@/:;=+'-f1e11a54-8aa9-4641-aaf3-fb92079499f0", "masterPublicKey": { "x": "GE5XQYcRDRhBcyDpNwlu79x6tshNi111ym1IfxOTIxk=", "y": "amgLgcCEYIPQ4oxinLoAvsO3VG7XTFdRfkG/3tooaZE=" } } ], "invalidUsersAndGroups": [{ "type": "group", "id": "group-that-does-not-exist" }] }"#;
        let policy_grant = PolicyGrant::default();
        let policy_cache = HashMap::new();
        let config = PolicyCachingConfig::default();
        let policy_resp: PolicyResponse =
            serde_json::from_str(policy_json).expect("json should parse");

        get_cached_policy_or(&config, &policy_grant, &policy_cache, async {
            Ok(policy_resp.clone())
        })
        .await?;
        assert_eq!(0, policy_cache.len());

        Ok(())
    }
    #[test]
    fn document_id_validate_good() {
        let doc_id1 = "an_actual_good_doc_id$";
        let doc_id2 = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789";
        assert_eq!(
            DocumentId(doc_id1.to_string()),
            DocumentId::try_from(doc_id1).unwrap()
        );
        assert_eq!(
            DocumentId(doc_id2.to_string()),
            DocumentId::try_from(doc_id2).unwrap()
        )
    }

    #[test]
    fn document_id_rejects_invalid() {
        let doc_id1 = DocumentId::try_from("not a good ID!");
        let doc_id2 = DocumentId::try_from("!!");
        let doc_id3 = DocumentId::try_from(
            "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567891",
        );

        assert_that!(
            &doc_id1.unwrap_err(),
            is_variant!(IronOxideErr::ValidationError)
        );
        assert_that!(
            &doc_id2.unwrap_err(),
            is_variant!(IronOxideErr::ValidationError)
        );
        assert_that!(
            &doc_id3.unwrap_err(),
            is_variant!(IronOxideErr::ValidationError)
        );
    }

    #[test]
    fn doc_id_rejects_empty() {
        let doc_id = DocumentId::try_from("");
        assert_that!(&doc_id, is_variant!(Err));
        assert_that!(
            &doc_id.unwrap_err(),
            is_variant!(IronOxideErr::ValidationError)
        );

        let doc_id = DocumentId::try_from("\n \t  ");
        assert_that!(&doc_id, is_variant!(Err));
        assert_that!(
            &doc_id.unwrap_err(),
            is_variant!(IronOxideErr::ValidationError)
        );
    }

    #[test]
    fn doc_name_rejects_empty() {
        let doc_name = DocumentName::try_from("");
        assert_that!(&doc_name, is_variant!(Err));
        assert_that!(
            &doc_name.unwrap_err(),
            is_variant!(IronOxideErr::ValidationError)
        );

        let doc_name = DocumentName::try_from("\n \t  ");
        assert_that!(&doc_name, is_variant!(Err));
        assert_that!(
            &doc_name.unwrap_err(),
            is_variant!(IronOxideErr::ValidationError)
        );
    }

    #[test]
    fn doc_name_rejects_too_long() {
        let doc_name = DocumentName::try_from(
            "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567891",
        );

        assert_that!(
            &doc_name.unwrap_err(),
            is_variant!(IronOxideErr::ValidationError)
        )
    }

    #[test]
    fn err_on_bad_doc_header() {
        let doc_with_wrong_version = BASE64_STANDARD.decode("AQA4eyJfZGlkXyI6ImNjOTIyZTA3NzRhM2MwZWViZTI2NDM2Yzk2ZjdiYzkzIiwiX3NpZF8iOjYwOH1ciL4su5SPZh4eFGuG+5rJ+/I2gDSZAs+2dXw097gU8fBkMWzRo0dDIW0dOxHg/1mio1yMRdDZDA==").unwrap();
        let doc_with_invalid_json = BASE64_STANDARD.decode("AgA4Z2NfZGlkXyI6ImNjOTIyZTA3NzRhM2MwZWViZTI2NDM2Yzk2ZjdiYzkzIiwiX3NpZF8iOjYwOH1ciL4su5SPZh4eFGuG+5rJ+/I2gDSZAs+2dXw097gU8fBkMWzRo0dDIW0dOxHg/1mio1yMRdDZDA==").unwrap();

        assert_that!(
            &get_id_from_bytes(&doc_with_wrong_version).unwrap_err(),
            has_structure!(
                IronOxideErr::DocumentHeaderParseFailure[contains("not a supported version")]
            )
        );

        assert_that!(
            &get_id_from_bytes(&doc_with_invalid_json).unwrap_err(),
            has_structure!(
                IronOxideErr::DocumentHeaderParseFailure[contains("Header value is corrupted")]
            )
        );
    }

    #[test]
    fn read_good_document_header_test() {
        let enc_doc = BASE64_STANDARD.decode("AgA4eyJfZGlkXyI6ImNjOTIyZTA3NzRhM2MwZWViZTI2NDM2Yzk2ZjdiYzkzIiwiX3NpZF8iOjYwOH1ciL4su5SPZh4eFGuG+5rJ+/I2gDSZAs+2dXw097gU8fBkMWzRo0dDIW0dOxHg/1mio1yMRdDZDA==").unwrap();

        let doc_id = get_id_from_bytes(&enc_doc).unwrap();

        assert_that!(
            &doc_id,
            has_structure!(DocumentId[eq("cc922e0774a3c0eebe26436c96f7bc93".to_string())])
        );

        let doc_parts = parse_document_parts(&enc_doc).unwrap();

        assert_that!(
            &doc_parts.0,
            has_structure!(DocumentHeader {
                document_id: eq(DocumentId("cc922e0774a3c0eebe26436c96f7bc93".to_string())),
                segment_id: eq(608),
            })
        );

        assert_that!(
            &doc_parts.1.bytes(),
            eq(vec![
                92, 136, 190, 44, 187, 148, 143, 102, 30, 30, 20, 107, 134, 251, 154, 201, 251,
                242, 54, 128, 52, 153, 2, 207, 182, 117, 124, 52, 247, 184, 20, 241, 240, 100, 49,
                108, 209, 163, 71, 67, 33, 109, 29, 59, 17, 224, 255, 89, 162, 163, 92, 140, 69,
                208, 217, 12
            ])
        )
    }

    #[test]
    fn generate_document_header_test() {
        let header = DocumentHeader::new("123abc".try_into().unwrap(), 18usize);

        assert_that!(
            &header.pack().0,
            eq(vec![
                2, 0, 29, 123, 34, 95, 100, 105, 100, 95, 34, 58, 34, 49, 50, 51, 97, 98, 99, 34,
                44, 34, 95, 115, 105, 100, 95, 34, 58, 49, 56, 125
            ])
        );
    }
    #[test]
    fn process_policy_good() {
        let recrypt = recrypt::api::Recrypt::new();
        let (_, pubk) = recrypt.generate_key_pair().unwrap();

        let policy = PolicyResponse {
            users_and_groups: vec![
                UserOrGroupWithKey::User {
                    id: "userid1".to_string(),
                    master_public_key: Some(pubk.into()),
                },
                UserOrGroupWithKey::Group {
                    id: "groupid1".to_string(),
                    master_public_key: Some(pubk.into()),
                },
            ],
            invalid_users_and_groups: vec![],
        };

        let (errs, results) = process_policy(&policy);
        assert_that!(results.len() == 2);
        assert_that!(errs.is_empty());

        let ex_user = WithKey {
            id: UserOrGroup::User {
                id: UserId::unsafe_from_string("userid1".to_string()),
            },
            public_key: pubk.into(),
        };

        let ex_group = WithKey {
            id: UserOrGroup::Group {
                id: GroupId::unsafe_from_string("groupid1".to_string()),
            },
            public_key: pubk.into(),
        };

        assert_that!(&results, contains_in_any_order(vec![ex_user, ex_group]));
    }

    #[test]
    fn dedupe_grants_removes_dupes() {
        let recrypt = recrypt::api::Recrypt::new();
        let (_, pubk) = recrypt.generate_key_pair().unwrap();

        let u1 = &UserId::unsafe_from_string("user1".into());
        let g1 = &GroupId::unsafe_from_string("group1".into());
        let grants_w_dupes: Vec<WithKey<UserOrGroup>> = vec![
            WithKey::new(u1.into(), pubk.into()),
            WithKey::new(g1.into(), pubk.into()),
            WithKey::new(u1.into(), pubk.into()),
            WithKey::new(g1.into(), pubk.into()),
        ];

        let deduplicated_grants = dedupe_grants(&grants_w_dupes);
        assert_that!(&deduplicated_grants.len(), eq(2))
    }

    #[test]
    fn encode_encrypted_dek_proto() {
        use recrypt::{api::Hashable, prelude::*};
        let recrypt_api = recrypt::api::Recrypt::new();
        let (_, pubk) = recrypt_api.generate_key_pair().unwrap();
        let signing_keys = recrypt_api.generate_ed25519_key_pair();
        let plaintext = recrypt_api.gen_plaintext();
        let encrypted_value = recrypt_api
            .encrypt(&plaintext, &pubk, &signing_keys)
            .unwrap();
        let user_str = "userid".to_string();

        let edek = EncryptedDek {
            encrypted_dek_data: encrypted_value.clone(),
            grant_to: WithKey {
                public_key: pubk.into(),
                id: UserId::unsafe_from_string(user_str.clone()).borrow().into(),
            },
        };

        let proto_edek: EncryptedDekP = edek.borrow().try_into().unwrap();

        assert_eq!(&user_str, &proto_edek.userOrGroup.userId());
        let (x, y) = pubk.bytes_x_y();
        assert_eq!(
            (x.to_vec(), y.to_vec()),
            (
                proto_edek.userOrGroup.masterPublicKey.x.to_vec(),
                proto_edek.userOrGroup.masterPublicKey.y.to_vec()
            )
        );

        if let recrypt::api::EncryptedValue::EncryptedOnceValue {
            ephemeral_public_key,
            encrypted_message,
            auth_hash,
            public_signing_key,
            signature,
        } = encrypted_value
        {
            assert_eq!(
                (
                    ephemeral_public_key.bytes_x_y().0.to_vec(),
                    ephemeral_public_key.bytes_x_y().1.to_vec()
                ),
                (
                    proto_edek.encryptedDekData.ephemeralPublicKey.x.to_vec(),
                    proto_edek.encryptedDekData.ephemeralPublicKey.y.to_vec()
                )
            );

            assert_eq!(
                encrypted_message.bytes().to_vec(),
                proto_edek.encryptedDekData.encryptedBytes.to_vec()
            );

            assert_eq!(
                auth_hash.bytes().to_vec(),
                proto_edek.encryptedDekData.authHash.to_vec()
            );

            assert_eq!(
                public_signing_key.to_bytes(),
                proto_edek.encryptedDekData.publicSigningKey.to_vec()
            );

            assert_eq!(
                signature.bytes().to_vec(),
                proto_edek.encryptedDekData.signature.to_vec()
            );
        } else {
            panic!("Should be EncryptedOnceValue");
        }
    }

    #[test]
    pub fn unmanaged_edoc_header_properly_encoded() -> Result<(), IronOxideErr> {
        use recrypt::prelude::*;

        let recr = recrypt::api::Recrypt::new();
        let signingkeys = DeviceSigningKeyPair::from(recr.generate_ed25519_key_pair());
        let aes_value = AesEncryptedValue::try_from(&[42u8; 32][..])?;
        let uid = UserId::unsafe_from_string("userid".into());
        let gid = GroupId::unsafe_from_string("groupid".into());
        let user: UserOrGroup = uid.borrow().into();
        let group: UserOrGroup = gid.borrow().into();
        let (_, pubk) = recr.generate_key_pair()?;
        let with_keys = vec![
            WithKey::new(user, pubk.into()),
            WithKey::new(group, pubk.into()),
        ];
        let doc_id = DocumentId("docid".into());
        let seg_id = 33;

        let encryption_result = recrypt_document(
            &signingkeys,
            &recr,
            recr.gen_plaintext(),
            &doc_id,
            with_keys,
        )?
        .into_edoc(DocumentHeader::new(doc_id.clone(), seg_id), aes_value);

        assert_eq!(&encryption_result.header.document_id, &doc_id);
        assert_eq!(&encryption_result.header.segment_id, &seg_id);

        let edoc_bytes = encryption_result.edoc_bytes();
        let (parsed_header, _) = parse_document_parts(&edoc_bytes)?;
        assert_eq!(&encryption_result.header, &parsed_header);

        Ok(())
    }

    #[test]
    pub fn unmanaged_edoc_compare_grants() -> Result<(), IronOxideErr> {
        use crate::proto::transform::{
            UserOrGroup as UserOrGroupP, user_or_group::UserOrGroupId as UserOrGroupIdP,
        };
        use recrypt::prelude::*;

        let recr = recrypt::api::Recrypt::new();
        let signingkeys = DeviceSigningKeyPair::from(recr.generate_ed25519_key_pair());
        let aes_value = AesEncryptedValue::try_from(&[42u8; 32][..])?;
        let uid = UserId::unsafe_from_string("userid".into());
        let gid = GroupId::unsafe_from_string("groupid".into());
        let user: UserOrGroup = uid.borrow().into();
        let group: UserOrGroup = gid.borrow().into();
        let (_, pubk) = recr.generate_key_pair()?;
        let with_keys = vec![
            WithKey::new(user, pubk.into()),
            WithKey::new(group, pubk.into()),
        ];
        let doc_id = DocumentId("docid".into());
        let seg_id = 33;

        let encryption_result = recrypt_document(
            &signingkeys,
            &recr,
            recr.gen_plaintext(),
            &doc_id,
            with_keys,
        )?
        .into_edoc(DocumentHeader::new(doc_id.clone(), seg_id), aes_value);

        // create an unmanaged result, which does the proto serialization
        let doc_encrypt_unmanaged_result =
            DocumentEncryptUnmanagedResult::new(encryption_result, vec![])?;

        // then deserialize and extract the user/groups from the edeks
        let proto_edeks =
            EncryptedDeksP::parse_from_bytes(doc_encrypt_unmanaged_result.encrypted_deks())?;
        let result: Result<Vec<UserOrGroup>, IronOxideErr> = proto_edeks
            .edeks
            .as_slice()
            .iter()
            .map(|edek| {
                if let Some(UserOrGroupP {
                    UserOrGroupId: Some(proto_uog),
                    ..
                }) = edek.userOrGroup.as_ref()
                {
                    match proto_uog {
                        UserOrGroupIdP::UserId(user_chars) => Ok(UserOrGroup::User {
                            id: user_chars.to_string().try_into()?,
                        }),
                        UserOrGroupIdP::GroupId(group_chars) => Ok(UserOrGroup::Group {
                            id: group_chars.to_string().try_into()?,
                        }),
                    }
                } else {
                    Err(IronOxideErr::ProtobufValidationError(format!(
                        "EncryptedDek does not have a valid user or group: {:?}",
                        &edek
                    )))
                }
            })
            .collect();

        // show that grants() and the edeks contain the same users/groups
        assert_that!(
            &result?,
            contains_in_any_order(vec![
                UserOrGroup::Group { id: gid.clone() },
                UserOrGroup::User { id: uid.clone() }
            ])
        );

        assert_that!(
            &doc_encrypt_unmanaged_result.grants().to_vec(),
            contains_in_any_order(vec![
                UserOrGroup::Group { id: gid },
                UserOrGroup::User { id: uid }
            ])
        );

        Ok(())
    }

    #[test]
    pub fn edek_edoc_no_match() -> Result<(), IronOxideErr> {
        use recrypt::prelude::*;

        let recr = recrypt::api::Recrypt::new();
        let signingkeys = DeviceSigningKeyPair::from(recr.generate_ed25519_key_pair());
        let aes_value = AesEncryptedValue::try_from(&[42u8; 32][..])?;
        let uid = UserId::unsafe_from_string("userid".into());
        let gid = GroupId::unsafe_from_string("groupid".into());
        let user: UserOrGroup = uid.borrow().into();
        let group: UserOrGroup = gid.borrow().into();
        let (_, pubk) = recr.generate_key_pair()?;
        let with_keys = vec![
            WithKey::new(user, pubk.into()),
            WithKey::new(group, pubk.into()),
        ];
        let doc_id = DocumentId("docid".into());
        let seg_id = 33;

        let encryption_result = recrypt_document(
            &signingkeys,
            &recr,
            recr.gen_plaintext(),
            &doc_id,
            with_keys,
        )?;

        // orig doc
        let edoc1 = encryption_result.clone().into_edoc(
            DocumentHeader::new(doc_id.clone(), seg_id),
            aes_value.clone(),
        );

        // with wrong doc id
        let edoc2 = encryption_result.clone().into_edoc(
            DocumentHeader::new(DocumentId("other_docid".into()), seg_id),
            aes_value.clone(),
        );

        // with wrong seg id
        let edoc3 = encryption_result.into_edoc(DocumentHeader::new(doc_id.clone(), 42), aes_value);

        let edoc1_bytes = edoc1.edoc_bytes();
        let edek2_bytes = edoc2.edek_bytes()?;
        let edek3_bytes = edoc3.edek_bytes()?;

        // test non matching doc ids
        {
            let proto_edeks =
                EncryptedDeksP::parse_from_bytes(&edek2_bytes).map_err(IronOxideErr::from)?;
            let (doc_meta, _) = parse_document_parts(&edoc1_bytes)?;
            let err = edeks_and_header_match_or_err(&proto_edeks, &doc_meta).unwrap_err();

            assert_that!(&err, is_variant!(IronOxideErr::UnmanagedDecryptionError));
            if let IronOxideErr::UnmanagedDecryptionError(
                edek_doc_id,
                edek_seg_id,
                edoc_doc_id,
                edoc_seg_id,
            ) = err
            {
                assert_eq!(&edek_doc_id, "other_docid");
                assert_eq!(edek_seg_id, seg_id as i32);
                assert_eq!(&edoc_doc_id, doc_id.id());
                assert_eq!(edoc_seg_id, seg_id as i32);
            }
        }

        // test non matching seg ids
        {
            let proto_edeks =
                EncryptedDeksP::parse_from_bytes(&edek3_bytes).map_err(IronOxideErr::from)?;
            let (doc_meta, _) = parse_document_parts(&edoc1_bytes)?;
            let err = edeks_and_header_match_or_err(&proto_edeks, &doc_meta).unwrap_err();

            assert_that!(&err, is_variant!(IronOxideErr::UnmanagedDecryptionError));
            if let IronOxideErr::UnmanagedDecryptionError(
                edek_doc_id,
                edek_seg_id,
                edoc_doc_id,
                edoc_seg_id,
            ) = err
            {
                assert_eq!(&edek_doc_id, doc_id.id());
                assert_eq!(edek_seg_id, 42i32);
                assert_eq!(&edoc_doc_id, doc_id.id());
                assert_eq!(edoc_seg_id, seg_id as i32);
            }
        }

        Ok(())
    }

    /// Helper: create EDEK proto bytes with the given user/group grants for a document.
    fn build_test_edek_bytes(
        user_ids: &[&str],
        group_ids: &[&str],
        doc_id: &str,
        seg_id: i32,
    ) -> Result<Vec<u8>, IronOxideErr> {
        use recrypt::prelude::*;
        let recr = recrypt::api::Recrypt::new();
        let signingkeys = DeviceSigningKeyPair::from(recr.generate_ed25519_key_pair());
        let (_, pubk) = recr.generate_key_pair()?;

        let mut with_keys: Vec<WithKey<UserOrGroup>> = Vec::new();
        for uid_str in user_ids {
            let uid = UserId::unsafe_from_string(uid_str.to_string());
            with_keys.push(WithKey::new(uid.borrow().into(), pubk.into()));
        }
        for gid_str in group_ids {
            let gid = GroupId::unsafe_from_string(gid_str.to_string());
            with_keys.push(WithKey::new(gid.borrow().into(), pubk.into()));
        }

        let document_id = DocumentId(doc_id.into());
        let recryption_result = recrypt_document(
            &signingkeys,
            &recr,
            recr.gen_plaintext(),
            &document_id,
            with_keys,
        )?;
        edeks_to_edeks_proto(&recryption_result.edeks, doc_id, seg_id)
    }

    mod revoke_access_unmanaged {
        use super::*;

        #[test]
        fn revoke_user_succeeds() {
            let edek_bytes = build_test_edek_bytes(&["user1", "user2"], &[], "doc1", 1).unwrap();
            let revoke_list = vec![UserOrGroup::User {
                id: UserId::unsafe_from_string("user1".into()),
            }];
            let result = document_revoke_access_unmanaged(&edek_bytes, &revoke_list).unwrap();

            assert!(result.access_via().is_none());
            assert_eq!(result.succeeded().len(), 1);
            assert_eq!(
                result.succeeded()[0],
                UserOrGroup::User {
                    id: UserId::unsafe_from_string("user1".into())
                }
            );
            assert!(result.failed().is_empty());

            // verify the remaining EDEKs only contain user2
            let remaining = EncryptedDeksP::parse_from_bytes(result.encrypted_deks()).unwrap();
            assert_eq!(remaining.edeks.len(), 1);
        }

        #[test]
        fn revoke_group_succeeds() {
            let edek_bytes = build_test_edek_bytes(&[], &["group1", "group2"], "doc1", 1).unwrap();
            let revoke_list = vec![UserOrGroup::Group {
                id: GroupId::unsafe_from_string("group2".into()),
            }];
            let result = document_revoke_access_unmanaged(&edek_bytes, &revoke_list).unwrap();

            assert_eq!(result.succeeded().len(), 1);
            assert_eq!(
                result.succeeded()[0],
                UserOrGroup::Group {
                    id: GroupId::unsafe_from_string("group2".into())
                }
            );
            assert!(result.failed().is_empty());

            let remaining = EncryptedDeksP::parse_from_bytes(result.encrypted_deks()).unwrap();
            assert_eq!(remaining.edeks.len(), 1);
        }

        #[test]
        fn revoke_nonexistent_user_reports_failure() {
            let edek_bytes = build_test_edek_bytes(&["user1"], &[], "doc1", 1).unwrap();
            let revoke_list = vec![UserOrGroup::User {
                id: UserId::unsafe_from_string("no_such_user".into()),
            }];
            let result = document_revoke_access_unmanaged(&edek_bytes, &revoke_list).unwrap();

            assert!(result.succeeded().is_empty());
            assert_eq!(result.failed().len(), 1);
            assert_eq!(
                result.failed()[0].user_or_group,
                UserOrGroup::User {
                    id: UserId::unsafe_from_string("no_such_user".into())
                }
            );
            assert!(result.failed()[0].err.contains("not found in EDEK grants"));

            // original EDEKs should be unmodified in count
            let remaining = EncryptedDeksP::parse_from_bytes(result.encrypted_deks()).unwrap();
            assert_eq!(remaining.edeks.len(), 1);
        }

        #[test]
        fn revoke_mixed_success_and_failure() {
            let edek_bytes = build_test_edek_bytes(&["user1"], &["group1"], "doc1", 1).unwrap();
            let revoke_list = vec![
                UserOrGroup::User {
                    id: UserId::unsafe_from_string("user1".into()),
                },
                UserOrGroup::Group {
                    id: GroupId::unsafe_from_string("nonexistent_group".into()),
                },
            ];
            let result = document_revoke_access_unmanaged(&edek_bytes, &revoke_list).unwrap();

            assert_eq!(result.succeeded().len(), 1);
            assert_eq!(
                result.succeeded()[0],
                UserOrGroup::User {
                    id: UserId::unsafe_from_string("user1".into())
                }
            );
            assert_eq!(result.failed().len(), 1);
            assert_eq!(
                result.failed()[0].user_or_group,
                UserOrGroup::Group {
                    id: GroupId::unsafe_from_string("nonexistent_group".into())
                }
            );

            let remaining = EncryptedDeksP::parse_from_bytes(result.encrypted_deks()).unwrap();
            assert_eq!(remaining.edeks.len(), 1); // only group1 remains
        }

        #[test]
        fn revoke_all_grants_leaves_empty_edeks() {
            let edek_bytes = build_test_edek_bytes(&["user1"], &["group1"], "doc1", 1).unwrap();
            let revoke_list = vec![
                UserOrGroup::User {
                    id: UserId::unsafe_from_string("user1".into()),
                },
                UserOrGroup::Group {
                    id: GroupId::unsafe_from_string("group1".into()),
                },
            ];
            let result = document_revoke_access_unmanaged(&edek_bytes, &revoke_list).unwrap();

            assert_eq!(result.succeeded().len(), 2);
            assert!(result.failed().is_empty());

            let remaining = EncryptedDeksP::parse_from_bytes(result.encrypted_deks()).unwrap();
            assert_eq!(remaining.edeks.len(), 0);
        }

        #[test]
        fn revoke_empty_list_is_noop() {
            let edek_bytes = build_test_edek_bytes(&["user1"], &["group1"], "doc1", 1).unwrap();
            let result = document_revoke_access_unmanaged(&edek_bytes, &[]).unwrap();

            assert!(result.succeeded().is_empty());
            assert!(result.failed().is_empty());

            let remaining = EncryptedDeksP::parse_from_bytes(result.encrypted_deks()).unwrap();
            assert_eq!(remaining.edeks.len(), 2);
        }

        #[test]
        fn revoke_preserves_document_id_and_segment() {
            let edek_bytes =
                build_test_edek_bytes(&["user1", "user2"], &[], "my_doc_42", 99).unwrap();
            let revoke_list = vec![UserOrGroup::User {
                id: UserId::unsafe_from_string("user1".into()),
            }];
            let result = document_revoke_access_unmanaged(&edek_bytes, &revoke_list).unwrap();

            let remaining = EncryptedDeksP::parse_from_bytes(result.encrypted_deks()).unwrap();
            assert_eq!(remaining.documentId.to_string(), "my_doc_42");
            assert_eq!(remaining.segmentId, 99);
        }

        #[test]
        fn revoke_garbage_bytes_fails() {
            let result = document_revoke_access_unmanaged(b"not_valid_proto", &[]);
            assert!(result.is_err());
        }

        #[test]
        fn revoke_empty_bytes_is_noop() {
            // empty bytes parse as an empty proto (no edeks, empty doc id, segment 0)
            let result = document_revoke_access_unmanaged(&[], &[]).unwrap();
            assert!(result.succeeded().is_empty());
            assert!(result.failed().is_empty());
        }
    }

    mod get_id_from_edeks {
        use super::*;
        use crate::document::advanced::DocumentAdvancedOps;
        use crate::internal::tests::create_test_sdk;

        #[test]
        fn extracts_document_id_from_valid_edeks() {
            let edek_bytes = build_test_edek_bytes(&["user1"], &[], "test_doc_id", 1).unwrap();
            let sdk = create_test_sdk().unwrap();
            let doc_id = sdk
                .document_get_id_from_edeks_unmanaged(&edek_bytes)
                .unwrap();
            assert_eq!(doc_id.id(), "test_doc_id");
        }

        #[test]
        fn empty_bytes_returns_err_for_missing_doc_id() {
            let sdk = create_test_sdk().unwrap();
            // empty proto has empty string documentId which should fail DocumentId validation
            let result = sdk.document_get_id_from_edeks_unmanaged(&[]);
            assert!(result.is_err());
        }
    }

    mod edeks_to_proto_roundtrip {
        use super::*;

        #[test]
        fn roundtrip_preserves_doc_id_segment_and_edek_count() {
            let recr = recrypt::api::Recrypt::new();
            let signingkeys = DeviceSigningKeyPair::from(recr.generate_ed25519_key_pair());
            let (_, pubk) = recr.generate_key_pair().unwrap();
            let uid = UserId::unsafe_from_string("user1".into());
            let gid = GroupId::unsafe_from_string("group1".into());
            let with_keys = vec![
                WithKey::new(UserOrGroup::from(uid), pubk.into()),
                WithKey::new(UserOrGroup::from(gid), pubk.into()),
            ];
            let doc_id = DocumentId("roundtrip_doc".into());

            let recryption_result = recrypt_document(
                &signingkeys,
                &recr,
                recr.gen_plaintext(),
                &doc_id,
                with_keys,
            )
            .unwrap();

            let bytes =
                edeks_to_edeks_proto(&recryption_result.edeks, "roundtrip_doc", 77).unwrap();
            let parsed = EncryptedDeksP::parse_from_bytes(&bytes).unwrap();

            assert_eq!(parsed.documentId.to_string(), "roundtrip_doc");
            assert_eq!(parsed.segmentId, 77);
            assert_eq!(parsed.edeks.len(), 2);
        }

        #[test]
        fn empty_edeks_produces_valid_proto() {
            let bytes = edeks_to_edeks_proto(&[], "empty_doc", 5).unwrap();
            let parsed = EncryptedDeksP::parse_from_bytes(&bytes).unwrap();
            assert_eq!(parsed.documentId.to_string(), "empty_doc");
            assert_eq!(parsed.segmentId, 5);
            assert_eq!(parsed.edeks.len(), 0);
        }
    }
}