use warpui::integration::TestStep;
use warpui::windowing::WindowManager;
use warpui::{SingletonEntity, WindowId, async_assert};

use super::open_workflow_count;
use crate::cloud_object::model::persistence::CloudModel;
use crate::cloud_object::{CloudObjectEventEntrypoint, Space};
use crate::drive::OpenWarpDriveObjectSettings;
use crate::integration_testing::view_getters::workspace_view;
use crate::server::cloud_objects::update_manager::UpdateManager;
use crate::server::ids::{ClientId, SyncId};
use crate::workflows::WorkflowViewMode;
use crate::workflows::manager::WorkflowOpenSource;
use crate::workflows::workflow::Workflow;
use crate::workspaces::user_workspaces::UserWorkspaces;

/// Create a personal workflow and save its sync ID into the step data.
pub fn create_a_personal_workflow(key: impl Into<String>) -> TestStep {
    let key = key.into();
    let workflow = Workflow::new("personal workflow", "echo 'name'");
    TestStep::new("Create a personal workflow")
        .with_action(move |app, _, data| {
            let client_id = ClientId::new();
            let sync_id = SyncId::ClientId(client_id);
            UpdateManager::handle(app).update(app, |update_manager, ctx| {
                update_manager.create_workflow(
                    workflow.clone(),
                    UserWorkspaces::as_ref(ctx)
                        .personal_drive(ctx)
                        .expect("User UID must be set in tests"),
                    None,
                    client_id,
                    CloudObjectEventEntrypoint::ManagementUI,
                    true,
                    ctx,
                );
            });

            data.insert(key.clone(), sync_id);
        })
        .add_assertion(move |app, _| {
            CloudModel::handle(app).read(app, |cloud_model, ctx| {
                async_assert!(
                    cloud_model
                        .active_cloud_objects_in_space(Space::Personal, ctx)
                        .count()
                        > 0,
                    "Workflow exists"
                )
            })
        })
}

/// Open the workflow saved at `workflow_key` in the active tab of the window saved at `window_key`
pub fn open_workflow(window_key: impl Into<String>, workflow_key: impl Into<String>) -> TestStep {
    let window_key = window_key.into();
    let workflow_key = workflow_key.into();

    let workflow_other_key = workflow_key.clone();
    TestStep::new("Open workflow")
        .with_action(move |app, _, data| {
            let workflow_id: &SyncId = data.get(&workflow_key).expect("No saved workflow ID");
            let window_id: &WindowId = data.get(&window_key).expect("No saved window ID");
            workspace_view(app, *window_id).update(app, |workspace, ctx| {
                // If the workflow isn't open yet, opening it won't focus the window (we only change
                // focus if switching to an already-open window). Since the user wouldn't be able to
                // open a workflow in an unfocused window, switch focus explicitly here.
                WindowManager::as_ref(ctx).show_window_and_focus_app(*window_id);
                workspace.open_workflow_in_pane(
                    &WorkflowOpenSource::Existing(*workflow_id),
                    &OpenWarpDriveObjectSettings::default(),
                    WorkflowViewMode::View,
                    ctx,
                );
            })
        })
        .add_named_assertion_with_data_from_prior_step(
            "Check workflow is open",
            move |app, _, data| {
                let workflow_id: &SyncId =
                    data.get(&workflow_other_key).expect("No workflow ID found");
                async_assert!(open_workflow_count(app, *workflow_id) == 1)
            },
        )
}