Integrating Platform Services and Basic Testing Strategies

// src/main.rs (or a dedicated actions.rs file if your project grows)
use gpui::actions;

// Define an action for copying text within our application's context
actions!(app, [CopyText]);

// ... rest of your application code will go here

// src/main.rs

use gpui::{
    actions, elements::*, px, App, AppContext, Context, EventEmitter, Global,
    Subscription, View, ViewContext, VisualContext, WindowOptions,
};
use std::sync::Arc;

// Define an action for copying text (re-declared for full context)
actions!(app, [CopyText]);

// Our simple view that holds some text
struct TextView {
    text: String,
    // We store subscriptions to ensure they are dropped when the view is.
    _subscriptions: Vec<Subscription>,
}

impl EventEmitter for TextView {}

impl TextView {
    fn new(cx: &mut ViewContext<Self>) -> Self {
        // Set a key context. This allows GPUI to automatically map system keybindings
        // (like Cmd-C/Ctrl-C) to our defined actions when this view is focused.
        cx.set_key_context("TextView");

        let subscriptions = vec![
            // Subscribe to the CopyText action. When CopyText is dispatched,
            // call `handle_copy_text`.
            cx.on_action(|this, _: &CopyText, cx| this.handle_copy_text(cx)),
        ];

        Self {
            text: "Hello from GPUI! Copy me!".to_string(),
            _subscriptions: subscriptions,
        }
    }

    // This method handles the CopyText action
    fn handle_copy_text(&mut self, cx: &mut ViewContext<Self>) {
        // Access the platform and call its `copy_text` method.
        // This places the content onto the system clipboard.
        cx.platform().copy_text(&self.text);
        println!("Copied: '{}'", self.text); // A simple print for debugging purposes
    }
}

impl View for TextView {
    // A unique name for this view type, useful for debugging and introspection.
    fn ui_name() -> &'static str {
        "TextView"
    }

    // The `render` method describes how the view should appear.
    fn render(&mut self, cx: &mut ViewContext<Self>) -> Element {
        div()
            .flex()
            .size_full() // Take up all available space
            .justify_center() // Center children horizontally
            .items_center() // Center children vertically
            .child(
                div()
                    .p_4() // Add padding
                    .bg_neutral_800() // Set a dark background color
                    .rounded_md() // Round the corners
                    .child(
                        text(&self.text) // Display our view's text
                            .text_color(rgb(0xFFFFFF)) // White text color
                            .text_xl() // Extra large text size
                    )
            )
            .into_any() // Convert the element to a type-erased AnyElement
    }
}

// Our main application setup
fn main() {
    App::new().run(|cx: &mut AppContext| {
        // Open a new window with default options
        cx.open_window(WindowOptions::default(), |cx| {
            // Create a new instance of our TextView and add it to the window
            cx.new_view(|cx| TextView::new(cx))
        });
    });
}

// src/main.rs (update actions! macro and add to TextView impl)

// Define both CopyText and PasteText actions
actions!(app, [CopyText, PasteText]);

// ... inside impl TextView { ... }

// Update the new function to subscribe to PasteText
impl TextView {
    fn new(cx: &mut ViewContext<Self>) -> Self {
        cx.set_key_context("TextView");

        let subscriptions = vec![
            cx.on_action(|this, _: &CopyText, cx| this.handle_copy_text(cx)),
            // Add subscription for the PasteText action
            cx.on_action(|this, _: &PasteText, cx| this.handle_paste_text(cx)),
        ];

        Self {
            text: "Hello from GPUI! Copy me!".to_string(),
            _subscriptions: subscriptions,
        }
    }

    // ... handle_copy_text remains the same ...

    // New method to handle the PasteText action
    fn handle_paste_text(&mut self, cx: &mut ViewContext<Self>) {
        // Since `read_text()` returns a `Task`, we need to spawn an async block
        // to await its result without blocking the UI thread.
        cx.spawn(|this, mut cx| async move {
            // Await the result of reading from the clipboard
            if let Some(pasted_text) = cx.platform().read_text().await {
                // If text was successfully read, update the view's state.
                // We must use `this.update()` to modify view state from within a Task.
                this.update(&mut cx, |this, cx| {
                    this.text = pasted_text;
                    println!("Pasted: '{}'", this.text); // For debugging
                    cx.notify(); // Notify GPUI that the view's state has changed,
                                 // prompting a re-render.
                });
            } else {
                println!("Clipboard is empty or could not read text.");
            }
        }).detach(); // Detach the task if you don't need to await its completion from the caller.
                     // This means the task runs independently in the background.
    }
}

// src/main.rs (add this block at the end of the file)

#[cfg(test)] // This attribute ensures the code only compiles when running tests
mod tests {
    use super::*; // Bring items from the outer module into scope
    use gpui::{test_app_context, AppContext, Platform};
    use parking_lot::Mutex; // For thread-safe mutable state in our mock
    use std::sync::Arc; // For shared ownership of our mock's state

    // We need a custom mock platform to control clipboard behavior for tests.
    // The default `test_app_context` mock might not expose direct control over
    // specific platform service return values.
    struct MockPlatform {
        clipboard_content: Arc<Mutex<Option<String>>>,
    }

    // Implementing the `gpui::Platform` trait for our mock.
    // For methods not directly relevant to our clipboard tests, we'll use
    // `unimplemented!()` or a no-op implementation.
    // This highlights the verbosity of manual mocks for large traits.
    // In a real project, a mocking library like `mockall` would generate most of this.
    impl Platform for MockPlatform {
        fn run_on_main_thread(&self, f: Box<dyn FnOnce() + Send>) { f(); }
        fn dispatch_on_main_thread(&self, f: Box<dyn FnOnce() + Send>) { f(); }
        fn run_loop_on_main_thread(&self, _: Box<dyn FnOnce() + Send>) -> gpui::Task<()> { gpui::Task::ready(()) }
        fn background_executor(&self) -> &gpui::BackgroundExecutor { unimplemented!("MockPlatform does not implement background_executor") }
        fn foreground_executor(&self) -> &gpui::ForegroundExecutor { unimplemented!("MockPlatform does not implement foreground_executor") }
        fn text_system(&self) -> &gpui::TextSystem { unimplemented!("MockPlatform does not implement text_system") }
        fn font_cache(&self) -> &gpui::FontCache { unimplemented!("MockPlatform does not implement font_cache") }
        fn window_bounds(&self, _: gpui::WindowId) -> gpui::Bounds<gpui::GlobalPixels> { unimplemented!("MockPlatform does not implement window_bounds") }
        fn set_window_bounds(&self, _: gpui::WindowId, _: gpui::Bounds<gpui::GlobalPixels>) { unimplemented!("MockPlatform does not implement set_window_bounds") }
        fn on_window_bounds_changed(&self, _: gpui::WindowId, _: Box<dyn FnMut(gpui::Bounds<gpui::GlobalPixels>)>) -> gpui::Subscription { unimplemented!("MockPlatform does not implement on_window_bounds_changed") }
        fn display_index_from_point(&self, _: gpui::Point<gpui::GlobalPixels>) -> gpui::AnyDisplayId { unimplemented!("MockPlatform does not implement display_index_from_point") }
        fn bounds_for_display(&self, _: gpui::AnyDisplayId) -> gpui::Bounds<gpui::GlobalPixels> { unimplemented!("MockPlatform does not implement bounds_for_display") }
        fn on_display_bounds_changed(&self, _: Box<dyn FnMut()>) -> gpui::Subscription { unimplemented!("MockPlatform does not implement on_display_bounds_changed") }
        fn open_url(&self, _: &str) {}
        fn open_file(&self, _: &std::path::Path) -> gpui::Task<std::io::Result<()>> { gpui::Task::ready(Ok(())) }
        fn prompt_for_paths(&self, _: gpui::FileDialogOptions) -> gpui::Task<Option<Vec<std::path::PathBuf>>> { gpui::Task::ready(None) }
        fn prompt_for_new_path(&self, _: gpui::FileDialogOptions) -> gpui::Task<Option<std::path::PathBuf>> { gpui::Task::ready(None) }
        fn show_context_menu(&self, _: gpui::Point<gpui::GlobalPixels>, _: gpui::ContextMenu) {}
        fn hide_context_menu(&self) {}
        fn on_menu_command(&self, _: Box<dyn FnMut(&str)>) -> gpui::Subscription { unimplemented!("MockPlatform does not implement on_menu_command") }
        fn on_system_theme_change(&self, _: Box<dyn FnMut(gpui::Theme)>) -> gpui::Subscription { unimplemented!("MockPlatform does not implement on_system_theme_change") }
        fn on_active_status_change(&self, _: Box<dyn FnMut(bool)>) -> gpui::Subscription { unimplemented!("MockPlatform does not implement on_active_status_change") }
        fn on_window_activation_change(&self, _: gpui::WindowId, _: Box<dyn FnMut(bool)>) -> gpui::Subscription { unimplemented!("MockPlatform does not implement on_window_activation_change") }
        fn on_window_appearance_change(&self, _: gpui::WindowId, _: Box<dyn FnMut(gpui::WindowAppearance)>) -> gpui::Subscription { unimplemented!("MockPlatform does not implement on_window_appearance_change") }
        fn on_window_finish_launching(&self, _: gpui::WindowId, _: Box<dyn FnOnce()>) {}
        fn on_event(&self, _: gpui::WindowId, _: Box<dyn FnMut(gpui::PlatformEvent)>) -> gpui::Subscription { unimplemented!("MockPlatform does not implement on_event") }
        fn activate(&self, _: bool) {}
        fn hide(&self) {}
        fn zoom_factor(&self, _: gpui::WindowId) -> f32 { 1.0 }
        fn set_zoom_factor(&self, _: gpui::WindowId, _: f32) { unimplemented!("MockPlatform does not implement set_zoom_factor") }
        fn display_id_from_window_id(&self, _: gpui::WindowId) -> gpui::AnyDisplayId { unimplemented!("MockPlatform does not implement display_id_from_window_id") }
        fn rect_for_applescript_display(&self, _: u32) -> gpui::Bounds<gpui::GlobalPixels> { unimplemented!("MockPlatform does not implement rect_for_applescript_display") }
        // Implement `write_to_clipboard` to store the text in our mock's state
        fn write_to_clipboard(&self, text: String) -> gpui::Task<()> {
            *self.clipboard_content.lock() = Some(text);
            gpui::Task::ready(())
        }
        // Implement `read_from_clipboard` to return text from our mock's state
        fn read_from_clipboard(&self) -> gpui::Task<Option<String>> {
            gpui::Task::ready(self.clipboard_content.lock().clone())
        }
        fn set_window_title(&self, _: gpui::WindowId, _: &str) { unimplemented!("MockPlatform does not implement set_window_title") }
        fn set_window_fullscreen(&self, _: gpui::WindowId, _: bool) { unimplemented!("MockPlatform does not implement set_window_fullscreen") }
        fn is_window_fullscreen(&self, _: gpui::WindowId) -> bool { unimplemented!("MockPlatform does not implement is_window_fullscreen") }
        fn set_window_maximized(&self, _: gpui::WindowId, _: bool) { unimplemented!("MockPlatform does not implement set_window_maximized") }
        fn is_window_maximized(&self, _: gpui::WindowId) -> bool { unimplemented!("MockPlatform does not implement is_window_maximized") }
        fn set_window_minimized(&self, _: gpui::WindowId, _: bool) { unimplemented!("MockPlatform does not implement set_window_minimized") }
        fn is_window_minimized(&self, _: gpui::WindowId) -> bool { unimplemented!("MockPlatform does not implement is_window_minimized") }
        fn set_window_background_color(&self, _: gpui::WindowId, _: gpui::Hsla) { unimplemented!("MockPlatform does not implement set_window_background_color") }
        fn toggle_window_shadow(&self, _: gpui::WindowId, _: bool) { unimplemented!("MockPlatform does not implement toggle_window_shadow") }
        fn get_window_appearance(&self, _: gpui::WindowId) -> gpui::WindowAppearance { unimplemented!("MockPlatform does not implement get_window_appearance") }
        fn request_window_attention(&self, _: gpui::WindowId) { unimplemented!("MockPlatform does not implement request_window_attention") }
        fn is_mouse_inside_window(&self, _: gpui::WindowId) -> bool { unimplemented!("MockPlatform does not implement is_mouse_inside_window") }
        fn track_mouse_position(&self, _: gpui::WindowId, _: Box<dyn FnMut(gpui::Point<gpui::GlobalPixels>)>) -> gpui::Subscription { unimplemented!("MockPlatform does not implement track_mouse_position") }
        fn display_name(&self, _: gpui::AnyDisplayId) -> String { unimplemented!("MockPlatform does not implement display_name") }
        fn on_input_event(&self, _: gpui::WindowId, _: Box<dyn FnMut(gpui::PlatformInput)>) -> gpui::Subscription { unimplemented!("MockPlatform does not implement on_input_event") }
        fn on_resize(&self, _: gpui::WindowId, _: Box<dyn FnMut(gpui::Size<gpui::GlobalPixels>)>) -> gpui::Subscription { unimplemented!("MockPlatform does not implement on_resize") }
        fn send_notification(&self, _: gpui::NotificationOptions) -> gpui::Task<()> { gpui::Task::ready(()) }
        fn invalidate_app_icon_if_needed(&self) { unimplemented!("MockPlatform does not implement invalidate_app_icon_if_needed") }
        fn dock_menu(&self) -> Option<gpui::DockMenu> { unimplemented!("MockPlatform does not implement dock_menu") }
        fn set_dock_menu(&self, _: gpui::DockMenu) { unimplemented!("MockPlatform does not implement set_dock_menu") }
        fn on_dock_menu_command(&self, _: Box<dyn FnMut(&str)>) -> gpui::Subscription { unimplemented!("MockPlatform does not implement on_dock_menu_command") }
        fn on_will_quit(&self, _: Box<dyn FnMut() -> gpui::Task<()>>) -> gpui::Subscription { unimplemented!("MockPlatform does not implement on_will_quit") }
        fn text_for_path(&self, _: &std::path::Path) -> gpui::Task<Result<String, std::io::Error>> { gpui::Task::ready(Err(std::io::Error::new(std::io::ErrorKind::NotFound, "mocked error"))) }
        fn write_text_to_path(&self, _: &std::path::Path, _: String) -> gpui::Task<Result<(), std::io::Error>> { gpui::Task::ready(Err(std::io::Error::new(std::io::ErrorKind::PermissionDenied, "mocked error"))) }
        fn path_for_resource(&self, _: &str) -> Option<std::path::PathBuf> { unimplemented!("MockPlatform does not implement path_for_resource") }
        fn take_screenshot(&self, _: gpui::WindowId) -> gpui::Task<Vec<u8>> { unimplemented!("MockPlatform does not implement take_screenshot") }
    }


    // Helper function to create a TextView in a test context
    fn setup_text_view(initial_text: &str, cx: &mut AppContext) -> gpui::ViewHandle<TextView> {
        cx.new_view(|cx| TextView {
            text: initial_text.to_string(),
            _subscriptions: vec![
                cx.on_action(|this, _: &CopyText, cx| this.handle_copy_text(cx)),
                cx.on_action(|this, _: &PasteText, cx| this.handle_paste_text(cx)),
            ],
        })
    }

    #[gpui::test] // This macro sets up the test environment for async GPUI tests
    async fn test_copy_text_action() {
        // Create shared state for our mock platform's clipboard
        let clipboard_content = Arc::new(Mutex::new(None));
        // Create an instance of our mock platform
        let mock_platform = Arc::new(MockPlatform { clipboard_content: clipboard_content.clone() });

        // Create a test AppContext, injecting our custom mock platform
        let mut app_context = test_app_context(Some(mock_platform));

        let initial_text = "Test text to copy";
        let text_view_handle = setup_text_view(initial_text, &mut app_context);

        // Simulate the CopyText action being dispatched
        app_context.dispatch_action(text_view_handle.clone(), &CopyText);

        // Allow any async tasks (like `write_to_clipboard` in our mock) to complete
        app_context.run_until_parked();

        // Verify that our mock platform's clipboard received the correct text
        assert_eq!(*clipboard_content.lock(), Some(initial_text.to_string()));

        // Ensure the view's internal state (its text) hasn't changed unexpectedly
        let current_text = text_view_handle.update(&mut app_context, |this, _cx| {
            this.text.clone()
        });
        assert_eq!(current_text, initial_text);
    }
}

// src/main.rs (add this to the `tests` module, after test_copy_text_action)

// ... inside #[cfg(test)] mod tests { ... }

#[gpui::test]
async fn test_paste_text_action() {
    let clipboard_content = Arc::new(Mutex::new(None));
    let mock_platform = Arc::new(MockPlatform { clipboard_content: clipboard_content.clone() });
    let mut app_context = test_app_context(Some(mock_platform));

    let initial_text = "Original text before paste";
    let text_view_handle = setup_text_view(initial_text, &mut app_context);

    // Scenario 1: Clipboard contains text
    let paste_value = "Pasted content from mock clipboard";
    *clipboard_content.lock() = Some(paste_value.to_string());

    app_context.dispatch_action(text_view_handle.clone(), &PasteText);
    app_context.run_until_parked(); // Wait for the async paste operation to complete

    let current_text_after_paste = text_view_handle.update(&mut app_context, |this, _cx| {
        this.text.clone()
    });
    assert_eq!(current_text_after_paste, paste_value.to_string(), "Text should be updated after pasting valid content.");

    // Scenario 2: Clipboard is empty
    *clipboard_content.lock() = None; // Simulate an empty clipboard

    app_context.dispatch_action(text_view_handle.clone(), &PasteText);
    app_context.run_until_parked();

    let current_text_after_empty_paste = text_view_handle.update(&mut app_context, |this, _cx| {
        this.text.clone()
    });
    // The text should remain the same as the last successful paste,
    // as our `handle_paste_text` only updates if `read_text()` returns `Some`.
    assert_eq!(current_text_after_empty_paste, paste_value.to_string(), "Text should not change when clipboard is empty.");

    // Scenario 3: Paste empty string (e.g., user copies empty selection)
    *clipboard_content.lock() = Some("".to_string());

    app_context.dispatch_action(text_view_handle.clone(), &PasteText);
    app_context.run_until_parked();

    let current_text_after_empty_string_paste = text_view_handle.update(&mut app_context, |this, _cx| {
        this.text.clone()
    });
    assert_eq!(current_text_after_empty_string_paste, "".to_string(), "Text should become empty if an empty string is pasted.");
}