//! Stateful fake implementation of [`ObjectClient`] for end-to-end tests
//! of cloud preferences sync.
//!
//! Unlike the auto-generated [`MockObjectClient`] (which requires each test
//! to script per-method `expect_*()` calls up front), this fake maintains
//! an in-memory store of preferences that can be read back after the
//! syncer runs. Tests use [`FakeObjectClient::seed_preference`] to add
//! cloud-side state and [`FakeObjectClient::cloud_value`] to assert on
//! the result after a sync roundtrip.
//!
//! Only the subset of [`ObjectClient`] methods actually called by the
//! cloud preferences syncer has a real implementation — every other
//! method panics with `unimplemented!()`. This is deliberate: callers
//! that hit one of these panics have likely wired a non-preferences
//! code path through the fake by mistake.

use std::collections::HashMap;
use std::sync::{Arc, Mutex};

use anyhow::{Result, anyhow};
use async_channel::Sender;
use async_trait::async_trait;
use chrono::{DateTime, Utc};
use cloud_object_client::ObjectPermissionUpdateResult;
use warp_graphql::object_permissions::AccessLevel;

use crate::cloud_object::model::actions::{ObjectActionHistory, ObjectActionType};
use crate::cloud_object::model::generic_string_model::GenericStringObjectId;
use crate::cloud_object::{
    BulkCreateCloudObjectResult, BulkCreateGenericStringObjectsRequest, CreateCloudObjectResult,
    CreateObjectRequest, CreatedCloudObject, GenericStringObjectFormat,
    GenericStringObjectUniqueKey, JsonObjectType, ObjectDeleteResult, ObjectIdType,
    ObjectMetadataUpdateResult, ObjectPermissionsUpdateData, ObjectType, ObjectsToUpdate, Owner,
    Revision, RevisionAndLastEditor, ServerFolder, ServerMetadata, ServerNotebook, ServerObject,
    ServerPermissions, ServerPreference, ServerWorkflow, UpdateCloudObjectResult,
};
use crate::drive::folders::FolderId;
use crate::drive::sharing::SharingAccessLevel;
use crate::notebooks::NotebookId;
use crate::server::cloud_objects::listener::ObjectUpdateMessage;
use crate::server::cloud_objects::update_manager::{GetCloudObjectResponse, InitialLoadResponse};
use crate::server::ids::{ServerId, ServerIdAndType, SyncId};
use crate::server::server_api::object::{GuestIdentifier, ObjectClient};
use crate::server::sync_queue::SerializedModel;
use crate::settings::cloud_preferences::{CloudPreferenceModel, Platform, Preference};
use crate::workflows::WorkflowId;

/// A stateful fake cloud preferences backend.
#[derive(Clone, Default)]
pub struct FakeObjectClient {
    state: Arc<Mutex<FakeCloudState>>,
}

#[derive(Default)]
struct FakeCloudState {
    /// Stored preferences keyed by `GenericStringObjectId`. The
    /// preferences syncer addresses updates and deletes by id, so this
    /// is the authoritative lookup.
    preferences: HashMap<GenericStringObjectId, StoredPreference>,
    /// Monotonically increasing counter used to allocate fresh
    /// [`ServerId`]s for newly created preferences.
    next_server_id: i64,
}

struct StoredPreference {
    model: CloudPreferenceModel,
    revision: Revision,
    metadata_ts: chrono::DateTime<Utc>,
}

impl FakeObjectClient {
    /// Seeds a preference into the cloud store as if another client had
    /// already written it. Returns the allocated [`ServerId`] so tests
    /// can reference it later if needed.
    ///
    /// The `value_json` argument is the JSON-serialized setting value
    /// (e.g. `"14.0"` for a float, `"true"` for a bool, `"\"Hack\""`
    /// for a string). This matches the format used by
    /// [`Preference::new`].
    pub fn seed_preference(
        &self,
        storage_key: &str,
        value_json: &str,
        platform: Platform,
    ) -> ServerId {
        let preference = build_preference(storage_key, value_json, platform);
        let model = CloudPreferenceModel::new(preference);

        let mut state = self.state.lock().unwrap();
        let server_id = state.alloc_server_id();
        state.preferences.insert(
            GenericStringObjectId::from(server_id),
            StoredPreference {
                model,
                revision: Revision::now(),
                metadata_ts: Utc::now(),
            },
        );
        server_id
    }

    /// Returns the current cloud value for the preference with the
    /// given storage key and platform, or `None` if the fake has no
    /// such preference.
    ///
    /// The returned string is the JSON-serialized setting value (same
    /// shape as [`Self::seed_preference`]).
    pub fn cloud_value(&self, storage_key: &str, platform: Platform) -> Option<String> {
        let state = self.state.lock().unwrap();
        state
            .preferences
            .values()
            .find(|stored| {
                stored.model.string_model.storage_key == storage_key
                    && stored.model.string_model.platform == platform
            })
            .map(|stored| stored.model.string_model.value.to_string())
    }

    /// Builds an [`InitialLoadResponse`] that reflects the current
    /// state of the fake. Tests pass the return value to
    /// [`UpdateManager::mock_initial_load`] to simulate the syncer's
    /// initial load seeing the seeded cloud state.
    pub fn snapshot_as_initial_load_response(&self) -> InitialLoadResponse {
        let state = self.state.lock().unwrap();
        let server_objects: Vec<Box<dyn ServerObject>> = state
            .preferences
            .iter()
            .map(|(id, stored)| {
                let metadata = ServerMetadata {
                    uid: ServerId::from(*id),
                    revision: stored.revision,
                    metadata_last_updated_ts: stored.metadata_ts.into(),
                    trashed_ts: None,
                    folder_id: None,
                    is_welcome_object: false,
                    creator_uid: None,
                    last_editor_uid: None,
                    current_editor_uid: None,
                };
                let permissions = ServerPermissions {
                    space: Owner::mock_current_user(),
                    guests: Vec::new(),
                    anyone_link_sharing: None,
                    permissions_last_updated_ts: stored.metadata_ts.into(),
                };
                let server_pref = ServerPreference::new(
                    SyncId::ServerId(ServerId::from(*id)),
                    stored.model.clone(),
                    metadata,
                    permissions,
                );
                Box::new(server_pref) as Box<dyn ServerObject>
            })
            .collect();

        let mut response = InitialLoadResponse::default();
        if !server_objects.is_empty() {
            response.updated_generic_string_objects.insert(
                GenericStringObjectFormat::Json(JsonObjectType::Preference),
                server_objects,
            );
        }
        response
    }
}

impl FakeCloudState {
    fn alloc_server_id(&mut self) -> ServerId {
        self.next_server_id += 1;
        ServerId::from(self.next_server_id)
    }
}

/// Builds a [`Preference`] struct from a storage key, JSON value, and
/// explicit platform. This bypasses [`Preference::new`]'s syncing-mode
/// inference so tests can seed preferences with an arbitrary platform.
fn build_preference(storage_key: &str, value_json: &str, platform: Platform) -> Preference {
    let value: serde_json::Value = serde_json::from_str(value_json)
        .unwrap_or_else(|err| panic!("invalid JSON value {value_json:?}: {err}"));
    Preference {
        storage_key: storage_key.to_owned(),
        value,
        platform,
    }
}

#[cfg_attr(not(target_family = "wasm"), async_trait)]
#[cfg_attr(target_family = "wasm", async_trait(?Send))]
impl ObjectClient for FakeObjectClient {
    async fn bulk_create_generic_string_objects(
        &self,
        _owner: Owner,
        objects: &[BulkCreateGenericStringObjectsRequest],
    ) -> Result<BulkCreateCloudObjectResult> {
        let mut state = self.state.lock().unwrap();
        let mut created = Vec::with_capacity(objects.len());
        for request in objects {
            let serialized = request.serialized_model.model_as_str();
            let model = CloudPreferenceModel::deserialize_owned(serialized)
                .map_err(|err| anyhow!("fake cloud failed to deserialize preference: {err}"))?;
            let server_id = state.alloc_server_id();
            let now = Utc::now();
            state.preferences.insert(
                GenericStringObjectId::from(server_id),
                StoredPreference {
                    model,
                    revision: Revision::now(),
                    metadata_ts: now,
                },
            );
            created.push(CreatedCloudObject {
                client_id: request.id,
                revision_and_editor: RevisionAndLastEditor {
                    revision: Revision::now(),
                    last_editor_uid: None,
                },
                metadata_ts: now.into(),
                server_id_and_type: ServerIdAndType {
                    id: server_id,
                    id_type: ObjectIdType::GenericStringObject,
                },
                creator_uid: None,
                permissions: ServerPermissions::mock_personal(),
            });
        }
        Ok(BulkCreateCloudObjectResult::Success {
            created_cloud_objects: created,
        })
    }

    async fn update_generic_string_object(
        &self,
        object_id: GenericStringObjectId,
        model: SerializedModel,
        _revision: Option<Revision>,
    ) -> Result<UpdateCloudObjectResult<Box<dyn ServerObject>>> {
        let mut state = self.state.lock().unwrap();
        let stored = state
            .preferences
            .get_mut(&object_id)
            .ok_or_else(|| anyhow!("fake cloud: no preference with id {object_id:?}"))?;
        stored.model = CloudPreferenceModel::deserialize_owned(model.model_as_str())
            .map_err(|err| anyhow!("fake cloud failed to deserialize preference: {err}"))?;
        stored.revision = Revision::now();
        stored.metadata_ts = Utc::now();
        Ok(UpdateCloudObjectResult::Success {
            revision_and_editor: RevisionAndLastEditor {
                revision: stored.revision,
                last_editor_uid: None,
            },
        })
    }

    async fn delete_object(&self, id: ServerId) -> Result<ObjectDeleteResult> {
        let mut state = self.state.lock().unwrap();
        state.preferences.remove(&GenericStringObjectId::from(id));
        Ok(ObjectDeleteResult::Success {
            deleted_ids: vec![SyncId::ServerId(id)],
        })
    }

    async fn fetch_changed_objects(
        &self,
        _objects_to_update: ObjectsToUpdate,
        _force_refresh: bool,
    ) -> Result<InitialLoadResponse> {
        Ok(self.snapshot_as_initial_load_response())
    }

    async fn fetch_environment_last_task_run_timestamps(
        &self,
    ) -> Result<HashMap<String, DateTime<Utc>>> {
        Ok(HashMap::new())
    }

    // ───────────────────────────────────────────────────────────────
    // The methods below are not exercised by CloudPreferencesSyncer,
    // so they intentionally panic. If a future change to the syncer
    // starts calling one of these, the test that triggered the call
    // will fail loudly with a clear message rather than silently
    // misbehave.
    // ───────────────────────────────────────────────────────────────

    async fn create_workflow(
        &self,
        _request: CreateObjectRequest,
    ) -> Result<CreateCloudObjectResult> {
        unimplemented!("FakeObjectClient::create_workflow")
    }

    async fn update_workflow(
        &self,
        _workflow_id: WorkflowId,
        _data: SerializedModel,
        _revision: Option<Revision>,
    ) -> Result<UpdateCloudObjectResult<ServerWorkflow>> {
        unimplemented!("FakeObjectClient::update_workflow")
    }

    async fn create_generic_string_object(
        &self,
        _format: GenericStringObjectFormat,
        _uniqueness_key: Option<GenericStringObjectUniqueKey>,
        _request: CreateObjectRequest,
    ) -> Result<CreateCloudObjectResult> {
        unimplemented!("FakeObjectClient::create_generic_string_object")
    }

    async fn create_notebook(
        &self,
        _request: CreateObjectRequest,
    ) -> Result<CreateCloudObjectResult> {
        unimplemented!("FakeObjectClient::create_notebook")
    }

    async fn update_notebook(
        &self,
        _notebook_id: NotebookId,
        _title: Option<String>,
        _data: Option<SerializedModel>,
        _revision: Option<Revision>,
    ) -> Result<UpdateCloudObjectResult<ServerNotebook>> {
        unimplemented!("FakeObjectClient::update_notebook")
    }

    async fn create_folder(
        &self,
        _request: CreateObjectRequest,
    ) -> Result<CreateCloudObjectResult> {
        unimplemented!("FakeObjectClient::create_folder")
    }

    async fn update_folder(
        &self,
        _folder_id: FolderId,
        _name: SerializedModel,
    ) -> Result<UpdateCloudObjectResult<ServerFolder>> {
        unimplemented!("FakeObjectClient::update_folder")
    }

    async fn grab_notebook_edit_access(&self, _notebook_id: NotebookId) -> Result<ServerMetadata> {
        unimplemented!("FakeObjectClient::grab_notebook_edit_access")
    }

    async fn give_up_notebook_edit_access(
        &self,
        _notebook_id: NotebookId,
    ) -> Result<ServerMetadata> {
        unimplemented!("FakeObjectClient::give_up_notebook_edit_access")
    }

    async fn get_warp_drive_updates(
        &self,
        _message_sender: Sender<ObjectUpdateMessage>,
        _stream_ready_sender: Sender<()>,
    ) -> Result<()> {
        unimplemented!("FakeObjectClient::get_warp_drive_updates")
    }

    async fn fetch_single_cloud_object(&self, _id: ServerId) -> Result<GetCloudObjectResponse> {
        unimplemented!("FakeObjectClient::fetch_single_cloud_object")
    }

    async fn transfer_notebook_owner(
        &self,
        _notebook_id: NotebookId,
        _owner: Owner,
    ) -> Result<bool> {
        unimplemented!("FakeObjectClient::transfer_notebook_owner")
    }

    async fn transfer_workflow_owner(
        &self,
        _workflow_id: WorkflowId,
        _owner: Owner,
    ) -> Result<bool> {
        unimplemented!("FakeObjectClient::transfer_workflow_owner")
    }

    async fn transfer_generic_string_object_owner(
        &self,
        _id: GenericStringObjectId,
        _owner: Owner,
    ) -> Result<bool> {
        unimplemented!("FakeObjectClient::transfer_generic_string_object_owner")
    }

    async fn trash_object(&self, _id: ServerId) -> Result<bool> {
        unimplemented!("FakeObjectClient::trash_object")
    }

    async fn untrash_object(&self, _id: ServerId) -> Result<ObjectMetadataUpdateResult> {
        unimplemented!("FakeObjectClient::untrash_object")
    }

    async fn empty_trash(&self, _owner: Owner) -> Result<ObjectDeleteResult> {
        unimplemented!("FakeObjectClient::empty_trash")
    }

    async fn move_object(
        &self,
        _id: ServerId,
        _folder_id: Option<FolderId>,
        _owner: Owner,
        _object_type: ObjectType,
    ) -> Result<bool> {
        unimplemented!("FakeObjectClient::move_object")
    }

    async fn record_object_action(
        &self,
        _id: ServerId,
        _action_type: ObjectActionType,
        _timestamp: DateTime<Utc>,
        _data: Option<String>,
    ) -> Result<ObjectActionHistory> {
        unimplemented!("FakeObjectClient::record_object_action")
    }

    async fn leave_object(&self, _id: ServerId) -> Result<ObjectDeleteResult> {
        unimplemented!("FakeObjectClient::leave_object")
    }

    async fn set_object_link_permissions(
        &self,
        _object_id: ServerId,
        _access_level: SharingAccessLevel,
    ) -> Result<ObjectPermissionUpdateResult> {
        unimplemented!("FakeObjectClient::set_object_link_permissions")
    }

    async fn remove_object_link_permissions(
        &self,
        _object_id: ServerId,
    ) -> Result<ObjectPermissionUpdateResult> {
        unimplemented!("FakeObjectClient::remove_object_link_permissions")
    }

    async fn add_object_guests(
        &self,
        _object_id: ServerId,
        _guest_emails: Vec<String>,
        _access_level: AccessLevel,
    ) -> Result<ObjectPermissionsUpdateData> {
        unimplemented!("FakeObjectClient::add_object_guests")
    }

    async fn update_object_guests(
        &self,
        _object_id: ServerId,
        _guest_emails: Vec<String>,
        _access_level: AccessLevel,
    ) -> Result<ServerPermissions> {
        unimplemented!("FakeObjectClient::update_object_guests")
    }

    async fn remove_object_guest(
        &self,
        _object_id: ServerId,
        _guest: GuestIdentifier,
    ) -> Result<ServerPermissions> {
        unimplemented!("FakeObjectClient::remove_object_guest")
    }
}