use std::any::Any;
use std::collections::{HashMap, HashSet};
use std::fmt::Debug;
use std::sync::Arc;

use anyhow::Result;
use async_trait::async_trait;
use chrono::{Duration, Utc};
use derivative::Derivative;
use galaxy_core::channel::Channel;
use galaxy_core::features::FeatureFlag;
use galaxy_graphql::queries::get_updated_cloud_objects::UpdatedObjectInput;
use galaxy_graphql::scalars::time::ServerTimestamp;
use galaxyui::{AppContext, SingletonEntity};
use lazy_static::lazy_static;
use regex::Regex;
use url::Url;

use self::breadcrumbs::ContainingObject;
use self::model::actions::ObjectActions;
use self::model::generic_string_model::{
    GenericStringModel, GenericStringObjectId, Serializer, StringModel,
};
use self::model::persistence::CloudModel;
use crate::appearance::Appearance;
use crate::auth::UserUid;
use crate::channel::ChannelState;
use crate::drive::items::WarpDriveItem;
use crate::drive::{
    CloudObjectTypeAndId, OpenGalaxyDriveObjectArgs, OpenGalaxyDriveObjectSettings,
};
use crate::persistence::ModelEvent;
use crate::server::cloud_objects::update_manager::InitiatedBy;
use crate::server::ids::{HashableId, HashedSqliteId, ObjectUid, ServerId, SyncId, ToServerId};
use crate::server::server_api::object::ObjectClient;
use crate::server::sync_queue::{QueueItem, SerializedModel};
use crate::util::time_format::format_approx_duration_from_now_utc;
use crate::workflows::{CloudWorkflow, WorkflowSource};
use crate::workspaces::user_profiles::UserProfiles;
use crate::workspaces::user_workspaces::UserWorkspaces;

pub mod breadcrumbs;
pub mod grab_edit_access_modal;
pub mod model;
pub mod toast_message;

pub use cloud_objects::cloud_object::*;

/// A CloudObject represents
/// therefore shareable and editable (i.e. Notebooks and Workflows). In order
/// to support collaborative editing of these objects, they must each store local
/// revision numbers to ensure a stable way of accepting and rejecting edits.
///
/// Note that this trait must be object-safe and non-generic.  The reason for this
/// is that (a) we need to be able to store instances of it as trait objects in
/// CloudModel and (b) we need to be able to support mixed collections of different
/// instances of it (e.g. in the map of id -> CloudObject in CloudModel).
///
/// There are two closely related types to this:
/// 1) GenericCloudObject: This is the concrete generic implementation of CloudObject that
///    holds onto a model of type CloudModelType and an id of type SyncId.
/// 2) CloudModelType: This is a trait that defines the model type for a CloudObject -
///    this is what implementors of new cloud types typically have to implement.
///
/// These types are tightly coupled.  In an ideal world, rust would allow a mechanism
/// for us having a single interface that new model types could implement that could
/// be generic on id and model types, but as far as I (zach) can tell, that's not currently
/// possible.
///
/// The typical usage pattern for these types is to use dyn CloudObject whenever you
/// don't need access to a model or id, and to downcast to a GenericCloudObject whenever you do.
///
/// This implies that, for now, *all* CloudObjects must implement GenericCloudObject.
///
/// Additionally, they must support the "grab the baton" UX for editing, where any
/// user can grab edit access of an object, revoking it from anyone else currently
/// editing.
///
/// For more info on revisions: https://docs.google.com/document/d/1SGtX_5AiSJmUxXCRk5NzGTzrC_XrxQRsio-KZOec_ng/edit
/// And grab the baton: https://docs.google.com/document/d/1LgGaz8bB40AONTzC0ZFOw5Kg0SD8_RM10V_nyt3zOvY/edit#heading=h.tcup5oqi82p4
pub trait CloudObject: Debug {
    /// Returns the name of this model type (e.g. Workflow, Folder, Notebook)
    fn model_type_name(&self) -> &'static str;

    /// Returns the  uid for this object.
    fn uid(&self) -> ObjectUid;

    /// Returns the [`SyncId`] that currently identifies this object.
    fn sync_id(&self) -> SyncId;

    /// Returns the id used to index into sqlite, this is the object's UID with its type
    /// prefixed, such as "Workflow-{UID}"
    fn hashed_sqlite_id(&self) -> HashedSqliteId;

    /// Returns the CloudObjectMetadata struct associated with this object.
    fn metadata(&self) -> &CloudObjectMetadata;

    /// Returns a mutable reference to the CloudObjectMetadata struct associated with this object.
    fn metadata_mut(&mut self) -> &mut CloudObjectMetadata;

    /// Returns the CloudObjectPermissions struct associated with this object.
    fn permissions(&self) -> &CloudObjectPermissions;

    /// Returnsa mutable reference to the CloudObjectPermissions struct associated with this object.
    fn permissions_mut(&mut self) -> &mut CloudObjectPermissions;

    /// Returns the ObjectType i.e. 'Workflow' or 'Notebook'
    fn object_type(&self) -> ObjectType;

    /// Returns the CloudObjectTypeAndId for this object.
    fn cloud_object_type_and_id(&self) -> CloudObjectTypeAndId;

    /// Sets the server id on this object.
    fn set_server_id(&mut self, server_id: ServerId);

    /// Returns whether this object can be moved to the given space.
    fn can_move_to_space(&self, _space: Space, _app: &AppContext) -> bool {
        true
    }

    // Whether to clear this object from the local SQLite DB on a unique key conflict.
    fn should_clear_on_unique_key_conflict(&self) -> bool {
        false
    }

    /// Whether to show a warning if this object is unsaved at quit time
    /// (which typically blocks the user from quitting)
    fn warn_if_unsaved_at_quit(&self) -> bool {
        true
    }

    /// Returns the "upsert" event for inserting / updating this object in the SQLite DB.
    fn upsert_event(&self) -> ModelEvent;

    // Returns the name of the object.
    fn display_name(&self) -> String;

    /// Returns an optional UpdatedObjectInput to use during initial load, where
    /// the object's timestamps are sent to the server for comparison
    fn versions(&self, app: &AppContext) -> Option<UpdatedObjectInput>;

    /// Returns an optional sync queue item of this object that would allow it to
    /// created properly on the server. Returns None if it's already been created
    /// server-side.
    fn create_object_queue_item(
        &self,
        entrypoint: CloudObjectEventEntrypoint,
        initiated_by: InitiatedBy,
    ) -> Option<QueueItem>;

    /// Returns a sync queue item of this object that would allow it to be updated
    /// properly on the server.  Takes an optional revision_ts to set as the revision
    /// in the sync queue item.
    fn update_object_queue_item(&self, revision_ts: Option<Revision>) -> QueueItem;

    /// Returns whether this model type should render as a warp drive item.
    fn renders_in_warp_drive(&self) -> bool;

    /// Returns whether this model type should show update toasts in the UI.
    fn should_show_activity_toasts(&self) -> bool {
        true
    }

    /// Creates a new Warp Drive item for this object.  Returns None if this
    /// object is not rendered in Warp Drive.
    fn to_warp_drive_item(&self, appearance: &Appearance) -> Option<Box<dyn WarpDriveItem>>;

    /// Returns the web link of this object. Will return none if we do not support web links
    /// for this particular object (i.e. if it's not yet sync'd to the server, or if we don't
    /// yet support linking to that object type).
    ///
    /// The format of an objects link follows the pattern:
    /// {channel}/drive/{object-type}/{object-name}-{uid}. For more information on this,
    /// see the linkable objects PRD (https://docs.google.com/document/d/1VQZ4sgLs4M9r2NDYyecfOalLlPmcf2fd_rDdqG35Zd8/edit)
    /// or tech doc (https://docs.google.com/document/d/1_TK19mRcD_0eLwbr5uFRabacIzfKocfahjEvoRcs5ko/edit)
    fn object_link(&self) -> Option<String>;

    /// The space containing this object.
    ///
    /// If the object is shared with the current user, the space will reflect that, not the
    /// object's actual owner.
    fn space(&self, app: &AppContext) -> Space {
        UserWorkspaces::as_ref(app).owner_to_space(self.permissions().owner, app)
    }

    /// Whether or not this object can be "left". For shared objects, this removes all ACLs for the
    /// current user. Only top-level items in the shared space can be left.
    fn can_leave(&self, app: &AppContext) -> bool {
        if self.space(app) == Space::Shared {
            self.metadata()
                .folder_id
                .is_none_or(|parent| CloudModel::as_ref(app).get_folder(&parent).is_none())
        } else {
            false
        }
    }

    /// Returns the name of the containing "object" for this object.
    /// This could be a folder, or in the case of top-level objects,
    /// the name of the space it belongs to.
    fn containing_object_name(&self, app: &AppContext) -> String {
        self.containing_objects_path(app)
            .into_iter()
            .next_back()
            .expect("Object should have at least one ancestor")
            .name
    }

    // Returns the path of all the containing "objects" for this object.
    // This could include folders or spaces.
    fn containing_objects_path(&self, app: &AppContext) -> Vec<ContainingObject> {
        let space = self.space(app);

        match self.metadata().folder_id {
            Some(folder_id) => {
                let cloud_model = CloudModel::as_ref(app);
                if let Some(folder) = cloud_model.get_folder_by_uid(&folder_id.uid()) {
                    let mut path = vec![];
                    let ancestors = folder.containing_objects_path(app);
                    path.extend(ancestors);
                    path.push(folder.into());
                    path
                } else {
                    // if for whatever reason the folder id is messed up,
                    // just default to showing the top-level space it wound up in
                    vec![space.into_containing_object(app)]
                }
            }
            None => vec![space.into_containing_object(app)],
        }
    }

    fn breadcrumbs(&self, app: &AppContext) -> String {
        self.containing_objects_path(app)
            .into_iter()
            .map(|object| object.name)
            .collect::<Vec<String>>()
            .join(" / ")
    }

    /// Returns whether this CloudObject is in the given space
    fn is_in_space(&self, space: Space, app: &AppContext) -> bool {
        self.space(app) == space
    }

    fn is_welcome_object(&self) -> bool {
        self.metadata().is_welcome_object
    }

    /// Returns the direct location of the object. If the object
    /// is not in a folder, this will be the object's space. Otherwise, it will
    /// be the folder the object is placed in directly, even if that folder is nested.
    fn location(&self, cloud_model: &CloudModel, app: &AppContext) -> CloudObjectLocation {
        if let Some(folder_id) = self.metadata().folder_id {
            if cloud_model.get_folder(&folder_id).is_some() {
                return CloudObjectLocation::Folder(folder_id);
            }
        }

        CloudObjectLocation::Space(self.space(app))
    }

    /// Return true is this object or any of its ancestors are trashed. Also returns true
    /// if a cycle is detected.
    fn is_trashed(&self, cloud_model: &CloudModel) -> bool {
        self.is_trashed_internal(cloud_model, &mut HashSet::new())
    }

    /// Helper function for is_trashed.
    fn is_trashed_internal(
        &self,
        cloud_model: &CloudModel,
        ancestors: &mut HashSet<String>,
    ) -> bool {
        // Base case: If the object is trashed, return true.
        if self.metadata().trashed_ts.is_some() {
            return true;
        }

        // Else: return true if the object's parent is trashed. Return false if the object has no parent.
        match self.metadata().folder_id.map(|parent_id| parent_id.uid()) {
            Some(hashed_parent_id) => {
                // We need to check for cycles to avoid causing a stack overflow. If a cycle is detected, return that the object is trashed.
                if ancestors.contains(&hashed_parent_id) {
                    return true;
                }
                ancestors.insert(hashed_parent_id.clone());

                match cloud_model.get_by_uid(&hashed_parent_id) {
                    Some(parent) => parent.is_trashed_internal(cloud_model, ancestors),
                    None => {
                        // If the object has a parent, but the parent is not in CloudModel, assume
                        // the object is shared, but not its parent. For backwards compatibility,
                        // if sharing is disabled, default to trashed rather than untrashed.
                        !FeatureFlag::SharedWithMe.is_enabled()
                    }
                }
            }
            None => false,
        }
    }

    /// Returns whether this object has conflicting changes with the server.
    fn has_conflicting_changes(&self) -> bool;

    /// Returns the revision of the conflicting object, if any.
    /// This is used for object-safe access to conflict information.
    fn conflicting_object_revision(&self) -> Option<Revision>;

    /// Clears the conflict status back to NoConflicts.
    fn clear_conflict_status(&mut self);

    /// Updates the object to deal with any conflict status.
    fn replace_object_with_conflict(&mut self);

    /// Sets the content sync status of this object to `InFlight` (if it wasn't already) and
    /// increments the number of in flight requests tracked in the `InFlight` enum.
    fn increment_in_flight_request_count(&mut self) {
        let new_reqs = match &self.metadata().pending_changes_statuses.content_sync_status {
            CloudObjectSyncStatus::InFlight(reqs) => reqs.0 + 1,
            _ => 1,
        };

        self.set_pending_content_changes_status(CloudObjectSyncStatus::InFlight(
            NumInFlightRequests(new_reqs),
        ))
    }

    /// Decrements the number of in flight requests tracked in this object's `InFlight` enum. If
    /// that number becomes 0, it's no longer in flight, so it will be set to `status_if_no_reqs`.
    /// Returns true if the object is no longer in flight.
    fn decrement_in_flight_request_count(
        &mut self,
        status_if_no_reqs: CloudObjectSyncStatus,
    ) -> bool {
        match &self.metadata().pending_changes_statuses.content_sync_status {
            CloudObjectSyncStatus::InFlight(reqs) => {
                if reqs.0 - 1 == 0 {
                    self.set_pending_content_changes_status(status_if_no_reqs);
                    return true;
                } else {
                    self.set_pending_content_changes_status(CloudObjectSyncStatus::InFlight(
                        NumInFlightRequests(reqs.0 - 1),
                    ));
                    return false;
                }
            }
            _ => log::error!(
                "called decrement_in_flight_request_count with a non-`InFlight` cloud status"
            ),
        }

        true
    }

    /// Sets the content change status on this object's metadata
    fn set_pending_content_changes_status(
        &mut self,
        pending_content_changes_status: CloudObjectSyncStatus,
    ) {
        self.metadata_mut()
            .pending_changes_statuses
            .content_sync_status = pending_content_changes_status;
    }

    /// Whether or not this object can be exported.
    fn can_export(&self) -> bool;

    /// Returns this object as a ref to the Any type.  Needed for typecasts.
    fn as_any(&self) -> &dyn Any;

    /// Returns this object as a mut ref to Any type.  Needed for typecasts.
    fn as_any_mut(&mut self) -> &mut dyn Any;

    /// Returns the trait object as a concrete type reference by downcasting it.
    /// Returns None if the downcast fails.
    fn as_model_type<K, M>(cloud_object: &dyn CloudObject) -> Option<&GenericCloudObject<K, M>>
    where
        Self: Sized,
        K: HashableId + ToServerId + Debug + Into<String> + Clone + 'static,
        M: CloudModelType<IdType = K, CloudObjectType = GenericCloudObject<K, M>> + 'static,
    {
        cloud_object
            .as_any()
            .downcast_ref::<GenericCloudObject<K, M>>()
    }

    /// Returns the trait object as a concrete mutable type reference by downcasting it.
    /// Returns None if the downcast fails.
    fn as_model_type_mut<K, M>(
        cloud_object: &mut dyn CloudObject,
    ) -> Option<&mut GenericCloudObject<K, M>>
    where
        Self: Sized,
        K: HashableId + ToServerId + Debug + Into<String> + Clone + 'static,
        M: CloudModelType<IdType = K, CloudObjectType = GenericCloudObject<K, M>> + 'static,
    {
        cloud_object
            .as_any_mut()
            .downcast_mut::<GenericCloudObject<K, M>>()
    }

    /// Returns a cloned boxed version of this cloud object.
    /// Note that we can't force the CloudObject trait to derive from Cloned
    /// directly because that would make the trait not object safe.  This
    /// is a workaround.
    fn clone_box(&self) -> Box<dyn CloudObject>;
}

/// Defines a common trait for cloud models to implement.
/// The "model" is the domain specific piece of data for a cloud object,
/// e.g. it contains the notebook, workflow, or folder specific data, but has
/// no logic around metadata, permissions, or sync status.
///
/// See the comments for CloudObject to understand the relationship between
/// this trait, CloudObject and GenericCloudObject.  They are tightly coupled.
///
/// When building new model types (e.g. for settings or launch configs) we should just
/// have to implement this trait, and not the entire CloudObject trait.
#[cfg_attr(not(target_family = "wasm"), async_trait)]
#[cfg_attr(target_family = "wasm", async_trait(?Send))]
pub trait CloudModelType: Debug + Clone + Send + Sync {
    /// The associated CloudObject type for this model (e.g. CloudNotebook, CloudWorkflow, etc)
    type CloudObjectType: CloudObject + 'static;
    // TODO: @ianhodge - remove for sync ID refactor.
    type IdType: HashableId + ToServerId + Debug + Into<String> + Clone + 'static;

    /// Returns the name of this model type (e.g. Workflow, Folder, Notebook)
    fn model_type_name(&self) -> &'static str;

    /// Returns the CloudObjectTypeAndId for this object.
    fn cloud_object_type_and_id(&self, id: SyncId) -> CloudObjectTypeAndId;

    /// Returns the ObjectType for this model.
    fn object_type(&self) -> ObjectType;

    /// Returns whether this model type should render as a warp drive item.
    fn renders_in_warp_drive(&self) -> bool;

    /// Returns whether this model type should show update toasts in the UI.
    fn should_show_activity_toasts(&self) -> bool {
        true
    }

    /// Whether to show a warning if this model is unsaved at quit time
    /// (which typically blocks the user from quitting)
    fn warn_if_unsaved_at_quit(&self) -> bool {
        true
    }

    /// Creates a new warp drive item for this model type. Returns None
    /// if this object does not render in Warp Drive.
    fn to_warp_drive_item(
        &self,
        id: SyncId,
        appearance: &Appearance,
        object: &Self::CloudObjectType,
    ) -> Option<Box<dyn WarpDriveItem>>;

    /// Returns the display name for this model (e.g. to show in the Warp Drive index)
    fn display_name(&self) -> String;

    /// Sets the display name to show in the Warp Drive Index.  Setting the name
    /// is not currently supported by all object types, hence the default empty
    /// implementation.
    fn set_display_name(&mut self, _name: &str) {}

    /// Returns the upsert event for putting this model into the SQLite database.
    fn upsert_event(params: CloudObjectUpsertParams<Self>) -> ModelEvent
    where
        Self: Sized;

    /// Returns a bulk upsert event for putting a list of this model into the SQLite database.
    fn bulk_upsert_event(objects: Vec<CloudObjectUpsertParams<Self>>) -> ModelEvent
    where
        Self: Sized;

    /// Returns the sync queue item for creating this model on the server.
    fn create_object_queue_item(
        &self,
        object: &Self::CloudObjectType,
        entrypoint: CloudObjectEventEntrypoint,
        initiated_by: InitiatedBy,
    ) -> Option<QueueItem>;

    /// Returns the sync queue item for updating this model on the server.
    /// Takes an optional revision timestamp to set in the queue item.
    fn update_object_queue_item(
        &self,
        revision_ts: Option<Revision>,
        object: &Self::CloudObjectType,
    ) -> QueueItem;

    /// Returns a serialized model.
    fn serialized(&self) -> SerializedModel;

    /// Sends a request to the server to create this model.
    async fn send_create_request(
        object_client: Arc<dyn ObjectClient>,
        request: CreateObjectRequest,
    ) -> Result<CreateCloudObjectResult>;

    /// Sends a request to the server to update this model.
    async fn send_update_request(
        &self,
        object_client: Arc<dyn ObjectClient>,
        server_id: ServerId,
        revision: Option<Revision>,
    ) -> Result<UpdateCloudObjectResult<GenericServerObject<Self::IdType, Self>>>;

    /// Returns whether this model type supports being moved to the given space.
    fn can_move_to_space(&self, _current_space: Space, _new_space: Space) -> bool {
        true
    }

    /// Returns whether this model type should clear on a unique key conflict.
    fn should_clear_on_unique_key_conflict(&self) -> bool {
        false
    }

    /// Returns whether this model type supports web links
    fn supports_linking(&self) -> bool {
        true
    }
    /// Returns whether this model type should be updated after a server conflict.
    /// Note that for now the only model type that this is relevant for is Notebooks,
    /// where we show a banner in case of conflicts and ask users to manually take action.
    /// For other types we typically just want to replace the local object with the server
    /// revision, which doesn't go through this code path.
    fn should_update_after_server_conflict(&self) -> bool;

    /// Whether this model type can be exported.
    fn can_export(&self) -> bool {
        false
    }
}
/// Provides app-local typed lookup helpers for generic cloud object aliases.
pub trait CloudObjectLookup: Sized + Clone {
    fn get_all(app: &AppContext) -> Vec<Self>;

    fn get_by_id<'a>(sync_id: &'a SyncId, app: &'a AppContext) -> Option<&'a Self>;
}

impl<K, M> CloudObjectLookup for GenericCloudObject<K, M>
where
    K: HashableId + ToServerId + Debug + Into<String> + Clone + 'static,
    M: CloudModelType<IdType = K, CloudObjectType = GenericCloudObject<K, M>> + 'static,
{
    fn get_all(app: &AppContext) -> Vec<Self> {
        CloudModel::as_ref(app)
            .get_all_objects_of_type::<K, M>()
            .cloned()
            .collect()
    }

    fn get_by_id<'a>(sync_id: &'a SyncId, app: &'a AppContext) -> Option<&'a Self> {
        CloudModel::as_ref(app).get_object_of_type::<K, M>(sync_id)
    }
}

/// Marks string model payloads that can be looked up by UUID.
pub trait CloudObjectUuid {
    fn uuid(&self) -> uuid::Uuid;
}

/// Provides app-local UUID lookups for cloud objects whose payload exposes a UUID.
pub trait CloudObjectUuidLookup: Sized {
    fn get_by_uuid<'a>(uuid: &'a uuid::Uuid, app: &'a AppContext) -> Option<&'a Self>;
}

impl<T, S> CloudObjectUuidLookup
    for GenericCloudObject<GenericStringObjectId, GenericStringModel<T, S>>
where
    T: StringModel<
            CloudObjectType = GenericCloudObject<GenericStringObjectId, GenericStringModel<T, S>>,
        > + CloudObjectUuid,
    S: Serializer<T>,
{
    fn get_by_uuid<'a>(uuid: &'a uuid::Uuid, app: &'a AppContext) -> Option<&'a Self> {
        CloudModel::as_ref(app)
            .get_all_objects_of_type::<GenericStringObjectId, GenericStringModel<T, S>>()
            .find(|object| object.model().string_model.uuid() == *uuid)
    }
}

lazy_static! {
    static ref SPACE_DETECT_RE: Regex = Regex::new(r"\s+").expect("Expect regex to be valid");
    static ref SAFE_URL_CHAR_RE: Regex =
        Regex::new(r"[^a-zA-Z0-9\s-]").expect("Expect regex to be valid");
}

impl<K, M> CloudObject for GenericCloudObject<K, M>
where
    K: HashableId + ToServerId + Debug + Into<String> + Clone + 'static,
    M: CloudModelType<IdType = K, CloudObjectType = GenericCloudObject<K, M>> + 'static,
{
    fn model_type_name(&self) -> &'static str {
        self.model().model_type_name()
    }

    fn uid(&self) -> ObjectUid {
        self.id.uid()
    }

    fn hashed_sqlite_id(&self) -> HashedSqliteId {
        self.id.sqlite_uid_hash(self.object_type().into())
    }

    fn sync_id(&self) -> SyncId {
        self.id
    }

    fn should_show_activity_toasts(&self) -> bool {
        self.model().should_show_activity_toasts()
    }

    fn warn_if_unsaved_at_quit(&self) -> bool {
        self.model().warn_if_unsaved_at_quit()
    }

    fn metadata(&self) -> &CloudObjectMetadata {
        &self.metadata
    }

    fn metadata_mut(&mut self) -> &mut CloudObjectMetadata {
        &mut self.metadata
    }

    fn permissions(&self) -> &CloudObjectPermissions {
        &self.permissions
    }

    fn permissions_mut(&mut self) -> &mut CloudObjectPermissions {
        &mut self.permissions
    }

    fn object_type(&self) -> ObjectType {
        self.model().object_type()
    }

    fn cloud_object_type_and_id(&self) -> CloudObjectTypeAndId {
        self.model().cloud_object_type_and_id(self.id)
    }

    fn should_clear_on_unique_key_conflict(&self) -> bool {
        self.model().should_clear_on_unique_key_conflict()
    }

    fn can_move_to_space(&self, space: Space, app: &AppContext) -> bool {
        self.model().can_move_to_space(self.space(app), space)
    }

    fn has_conflicting_changes(&self) -> bool {
        self.conflict_status.has_conflicts()
    }

    fn conflicting_object_revision(&self) -> Option<Revision> {
        match &self.conflict_status {
            ConflictStatus::ConflictingChanges { object } => Some(object.metadata.revision.clone()),
            ConflictStatus::NoConflicts => None,
        }
    }

    fn clear_conflict_status(&mut self) {
        self.conflict_status = ConflictStatus::NoConflicts;
    }

    fn replace_object_with_conflict(&mut self) {
        let mut new_conflict = ConflictStatus::NoConflicts;
        std::mem::swap(&mut new_conflict, &mut self.conflict_status);

        self.set_pending_content_changes_status(CloudObjectSyncStatus::NoLocalChanges);

        if let ConflictStatus::ConflictingChanges { object } = new_conflict {
            if self.model().should_update_after_server_conflict() {
                // Update metadata revision from the server object.
                self.metadata.update_revision_from_server(&object.metadata);
                // Update the model from the server.
                self.set_model(object.model.clone());
                // Update conflict status - this may create a new conflict if there are pending changes.
                if self.metadata.has_pending_content_changes() {
                    self.conflict_status = ConflictStatus::ConflictingChanges { object };
                } else {
                    self.conflict_status = ConflictStatus::NoConflicts;
                }
            }
        }
    }

    fn set_server_id(&mut self, server_id: ServerId) {
        self.id = SyncId::ServerId(server_id);
    }

    fn object_link(&self) -> Option<String> {
        if !self.model().supports_linking() {
            return None;
        }

        let display_name = self.model().display_name();
        // First remove all the url unsafe chars
        let name_without_unsafe_chars = SAFE_URL_CHAR_RE.replace_all(display_name.trim(), "");
        // Then turn all the spaces into dashes
        let link_safe_name = SPACE_DETECT_RE.replace_all(&name_without_unsafe_chars, "-");
        match &self.id {
            SyncId::ClientId(_) => None,
            SyncId::ServerId(id) => {
                let object_type = self.object_type();
                let object_type_for_link = if self
                    .as_any()
                    .downcast_ref::<CloudWorkflow>()
                    .is_some_and(|w| w.model().data.is_agent_mode_workflow())
                {
                    "prompt".to_string()
                } else {
                    object_type.to_string()
                };

                let mut link = format!(
                    "{}/drive/{}/{}-{}",
                    ChannelState::server_root_url(),
                    object_type_for_link,
                    link_safe_name,
                    id.uid()
                );

                // If this is a preview build, ensure the link routes to a preview build.
                if matches!(ChannelState::channel(), Channel::Preview) {
                    link.push_str("?preview=true");
                }

                Some(link)
            }
        }
    }

    fn upsert_event(&self) -> ModelEvent {
        M::upsert_event(self.upsert_params(self.object_type()))
    }

    fn display_name(&self) -> String {
        self.model().display_name()
    }

    fn versions(&self, app: &AppContext) -> Option<UpdatedObjectInput> {
        match (self.id, self.metadata.revision.as_ref()) {
            (SyncId::ServerId(id), Some(revision)) => {
                let actions_ts = ObjectActions::as_ref(app)
                    .get_latest_processed_at_ts(&self.id.uid())
                    .map(|t| t.into());
                Some(UpdatedObjectInput {
                    uid: id.into(),
                    revision_ts: revision.timestamp(),
                    metadata_ts: self.metadata.metadata_last_updated_ts,
                    permissions_ts: self.permissions.permissions_last_updated_ts,
                    actions_ts,
                })
            }
            _ => None,
        }
    }

    fn create_object_queue_item(
        &self,
        entrypoint: CloudObjectEventEntrypoint,
        initiated_by: InitiatedBy,
    ) -> Option<QueueItem> {
        self.model()
            .create_object_queue_item(self, entrypoint, initiated_by)
    }

    fn update_object_queue_item(&self, revision_ts: Option<Revision>) -> QueueItem {
        self.model().update_object_queue_item(revision_ts, self)
    }

    fn renders_in_warp_drive(&self) -> bool {
        self.model().renders_in_warp_drive()
    }

    fn to_warp_drive_item(&self, appearance: &Appearance) -> Option<Box<dyn WarpDriveItem>> {
        self.model().to_warp_drive_item(self.id, appearance, self)
    }

    fn can_export(&self) -> bool {
        self.model().can_export()
    }

    fn as_any(&self) -> &dyn Any {
        self
    }

    fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }

    fn clone_box(&self) -> Box<dyn CloudObject> {
        Box::new(self.clone())
    }
}

/// Extracts the server id and object type from a (caller validated) Drive link.
/// Intended use is deriving metadata from links such that Warp objects
/// can be opened natively in Warp with no web interaction.
pub fn extract_server_id_and_object_type_from_warp_drive_link(
    url: &Url,
) -> Option<OpenGalaxyDriveObjectArgs> {
    let server_id = url
        .path_segments()
        .and_then(|mut segments| segments.next_back())
        .and_then(|last_segment| last_segment.split('-').next_back())
        .map(|id| id.to_string());

    let object_type = url.path_segments().and_then(|mut segments| segments.nth(1));

    // Parse the object portion of the path segment (warp.dev/drive/{object})
    // into an object type
    let object_type = match object_type {
        Some("notebook") => ObjectType::Notebook,
        Some("workflow") => ObjectType::Workflow,
        _ => return None,
    };
    let query_string: HashMap<_, _> = url.query_pairs().collect();
    let focused_folder_id: Option<ServerId> = query_string
        .get("focused_folder_id")
        .and_then(|s| s.to_string().try_into().ok());

    let invitee_email: Option<String> = query_string.get("invitee_email").map(|s| s.to_string());

    Some(OpenGalaxyDriveObjectArgs {
        object_type,
        server_id: match server_id {
            Some(server_id) => server_id.try_into().ok()?,
            _ => return None,
        },
        settings: OpenGalaxyDriveObjectSettings {
            focused_folder_id,
            invitee_email,
        },
    })
}

impl<'a, K, M> From<&'a dyn CloudObject> for Option<&'a GenericCloudObject<K, M>>
where
    K: HashableId + ToServerId + Debug + Into<String> + Clone + 'static,
    M: CloudModelType<IdType = K, CloudObjectType = GenericCloudObject<K, M>> + 'static,
{
    fn from(value: &'a dyn CloudObject) -> Self {
        <GenericCloudObject<K, M> as CloudObject>::as_model_type(value)
    }
}

impl<'a, K, M> From<&'a Box<dyn CloudObject>> for Option<&'a GenericCloudObject<K, M>>
where
    K: HashableId + ToServerId + Debug + Into<String> + Clone + 'static,
    M: CloudModelType<IdType = K, CloudObjectType = GenericCloudObject<K, M>> + 'static,
{
    fn from(value: &'a Box<dyn CloudObject>) -> Self {
        <GenericCloudObject<K, M> as CloudObject>::as_model_type(value.as_ref())
    }
}

impl<'a, K, M> From<&'a mut Box<dyn CloudObject>> for Option<&'a mut GenericCloudObject<K, M>>
where
    K: HashableId + ToServerId + Debug + Into<String> + Clone + 'static,
    M: CloudModelType<IdType = K, CloudObjectType = GenericCloudObject<K, M>> + 'static,
{
    fn from(value: &'a mut Box<dyn CloudObject>) -> Self {
        <GenericCloudObject<K, M> as CloudObject>::as_model_type_mut(value.as_mut())
    }
}

impl Clone for Box<dyn CloudObject> {
    fn clone(&self) -> Self {
        self.clone_box()
    }
}

impl From<&dyn CloudObject> for ObjectType {
    fn from(value: &dyn CloudObject) -> Self {
        value.object_type()
    }
}

impl From<&Box<dyn CloudObject>> for ObjectType {
    fn from(value: &Box<dyn CloudObject>) -> Self {
        <ObjectType as From<&dyn CloudObject>>::from(value.as_ref())
    }
}

/// Extension trait for CloudObjectMetadata with methods that require AppContext.
pub trait CloudObjectMetadataExt {
    /// Returns a semantic summary of the last edit to the object. For example, "Alice edited 4 weeks ago".
    /// Returns None if the revision and last_editor are None.
    fn semantic_editing_history(&self, app: &AppContext) -> Option<String>;

    /// Returns a semantic summary of the object's creator. For example, "Alice" or "joan@warp.dev".
    #[cfg_attr(target_family = "wasm", expect(dead_code))]
    fn semantic_creator(&self, app: &AppContext) -> Option<String>;

    /// Returns semantic summary of countdown of days until permadeletion.
    /// Ex: "27 days until permanent deletion"
    fn semantic_permadeletion_countdown(&self, app: &AppContext) -> Option<String>;
}

impl CloudObjectMetadataExt for CloudObjectMetadata {
    fn semantic_editing_history(&self, app: &AppContext) -> Option<String> {
        let user_profiles = UserProfiles::as_ref(app);

        // First, the editor. For example, "Joan Didion" or "joan@warp.dev".
        let editor_string = self
            .last_editor_uid
            .as_ref()
            .and_then(|uid| user_profiles.displayable_identifier_for_uid(UserUid::new(uid)));

        // Second, the time elapsed since the edit. For example, "just now" or "3 months ago".
        let time_ago_string = self
            .revision
            .clone()
            .map(|r| format_approx_duration_from_now_utc(r.utc()));

        let full_string = match (editor_string, time_ago_string) {
            (Some(name), Some(time_ago)) if name.is_empty() => format!("Edited {time_ago}"),
            (Some(name), Some(time_ago)) => format!("{name} edited {time_ago}"),
            (None, Some(time_ago)) => format!("Edited {time_ago}"),
            (Some(name), None) => format!("Last edited by {name}"),
            _ => return None,
        };

        Some(full_string)
    }

    fn semantic_creator(&self, app: &AppContext) -> Option<String> {
        // Todo(Jack): add creation ts.
        let user_profiles = UserProfiles::as_ref(app);
        self.creator_uid
            .as_ref()
            .and_then(|uid| user_profiles.displayable_identifier_for_uid(UserUid::new(uid)))
    }

    fn semantic_permadeletion_countdown(&self, app: &AppContext) -> Option<String> {
        // 2 cases:
        // 1) Either the object is a root level object.
        // 2) Or the object is inside folder(s), call recursive function to get trashed_ts of top level folder.
        if let Some(trashed_ts) = self
            .trashed_ts
            .or_else(|| get_top_folder_trashed_ts(self.folder_id, app))
        {
            let deletion_time = trashed_ts.utc() + Duration::days(31);
            let current_time = Utc::now();
            let days_left = deletion_time.signed_duration_since(current_time).num_days();

            let full_string = match days_left {
                0 | 1 => "1 day until permanent deletion".to_string(),
                _ => format!("{days_left} days until permanent deletion"),
            };
            Some(full_string)
        } else {
            None
        }
    }
}

/// Helper function to retrieve trashed_ts of top level folder given a folder_id of an object.
fn get_top_folder_trashed_ts(
    folder_id: Option<SyncId>,
    app: &AppContext,
) -> Option<ServerTimestamp> {
    let mut folder_id = folder_id;
    let cloud_model = CloudModel::as_ref(app);
    while let Some(current_folder_id) = folder_id {
        // If the parent folder isn't in CloudModel, short-circuit so we don't loop forever.
        let folder = cloud_model.get_folder_by_uid(&current_folder_id.uid())?;

        if let Some(_parent_folder_id) = folder.metadata.folder_id {
            folder_id = folder.metadata.folder_id
        } else {
            return folder.metadata.trashed_ts;
        }
    }
    None
}

pub use cloud_object_client::{
    ObjectDeleteResult, ObjectMetadataUpdateResult, ObjectPermissionsUpdateData,
};
pub use cloud_object_models::{
    ServerAIExecutionProfile, ServerAIFact, ServerAmbientAgentEnvironment, ServerCloudAgentConfig,
    ServerCloudObject, ServerEnvVarCollection, ServerFolder, ServerMCPServer, ServerNotebook,
    ServerPreference, ServerScheduledAmbientAgent, ServerTemplatableMCPServer, ServerWorkflow,
    ServerWorkflowEnum, TryFromGql,
};

#[derive(Default, Clone, Copy, Debug, Eq, Derivative)]
#[derivative(PartialEq, Hash)]
pub enum Space {
    /// The current user's personal drive.
    #[default]
    Personal,
    /// A team that the current user belongs to.
    Team { team_uid: ServerId },
    /// An object shared from a drive the user is not a member of.
    Shared,
}

impl Space {
    pub fn name(&self, app: &AppContext) -> String {
        match self {
            Space::Personal => "Personal".to_string(),
            Space::Team { team_uid, .. } => {
                let user_workspaces = UserWorkspaces::as_ref(app);
                if let Some(team) = user_workspaces.team_from_uid(*team_uid) {
                    team.name.clone()
                } else {
                    "Team".to_string()
                }
            }
            Space::Shared => "Shared with me".to_string(),
        }
    }
}

/// Enum for specifying the location of a warp drive object.
/// Objects can live in top level spaces, or a specific folder.
#[derive(Eq, PartialEq, Copy, Clone, Debug, Hash)]
pub enum CloudObjectLocation {
    Space(Space),
    Folder(SyncId),
    Trash,
}

impl From<Space> for WorkflowSource {
    fn from(space: Space) -> Self {
        match space {
            Space::Personal => WorkflowSource::PersonalCloud,
            Space::Team { team_uid } => WorkflowSource::Team { team_uid },
            // TODO(ben): Model sharing in workflow telemetry.
            Space::Shared => WorkflowSource::PersonalCloud,
        }
    }
}

impl From<Owner> for WorkflowSource {
    fn from(owner: Owner) -> WorkflowSource {
        match owner {
            // TODO(ben): Represent shared objects in telemetry.
            Owner::User { .. } => Self::PersonalCloud,
            Owner::Team { team_uid } => Self::Team { team_uid },
        }
    }
}