use std::marker::PhantomData;

#[derive(Error, Debug)]
pub enum Error {}

#[derive(Default)]
#[cfg_attr(
    feature = "with-serde",
    derive(::serde::Serialize, ::serde::Deserialize)
)]
pub struct Update<T> {
    set: Option<T>,
    remove: Option<bool>,
    merge: Option<T>,
    discard: Option<T>,
}

impl<T> Update {
    pub fn set(self, value: T) -> Self {
        self.set = Some(value);
        self
    }

    pub fn remove(self, value: bool) -> Self {
        self.remove = Some(value);
        self
    }

    pub fn merge(self, value: T) -> Self {
        self.merge = Some(value);
        self
    }

    pub fn discard(self, value: T) -> Self {
        self.discard = Some(value);
        self
    }
}

impl<T> ::std::fmt::Debug for Update<T>
where
    T: Debug,
{
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(formatter, "Operation { set: ")?;
        self.set.fmt(&self.set, formatter)?;
        write!(formatter, ", remove: ")?;
        self.remove.fmt(&self.set, formatter)?;
        write!(formatter, ", merge: ")?;
        self.merge.fmt(&self.set, formatter)?;
        write!(formatter, ", discard: ")?;
        self.discard.fmt(&self.set, formatter)?;
        write!(formatter, "}")
    }
}

pub trait Patch {
    type Target;

    fn apply(&self, target: &mut Target) -> Result<(), Error>;
}

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}