automorph 0.2.0

//! Implementations for Option and Result types.

use automerge::{
    ChangeHash, ObjId, ObjType, Prop, ReadDoc, ScalarValue, Value, transaction::Transactable,
};

use crate::{Automorph, ChangeReport, Error, FieldCursor, OptionChanges, Result, ResultChanges, ScalarCursor};

// =============================================================================
// OptionCursor
// =============================================================================

/// Cursor for tracking `Option<T>` fields efficiently.
///
/// This cursor caches whether the Option was `Some` when last refreshed,
/// enabling O(1) detection of:
/// - `None` → `Some` transitions
/// - `Some` → `None` transitions
/// - Changes to the inner value when both are `Some`
///
/// # Type Parameters
///
/// - `C`: The cursor type for the inner `T` when `Option<T>` is `Some`
///
/// # Example
///
/// ```rust
/// use automorph::{Automorph, Tracked, ChangeReport};
/// use automerge::{AutoCommit, ROOT};
///
/// #[derive(Automorph, Clone, Debug, Default)]
/// struct Container {
///     value: Option<String>,
/// }
///
/// let mut doc = AutoCommit::new();
/// Container { value: Some("hello".to_string()) }
///     .save(&mut doc, &ROOT, "container").unwrap();
///
/// let mut tracked = Tracked::<Container>::load(&doc, &ROOT, "container").unwrap();
///
/// // Modify the value
/// Container { value: Some("world".to_string()) }
///     .save(&mut doc, &ROOT, "container").unwrap();
///
/// // Check for changes - has_structural_changes now works for Option fields
/// let changes = tracked.update(&doc).unwrap();
/// assert!(changes.any());
/// ```
///
/// # Thread Safety
///
/// `OptionCursor<C>` is `Send` and `Sync` when `C` is.
#[derive(Clone, Debug, Default)]
pub struct OptionCursor<C: FieldCursor> {
    /// Whether the option was Some when cached
    pub is_some: bool,
    /// Cached ObjId when Some (for value comparison)
    pub obj_id: Option<ObjId>,
    /// Inner cursor for when the value is Some
    pub inner_cursor: C,
}

impl<C: FieldCursor> FieldCursor for OptionCursor<C> {
    type Changes = OptionChanges<C::Changes>;

    fn diff<D: ReadDoc>(&self, doc: &D, obj: &ObjId) -> crate::Result<Self::Changes> {
        // Check current state in document
        let current = doc.get(obj, "")?;
        let current_is_some = current.is_some();

        match (self.is_some, current_is_some) {
            // Was None, still None - no change
            (false, false) => Ok(OptionChanges::Unchanged),
            // Was None, now Some
            (false, true) => Ok(OptionChanges::BecameSome),
            // Was Some, now None
            (true, false) => Ok(OptionChanges::BecameNone),
            // Was Some, still Some - check inner value
            (true, true) => {
                if let Some((_, current_id)) = current {
                    let inner_changes = self.inner_cursor.diff(doc, &current_id)?;
                    if inner_changes.any() {
                        Ok(OptionChanges::Inner(inner_changes))
                    } else {
                        Ok(OptionChanges::Unchanged)
                    }
                } else {
                    Ok(OptionChanges::BecameNone)
                }
            }
        }
    }

    fn refresh<D: ReadDoc>(&mut self, doc: &D, obj: &ObjId) -> crate::Result<()> {
        match doc.get(obj, "")? {
            Some((_, id)) => {
                self.is_some = true;
                self.obj_id = Some(id.clone());
                self.inner_cursor.refresh(doc, &id)?;
            }
            None => {
                self.is_some = false;
                self.obj_id = None;
                // inner_cursor stays at default since there's no value
            }
        }
        Ok(())
    }
}

impl<C: FieldCursor> OptionCursor<C> {
    /// Compare this cursor against the current document state at a key.
    ///
    /// This is used internally by struct cursors to check Option fields.
    pub fn diff_at_key<D: ReadDoc>(
        &self,
        doc: &D,
        obj: &ObjId,
        key: &str,
    ) -> crate::Result<OptionChanges<C::Changes>> {
        // Check current state at the key
        let current = doc.get(obj, key)?;
        let current_is_some = current.is_some();

        match (self.is_some, current_is_some) {
            // Was None, still None - no change
            (false, false) => Ok(OptionChanges::Unchanged),
            // Was None, now Some
            (false, true) => Ok(OptionChanges::BecameSome),
            // Was Some, now None
            (true, false) => Ok(OptionChanges::BecameNone),
            // Was Some, still Some - check inner value using ObjId comparison
            (true, true) => {
                if let Some((_, current_id)) = current {
                    // For scalar types, compare ObjIds directly
                    // For object types, delegate to inner cursor
                    let inner_changes = self.inner_cursor.diff(doc, &current_id)?;
                    if inner_changes.any() {
                        Ok(OptionChanges::Inner(inner_changes))
                    } else {
                        Ok(OptionChanges::Unchanged)
                    }
                } else {
                    Ok(OptionChanges::BecameNone)
                }
            }
        }
    }

    /// Refresh this cursor from the current document state at a key.
    ///
    /// This is used internally by struct cursors to refresh Option fields.
    pub fn refresh_at_key<D: ReadDoc>(
        &mut self,
        doc: &D,
        obj: &ObjId,
        key: &str,
    ) -> crate::Result<()> {
        match doc.get(obj, key)? {
            Some((_, id)) => {
                self.is_some = true;
                self.obj_id = Some(id.clone());
                self.inner_cursor.refresh(doc, &id)?;
            }
            None => {
                self.is_some = false;
                self.obj_id = None;
                // inner_cursor stays at default since there's no value
            }
        }
        Ok(())
    }
}

// =============================================================================
// ResultCursor
// =============================================================================

/// Cursor for tracking `Result<T, E>` fields efficiently.
///
/// This cursor caches whether the Result was `Ok` or `Err` when last refreshed,
/// enabling O(1) detection of:
/// - `Err` → `Ok` transitions
/// - `Ok` → `Err` transitions
/// - Changes to the inner value when variant matches
///
/// # Type Parameters
///
/// - `OkC`: The cursor type for the inner `T` when `Result<T, E>` is `Ok`
/// - `ErrC`: The cursor type for the inner `E` when `Result<T, E>` is `Err`
///
/// # Thread Safety
///
/// `ResultCursor<OkC, ErrC>` is `Send` and `Sync` when both `OkC` and `ErrC` are.
#[derive(Clone, Debug, Default)]
pub struct ResultCursor<OkC: FieldCursor, ErrC: FieldCursor> {
    /// Whether the result was Ok (true), Err (false), or None (not set)
    pub is_ok: Option<bool>,
    /// Cached ObjId for the map containing Ok/Err
    pub map_id: Option<ObjId>,
    /// Cursor for Ok variant
    pub ok_cursor: OkC,
    /// Cursor for Err variant
    pub err_cursor: ErrC,
}

impl<OkC: FieldCursor, ErrC: FieldCursor> FieldCursor for ResultCursor<OkC, ErrC> {
    type Changes = ResultChanges<OkC::Changes, ErrC::Changes>;

    fn diff<D: ReadDoc>(&self, doc: &D, obj: &ObjId) -> crate::Result<Self::Changes> {
        // Result is stored as a map with "Ok" or "Err" key
        let current = doc.get(obj, "")?;

        if let Some((_, map_id)) = current {
            let has_ok = doc.get(&map_id, "Ok")?.is_some();
            let has_err = doc.get(&map_id, "Err")?.is_some();

            match (self.is_ok, has_ok, has_err) {
                // No previous state - treat as new
                (None, true, false) => Ok(ResultChanges::BecameOk),
                (None, false, true) => Ok(ResultChanges::BecameErr),
                (None, _, _) => Ok(ResultChanges::Unchanged),

                // Was Ok, still Ok - check inner
                (Some(true), true, false) => {
                    if let Some((_, ok_id)) = doc.get(&map_id, "Ok")? {
                        let inner_changes = self.ok_cursor.diff(doc, &ok_id)?;
                        if inner_changes.any() {
                            Ok(ResultChanges::OkInner(inner_changes))
                        } else {
                            Ok(ResultChanges::Unchanged)
                        }
                    } else {
                        Ok(ResultChanges::BecameErr)
                    }
                }

                // Was Err, still Err - check inner
                (Some(false), false, true) => {
                    if let Some((_, err_id)) = doc.get(&map_id, "Err")? {
                        let inner_changes = self.err_cursor.diff(doc, &err_id)?;
                        if inner_changes.any() {
                            Ok(ResultChanges::ErrInner(inner_changes))
                        } else {
                            Ok(ResultChanges::Unchanged)
                        }
                    } else {
                        Ok(ResultChanges::BecameOk)
                    }
                }

                // Variant changes
                (Some(true), false, true) => Ok(ResultChanges::BecameErr),
                (Some(false), true, false) => Ok(ResultChanges::BecameOk),

                // Invalid states
                (_, true, true) => Err(Error::invalid_value(
                    "Result cannot have both 'Ok' and 'Err' keys",
                )),
                (_, false, false) => Ok(ResultChanges::Unchanged),
            }
        } else {
            // Result was deleted
            match self.is_ok {
                Some(_) => Ok(ResultChanges::Unchanged), // Changed to deleted
                None => Ok(ResultChanges::Unchanged),
            }
        }
    }

    fn refresh<D: ReadDoc>(&mut self, doc: &D, obj: &ObjId) -> crate::Result<()> {
        match doc.get(obj, "")? {
            Some((_, map_id)) => {
                self.map_id = Some(map_id.clone());

                let has_ok = doc.get(&map_id, "Ok")?.is_some();
                let has_err = doc.get(&map_id, "Err")?.is_some();

                if has_ok {
                    self.is_ok = Some(true);
                    if let Some((_, ok_id)) = doc.get(&map_id, "Ok")? {
                        self.ok_cursor.refresh(doc, &ok_id)?;
                    }
                } else if has_err {
                    self.is_ok = Some(false);
                    if let Some((_, err_id)) = doc.get(&map_id, "Err")? {
                        self.err_cursor.refresh(doc, &err_id)?;
                    }
                }
            }
            None => {
                self.is_ok = None;
                self.map_id = None;
            }
        }
        Ok(())
    }
}

impl<OkC: FieldCursor, ErrC: FieldCursor> ResultCursor<OkC, ErrC> {
    /// Compare this cursor against the current document state at a key.
    ///
    /// This is used internally by struct cursors to check Result fields.
    pub fn diff_at_key<D: ReadDoc>(
        &self,
        doc: &D,
        obj: &ObjId,
        key: &str,
    ) -> crate::Result<ResultChanges<OkC::Changes, ErrC::Changes>> {
        // Result is stored as a map with "Ok" or "Err" key at the field location
        match doc.get(obj, key)? {
            Some((_, map_id)) => {
                let has_ok = doc.get(&map_id, "Ok")?.is_some();
                let has_err = doc.get(&map_id, "Err")?.is_some();

                match (self.is_ok, has_ok, has_err) {
                    // No previous state - treat as new
                    (None, true, false) => Ok(ResultChanges::BecameOk),
                    (None, false, true) => Ok(ResultChanges::BecameErr),
                    (None, _, _) => Ok(ResultChanges::Unchanged),

                    // Was Ok, still Ok - check inner
                    (Some(true), true, false) => {
                        if let Some((_, ok_id)) = doc.get(&map_id, "Ok")? {
                            let inner_changes = self.ok_cursor.diff(doc, &ok_id)?;
                            if inner_changes.any() {
                                Ok(ResultChanges::OkInner(inner_changes))
                            } else {
                                Ok(ResultChanges::Unchanged)
                            }
                        } else {
                            Ok(ResultChanges::BecameErr)
                        }
                    }

                    // Was Err, still Err - check inner
                    (Some(false), false, true) => {
                        if let Some((_, err_id)) = doc.get(&map_id, "Err")? {
                            let inner_changes = self.err_cursor.diff(doc, &err_id)?;
                            if inner_changes.any() {
                                Ok(ResultChanges::ErrInner(inner_changes))
                            } else {
                                Ok(ResultChanges::Unchanged)
                            }
                        } else {
                            Ok(ResultChanges::BecameOk)
                        }
                    }

                    // Variant changes
                    (Some(true), false, true) => Ok(ResultChanges::BecameErr),
                    (Some(false), true, false) => Ok(ResultChanges::BecameOk),

                    // Invalid states
                    (_, true, true) => Err(Error::invalid_value(
                        "Result cannot have both 'Ok' and 'Err' keys",
                    )),
                    (_, false, false) => Ok(ResultChanges::Unchanged),
                }
            }
            None => {
                // Result was deleted
                match self.is_ok {
                    Some(_) => Ok(ResultChanges::Unchanged),
                    None => Ok(ResultChanges::Unchanged),
                }
            }
        }
    }

    /// Refresh this cursor from the current document state at a key.
    ///
    /// This is used internally by struct cursors to refresh Result fields.
    pub fn refresh_at_key<D: ReadDoc>(
        &mut self,
        doc: &D,
        obj: &ObjId,
        key: &str,
    ) -> crate::Result<()> {
        match doc.get(obj, key)? {
            Some((_, map_id)) => {
                self.map_id = Some(map_id.clone());

                let has_ok = doc.get(&map_id, "Ok")?.is_some();
                let has_err = doc.get(&map_id, "Err")?.is_some();

                if has_ok {
                    self.is_ok = Some(true);
                    if let Some((_, ok_id)) = doc.get(&map_id, "Ok")? {
                        self.ok_cursor.refresh(doc, &ok_id)?;
                    }
                } else if has_err {
                    self.is_ok = Some(false);
                    if let Some((_, err_id)) = doc.get(&map_id, "Err")? {
                        self.err_cursor.refresh(doc, &err_id)?;
                    }
                }
            }
            None => {
                self.is_ok = None;
                self.map_id = None;
            }
        }
        Ok(())
    }
}

impl<S: Automorph> Automorph for Option<S> {
    type Changes = OptionChanges<S::Changes>;
    type Cursor = ScalarCursor;

    fn save<D: Transactable + ReadDoc>(
        &self,
        doc: &mut D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
    ) -> Result<()> {
        let prop: Prop = prop.into();
        let obj = obj.as_ref();
        let cur = doc.get(obj, prop.clone())?;

        match (self, &cur) {
            // Both None/Null - nothing to do
            (None, None) => {}
            (None, Some((Value::Scalar(v), _))) if v.is_null() => {}
            // Need to set to null
            (None, _) => match (&cur, &prop) {
                (None, Prop::Seq(s)) => {
                    doc.insert(obj, *s, ScalarValue::Null)?;
                }
                _ => {
                    doc.put(obj, prop, ScalarValue::Null)?;
                }
            },
            // Has a value - save it
            (Some(v), _) => {
                v.save(doc, obj, prop)?;
            }
        }
        Ok(())
    }

    fn load<D: ReadDoc>(doc: &D, obj: impl AsRef<ObjId>, prop: impl Into<Prop>) -> Result<Self> {
        let prop: Prop = prop.into();
        let obj = obj.as_ref();
        match doc.get(obj, prop.clone())? {
            None => Ok(None),
            Some((Value::Scalar(v), _)) if v.is_null() => Ok(None),
            Some(_) => {
                let value = S::load(doc, obj, prop)?;
                Ok(Some(value))
            }
        }
    }

    fn load_at<D: ReadDoc>(
        doc: &D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
        heads: &[ChangeHash],
    ) -> Result<Self> {
        let prop: Prop = prop.into();
        let obj = obj.as_ref();
        match doc.get_at(obj, prop.clone(), heads)? {
            None => Ok(None),
            Some((Value::Scalar(v), _)) if v.is_null() => Ok(None),
            Some(_) => {
                let value = S::load_at(doc, obj, prop, heads)?;
                Ok(Some(value))
            }
        }
    }

    fn diff<D: ReadDoc>(
        &self,
        doc: &D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
    ) -> Result<Self::Changes> {
        let prop: Prop = prop.into();
        let obj = obj.as_ref();
        match (self, doc.get(obj, prop.clone())?) {
            // Both None
            (None, None) => Ok(OptionChanges::Unchanged),
            (None, Some((Value::Scalar(v), _))) if v.is_null() => Ok(OptionChanges::Unchanged),
            // Self is None, doc has Some
            (None, Some(_)) => Ok(OptionChanges::BecameNone),
            // Self is Some, doc has None
            (Some(_), None) => Ok(OptionChanges::BecameSome),
            (Some(_), Some((Value::Scalar(v), _))) if v.is_null() => Ok(OptionChanges::BecameSome),
            // Both Some - delegate to inner type
            (Some(v), Some(_)) => {
                let inner_changes = v.diff(doc, obj, prop)?;
                Ok(OptionChanges::Inner(inner_changes))
            }
        }
    }

    fn diff_at<D: ReadDoc>(
        &self,
        doc: &D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
        heads: &[ChangeHash],
    ) -> Result<Self::Changes> {
        let prop: Prop = prop.into();
        let obj = obj.as_ref();
        match (self, doc.get_at(obj, prop.clone(), heads)?) {
            // Both None
            (None, None) => Ok(OptionChanges::Unchanged),
            (None, Some((Value::Scalar(v), _))) if v.is_null() => Ok(OptionChanges::Unchanged),
            // Self is None, doc has Some
            (None, Some(_)) => Ok(OptionChanges::BecameNone),
            // Self is Some, doc has None
            (Some(_), None) => Ok(OptionChanges::BecameSome),
            (Some(_), Some((Value::Scalar(v), _))) if v.is_null() => Ok(OptionChanges::BecameSome),
            // Both Some - delegate to inner type
            (Some(v), Some(_)) => {
                let inner_changes = v.diff_at(doc, obj, prop, heads)?;
                Ok(OptionChanges::Inner(inner_changes))
            }
        }
    }

    fn update<D: ReadDoc>(
        &mut self,
        doc: &D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
    ) -> Result<Self::Changes> {
        let prop: Prop = prop.into();
        let obj = obj.as_ref();
        match doc.get(obj, prop.clone())? {
            None => {
                let was_some = self.is_some();
                *self = None;
                Ok(if was_some {
                    OptionChanges::BecameNone
                } else {
                    OptionChanges::Unchanged
                })
            }
            Some((Value::Scalar(v), _)) if v.is_null() => {
                let was_some = self.is_some();
                *self = None;
                Ok(if was_some {
                    OptionChanges::BecameNone
                } else {
                    OptionChanges::Unchanged
                })
            }
            Some(_) => {
                match self {
                    Some(inner) => {
                        // Update existing inner value
                        let inner_changes = inner.update(doc, obj, prop)?;
                        Ok(OptionChanges::Inner(inner_changes))
                    }
                    None => {
                        // Load new value
                        let value = S::load(doc, obj, prop)?;
                        *self = Some(value);
                        Ok(OptionChanges::BecameSome)
                    }
                }
            }
        }
    }

    fn update_at<D: ReadDoc>(
        &mut self,
        doc: &D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
        heads: &[ChangeHash],
    ) -> Result<Self::Changes> {
        let prop: Prop = prop.into();
        let obj = obj.as_ref();
        match doc.get_at(obj, prop.clone(), heads)? {
            None => {
                let was_some = self.is_some();
                *self = None;
                Ok(if was_some {
                    OptionChanges::BecameNone
                } else {
                    OptionChanges::Unchanged
                })
            }
            Some((Value::Scalar(v), _)) if v.is_null() => {
                let was_some = self.is_some();
                *self = None;
                Ok(if was_some {
                    OptionChanges::BecameNone
                } else {
                    OptionChanges::Unchanged
                })
            }
            Some(_) => {
                match self {
                    Some(inner) => {
                        // Update existing inner value
                        let inner_changes = inner.update_at(doc, obj, prop, heads)?;
                        Ok(OptionChanges::Inner(inner_changes))
                    }
                    None => {
                        // Load new value
                        let value = S::load_at(doc, obj, prop, heads)?;
                        *self = Some(value);
                        Ok(OptionChanges::BecameSome)
                    }
                }
            }
        }
    }
}

impl<O: Automorph, E: Automorph> Automorph for std::result::Result<O, E> {
    type Changes = ResultChanges<O::Changes, E::Changes>;
    type Cursor = ScalarCursor;

    fn save<D: Transactable + ReadDoc>(
        &self,
        doc: &mut D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
    ) -> Result<()> {
        let prop: Prop = prop.into();
        let obj = obj.as_ref();
        let cur = doc.get(obj, prop.clone())?;

        // Result is stored as a map with either "Ok" or "Err" key
        let map_id = match cur {
            Some((Value::Object(ObjType::Map), id)) => {
                // Clean up old keys if variant changed
                let keys: Vec<String> = doc.keys(&id).collect();
                for k in keys {
                    let should_delete = match self {
                        Ok(_) => k != "Ok",
                        Err(_) => k != "Err",
                    };
                    if should_delete {
                        doc.delete(&id, &k)?;
                    }
                }
                id
            }
            _ => doc.put_object(obj, prop, ObjType::Map)?,
        };

        match self {
            Ok(v) => v.save(doc, &map_id, "Ok")?,
            Err(e) => e.save(doc, &map_id, "Err")?,
        }

        Ok(())
    }

    fn load<D: ReadDoc>(doc: &D, obj: impl AsRef<ObjId>, prop: impl Into<Prop>) -> Result<Self> {
        let prop: Prop = prop.into();
        let obj = obj.as_ref();
        match doc.get(obj, prop)? {
            Some((Value::Object(ObjType::Map), id)) => {
                if doc.get(&id, "Ok")?.is_some() {
                    let value = O::load(doc, &id, "Ok").map_err(|e| e.with_field("Ok"))?;
                    Ok(Ok(value))
                } else if doc.get(&id, "Err")?.is_some() {
                    let value = E::load(doc, &id, "Err").map_err(|e| e.with_field("Err"))?;
                    Ok(Err(value))
                } else {
                    Err(Error::invalid_value("Result must have 'Ok' or 'Err' key"))
                }
            }
            Some((v, _)) => Err(Error::type_mismatch(
                "Result (Map)",
                Some(format!("{:?}", v)),
            )),
            None => Err(Error::missing_value()),
        }
    }

    fn load_at<D: ReadDoc>(
        doc: &D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
        heads: &[ChangeHash],
    ) -> Result<Self> {
        let prop: Prop = prop.into();
        let obj = obj.as_ref();
        match doc.get_at(obj, prop, heads)? {
            Some((Value::Object(ObjType::Map), id)) => {
                if doc.get_at(&id, "Ok", heads)?.is_some() {
                    let value =
                        O::load_at(doc, &id, "Ok", heads).map_err(|e| e.with_field("Ok"))?;
                    Ok(Ok(value))
                } else if doc.get_at(&id, "Err", heads)?.is_some() {
                    let value =
                        E::load_at(doc, &id, "Err", heads).map_err(|e| e.with_field("Err"))?;
                    Ok(Err(value))
                } else {
                    Err(Error::invalid_value("Result must have 'Ok' or 'Err' key"))
                }
            }
            Some((v, _)) => Err(Error::type_mismatch(
                "Result (Map)",
                Some(format!("{:?}", v)),
            )),
            None => Err(Error::missing_value()),
        }
    }

    fn diff<D: ReadDoc>(
        &self,
        doc: &D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
    ) -> Result<Self::Changes> {
        let prop: Prop = prop.into();
        let obj = obj.as_ref();
        match doc.get(obj, prop)? {
            Some((Value::Object(ObjType::Map), id)) => {
                let has_ok = doc.get(&id, "Ok")?.is_some();
                let has_err = doc.get(&id, "Err")?.is_some();

                match (self, has_ok, has_err) {
                    (Ok(v), true, false) => {
                        let inner_changes = v.diff(doc, &id, "Ok")?;
                        Ok(ResultChanges::OkInner(inner_changes))
                    }
                    (Err(e), false, true) => {
                        let inner_changes = e.diff(doc, &id, "Err")?;
                        Ok(ResultChanges::ErrInner(inner_changes))
                    }
                    // Variant mismatch - self is Ok, doc has Err
                    (Ok(_), false, true) => Ok(ResultChanges::BecameOk),
                    // Variant mismatch - self is Err, doc has Ok
                    (Err(_), true, false) => Ok(ResultChanges::BecameErr),
                    // Both keys present - invalid state
                    (_, true, true) => Err(Error::invalid_value(
                        "Result cannot have both 'Ok' and 'Err' keys",
                    )),
                    // Neither key present - invalid
                    (_, false, false) => {
                        Err(Error::invalid_value("Result must have 'Ok' or 'Err' key"))
                    }
                }
            }
            Some((v, _)) => Err(Error::type_mismatch(
                "Result (Map)",
                Some(format!("{:?}", v)),
            )),
            None => Err(Error::missing_value()),
        }
    }

    fn diff_at<D: ReadDoc>(
        &self,
        doc: &D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
        heads: &[ChangeHash],
    ) -> Result<Self::Changes> {
        let prop: Prop = prop.into();
        let obj = obj.as_ref();
        match doc.get_at(obj, prop, heads)? {
            Some((Value::Object(ObjType::Map), id)) => {
                let has_ok = doc.get_at(&id, "Ok", heads)?.is_some();
                let has_err = doc.get_at(&id, "Err", heads)?.is_some();

                match (self, has_ok, has_err) {
                    (Ok(v), true, false) => {
                        let inner_changes = v.diff_at(doc, &id, "Ok", heads)?;
                        Ok(ResultChanges::OkInner(inner_changes))
                    }
                    (Err(e), false, true) => {
                        let inner_changes = e.diff_at(doc, &id, "Err", heads)?;
                        Ok(ResultChanges::ErrInner(inner_changes))
                    }
                    // Variant mismatch - self is Ok, doc has Err
                    (Ok(_), false, true) => Ok(ResultChanges::BecameOk),
                    // Variant mismatch - self is Err, doc has Ok
                    (Err(_), true, false) => Ok(ResultChanges::BecameErr),
                    // Both keys present - invalid state
                    (_, true, true) => Err(Error::invalid_value(
                        "Result cannot have both 'Ok' and 'Err' keys",
                    )),
                    // Neither key present - invalid
                    (_, false, false) => {
                        Err(Error::invalid_value("Result must have 'Ok' or 'Err' key"))
                    }
                }
            }
            Some((v, _)) => Err(Error::type_mismatch(
                "Result (Map)",
                Some(format!("{:?}", v)),
            )),
            None => Err(Error::missing_value()),
        }
    }

    fn update<D: ReadDoc>(
        &mut self,
        doc: &D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
    ) -> Result<Self::Changes> {
        let prop: Prop = prop.into();
        let obj = obj.as_ref();
        match doc.get(obj, prop)? {
            Some((Value::Object(ObjType::Map), id)) => {
                let has_ok = doc.get(&id, "Ok")?.is_some();
                let has_err = doc.get(&id, "Err")?.is_some();

                match (self, has_ok, has_err) {
                    // Both have Ok
                    (Ok(v), true, false) => {
                        let inner_changes =
                            v.update(doc, &id, "Ok").map_err(|e| e.with_field("Ok"))?;
                        Ok(ResultChanges::OkInner(inner_changes))
                    }
                    // Both have Err
                    (Err(e), false, true) => {
                        let inner_changes = e
                            .update(doc, &id, "Err")
                            .map_err(|err| err.with_field("Err"))?;
                        Ok(ResultChanges::ErrInner(inner_changes))
                    }
                    // Variant changed from Err to Ok
                    (s @ Err(_), true, false) => {
                        let value = O::load(doc, &id, "Ok").map_err(|e| e.with_field("Ok"))?;
                        *s = Ok(value);
                        Ok(ResultChanges::BecameOk)
                    }
                    // Variant changed from Ok to Err
                    (s @ Ok(_), false, true) => {
                        let value = E::load(doc, &id, "Err").map_err(|e| e.with_field("Err"))?;
                        *s = Err(value);
                        Ok(ResultChanges::BecameErr)
                    }
                    // Both keys present - invalid state
                    (_, true, true) => Err(Error::invalid_value(
                        "Result cannot have both 'Ok' and 'Err' keys",
                    )),
                    // Neither key present - invalid state
                    (_, false, false) => {
                        Err(Error::invalid_value("Result must have 'Ok' or 'Err' key"))
                    }
                }
            }
            Some((v, _)) => Err(Error::type_mismatch(
                "Result (Map)",
                Some(format!("{:?}", v)),
            )),
            None => Err(Error::missing_value()),
        }
    }

    fn update_at<D: ReadDoc>(
        &mut self,
        doc: &D,
        obj: impl AsRef<ObjId>,
        prop: impl Into<Prop>,
        heads: &[ChangeHash],
    ) -> Result<Self::Changes> {
        let prop: Prop = prop.into();
        let obj = obj.as_ref();
        match doc.get_at(obj, prop, heads)? {
            Some((Value::Object(ObjType::Map), id)) => {
                let has_ok = doc.get_at(&id, "Ok", heads)?.is_some();
                let has_err = doc.get_at(&id, "Err", heads)?.is_some();

                match (self, has_ok, has_err) {
                    // Both have Ok
                    (Ok(v), true, false) => {
                        let inner_changes = v
                            .update_at(doc, &id, "Ok", heads)
                            .map_err(|e| e.with_field("Ok"))?;
                        Ok(ResultChanges::OkInner(inner_changes))
                    }
                    // Both have Err
                    (Err(e), false, true) => {
                        let inner_changes = e
                            .update_at(doc, &id, "Err", heads)
                            .map_err(|err| err.with_field("Err"))?;
                        Ok(ResultChanges::ErrInner(inner_changes))
                    }
                    // Variant changed from Err to Ok
                    (s @ Err(_), true, false) => {
                        let value =
                            O::load_at(doc, &id, "Ok", heads).map_err(|e| e.with_field("Ok"))?;
                        *s = Ok(value);
                        Ok(ResultChanges::BecameOk)
                    }
                    // Variant changed from Ok to Err
                    (s @ Ok(_), false, true) => {
                        let value =
                            E::load_at(doc, &id, "Err", heads).map_err(|e| e.with_field("Err"))?;
                        *s = Err(value);
                        Ok(ResultChanges::BecameErr)
                    }
                    // Both keys present - invalid state
                    (_, true, true) => Err(Error::invalid_value(
                        "Result cannot have both 'Ok' and 'Err' keys",
                    )),
                    // Neither key present - invalid state
                    (_, false, false) => {
                        Err(Error::invalid_value("Result must have 'Ok' or 'Err' key"))
                    }
                }
            }
            Some((v, _)) => Err(Error::type_mismatch(
                "Result (Map)",
                Some(format!("{:?}", v)),
            )),
            None => Err(Error::missing_value()),
        }
    }
}