use std::{borrow::Cow, collections::HashMap};

use serde::{Deserialize, Serialize};
use serde_json::Value;

use crate::{
    common::{Id, UtcDate},
    endpoints::session::Account,
};

#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct PrincipalsSessionCapabilities {}

#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct PrincipalsAccountCapabilities<'a> {
    /// The id of the principal in this account that corresponds to the user
    /// fetching this object, if any.
    #[serde(borrow)]
    pub current_user_principal_id: Option<Id<'a>>,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct PrincipalsOwnerAccountCapabilities<'a> {
    /// The id of an account with the `urn:ietf:params:jmap:principals`
    /// capability that contains the corresponding Principal object.
    #[serde(borrow)]
    pub account_id_for_principal: Id<'a>,
    /// The id of the Principal that owns this account.
    #[serde(borrow)]
    pub principal_id: Id<'a>,
}

/// A Principal represents an individual, group, location (e.g. a room),
/// resource (e.g. a projector) or other entity in a collaborative environment.
/// Sharing in JMAP is generally configured by assigning rights to certain data
/// within an account to other principals, for example a user may assign
/// permission to read their calendar to a principal representing another user,
/// or their team.
///
/// In a shared environment such as a workplace, a user may have access to a
/// large number of principals.
///
/// In most systems the user will have access to a single Account containing
/// Principal objects, but they may have access to multiple if, for example,
/// aggregating data from different places.
#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Principal<'a> {
    /// The id of the principal.
    #[serde(borrow)]
    pub id: Id<'a>,
    pub type_: PrincipalType,
    /// The name of the principal, e.g. “Jane Doe”, or “Room 4B”.
    #[serde(borrow)]
    pub name: Cow<'a, str>,
    /// A longer description of the principal, for example details about the facilities of a
    /// resource, or null if no description available.
    #[serde(borrow)]
    pub description: Option<Cow<'a, str>>,
    /// An email address for the principal, or null if no email is available.
    #[serde(borrow)]
    pub email: Option<Cow<'a, str>>,
    /// The time zone for this principal, if known. If not null, the value MUST
    /// be a time zone id from the IANA Time Zone Database TZDB.
    #[serde(borrow)]
    pub time_zone: Option<Cow<'a, str>>,
    /// A map of JMAP capability URIs to domain specific information about the principal in
    /// relation to that capability, as defined in the document that registered the capability.
    #[serde(borrow)]
    pub capabilities: HashMap<Cow<'a, str>, Value>,
    /// A map of account id to Account object for each JMAP Account containing data for this
    /// principal that the user has access to, or null if none.
    #[serde(borrow)]
    pub accounts: Option<HashMap<Id<'a>, Account<'a>>>,
}

#[derive(Serialize, Deserialize, Clone, Copy, Debug)]
#[serde(rename_all = "camelCase")]
pub enum PrincipalType {
    /// This represents a single person.
    Individual,
    /// This represents a group of people.
    Group,
    /// This represents some resource, e.g. a projector.
    Resource,
    /// This represents a location.
    Location,
    /// This represents some other undefined principal.
    Other,
}

/// The ShareNotification data type records when the user’s permissions to access a shared object
/// changes. ShareNotification are only created by the server; users cannot create them explicitly.
/// Notifications are stored in the same Account as the Principals.
///
/// Clients SHOULD present the list of notifications to the user and allow them to dismiss them. To
/// dismiss a notification you use a standard “/set” call to destroy it.
///
/// The server SHOULD create a ShareNotification whenever the user’s permissions change on an
/// object. It SHOULD NOT create a notification for permission changes to a group principal, even if
/// the user is in the group.
#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ShareNotification<'a> {
    /// The id of the ShareNotification.
    pub id: Cow<'a, str>,
    /// The time this notification was created.
    pub created: UtcDate,
    /// Who made the change.
    pub changed_by: Person<'a>,
    /// The name of the data type for the object whose permissions have changed, e.g. “Calendar” or
    /// “Mailbox”.
    pub object_id: Cow<'a, str>,
    /// The id of the account where this object exists.
    pub object_account_id: Cow<'a, str>,
    /// The name of the object at the time the notification was made.
    pub name: Cow<'a, str>,
    /// The “myRights” property of the object for the user before the change.
    pub old_rights: Cow<'a, str>,
    /// The “myRights” property of the object for the user after the change.
    pub new_rights: Cow<'a, str>,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Person<'a> {
    /// The name of the person who made the change.
    pub name: Cow<'a, str>,
    /// The email of the person who made the change, or null if no email is available.
    pub email: Option<Cow<'a, str>>,
    /// The id of the Principal corresponding to the person who made the change, or null if no
    /// associated principal.
    pub principal: Option<Cow<'a, str>>,
}