//! Modifying the state of Foo objects on the server is done via the
//! "Foo/set" method.  This encompasses creating, updating, and
//! destroying Foo records.  This allows the server to sort out ordering
//! and dependencies that may exist if doing multiple operations at once
//! (for example, to ensure there is always a minimum number of a certain
//! record type).

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

use serde::{Deserialize, Serialize};
use serde_json::Value;
use serde_with::{serde_as, BorrowCow};

use crate::{common::Id, endpoints::object::ObjectState};

#[serde_as]
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct SetParams<'a, T> {
    /// The id of the account to use.
    account_id: Id<'a>,
    /// This is a state string as returned by the "Foo/get" method
    /// (representing the state of all objects of this type in the
    /// account). If supplied, the string must match the current state;
    /// otherwise, the method will be aborted and a "stateMismatch" error
    /// returned. If null, any changes will be applied to the current
    /// state.
    #[serde(borrow)]
    if_in_state: Option<ObjectState<'a>>,
    /// A map of a *creation id* (a temporary id set by the client) to Foo
    /// objects, or null if no objects are to be created.
    ///
    /// The Foo object type definition may define default values for
    /// properties.  Any such property may be omitted by the client.
    ///
    /// The client MUST omit any properties that may only be set by the
    /// server (for example, the "id" property on most object types).
    #[serde(default)]
    create: HashMap<Id<'a>, T>,
    /// A map of an id to a Patch object to apply to the current Foo
    /// object with that id, or null if no objects are to be updated.
    #[serde(default)]
    update: HashMap<Id<'a>, PatchObject<'a>>,
    /// A list of ids for Foo objects to permanently delete, or null if no
    /// objects are to be destroyed.
    #[serde(default)]
    destroy: Vec<Id<'a>>,
}

/// A *PatchObject* is of type "String[*]" and represents an unordered
/// set of patches.  The keys are a path in JSON Pointer format
/// [RFC6901], with an implicit leading "/" (i.e., prefix each key
/// with "/" before applying the JSON Pointer evaluation algorithm).
#[serde_as]
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct PatchObject<'a>(#[serde_as(as = "HashMap<BorrowCow, _>")] HashMap<Cow<'a, str>, Value>);

#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct SetResult<'a, T> {
    /// The id of the account used for the call.
    #[serde(borrow)]
    account_id: Id<'a>,
    /// The state string that would have been returned by "Foo/get" before
    /// making the requested changes, or null if the server doesn't know
    /// what the previous state string was.
    #[serde(borrow)]
    old_state: Option<ObjectState<'a>>,
    /// The state string that will now be returned by "Foo/get".
    #[serde(borrow)]
    new_state: ObjectState<'a>,
    /// A map of the creation id to an object containing any properties of
    /// the created Foo object that were not sent by the client.  This
    /// includes all server-set properties (such as the "id" in most
    /// object types) and any properties that were omitted by the client
    /// and thus set to a default by the server.
    ///
    /// This argument is null if no Foo objects were successfully created.
    #[serde(default, borrow)]
    created: HashMap<Id<'a>, T>,
    /// The keys in this map are the ids of all Foos that were
    /// successfully updated.
    ///
    /// The value for each id is a Foo object containing any property that
    /// changed in a way *not* explicitly requested by the PatchObject
    /// sent to the server, or null if none.  This lets the client know of
    /// any changes to server-set or computed properties.
    ///
    /// This argument is null if no Foo objects were successfully updated.
    #[serde(default, borrow)]
    updated: HashMap<Id<'a>, Option<T>>,
    /// A list of Foo ids for records that were successfully destroyed, or
    /// null if none.
    #[serde(default, borrow)]
    destroyed: Vec<Id<'a>>,
    /// A map of the creation id to a SetError object for each record that
    /// failed to be created, or null if all successful.
    #[serde(default, borrow)]
    not_created: HashMap<Id<'a>, SetError<'a>>,
    /// A map of the Foo id to a SetError object for each record that
    /// failed to be updated, or null if all successful.
    #[serde(default, borrow)]
    not_updated: HashMap<Id<'a>, SetError<'a>>,
    /// A map of the Foo id to a SetError object for each record that
    /// failed to be destroyed, or null if all successful.
    #[serde(default, borrow)]
    not_destroyed: HashMap<Id<'a>, SetError<'a>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct SetError<'a> {
    /// The type of error.
    #[serde(rename = "type")]
    type_: SetErrorKind,
    /// A description of the error to help with debugging that includes an
    /// explanation of what the problem was.  This is a non-localised
    /// string and is not intended to be shown directly to end users.
    #[serde(borrow)]
    description: Option<Cow<'a, str>>,
    /// The SetError object SHOULD also have a property called "properties" of
    /// type "String[]" that lists *all* the properties that were invalid. For
    /// type of `invalidProperties`.
    #[serde(borrow)]
    properties: Vec<Cow<'a, str>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub enum SetErrorKind {
    /// (create; update; destroy).  The create/update/destroy would violate
    /// an ACL or other permissions policy.
    Forbidden,
    /// (create; update).  The create would exceed a server-defined limit
    /// on the number or total size of objects of this type.
    OverQuota,
    /// (create; update).  The create/update would result in an object that
    /// exceeds a server-defined limit for the maximum size of a single object
    /// of this type.
    TooLarge,
    /// (create).  Too many objects of this type have been created recently,
    /// and a server-defined rate limit has been reached.  It may work if tried
    /// again later.
    RateLimit,
    /// (update; destroy).  The id given to update/destroy cannot be found.
    NotFound,
    /// (update).  The PatchObject given to update the record was not a valid
    /// patch (see the patch description).
    InvalidPatch,
    /// (update).  The client requested that an object be both updated and
    /// destroyed in the same /set request, and the server has decided to
    /// therefore ignore the update.
    WillDestroy,
    /// (create; update).  The record given is invalid in some way.  For
    /// example:
    ///
    /// - It contains properties that are invalid according to the type specification of this
    ///   record type.
    /// - It contains a property that may only be set by the server (e.g., "id") and is different
    ///   to the current value.  Note, to allow clients to pass whole objects back, it is not an
    ///   error to include a server-set property in an update as long as the value is identical to
    ///   the current value on the server.
    /// - There is a reference to another record (foreign key), and the given id does not
    ///   correspond to a valid record.
    InvalidProperties,
    /// (create; destroy).  This is a singleton type, so you cannot create
    /// another one or destroy the existing one.
    Singleton,
}