alma 0.1.1

use super::error::{WasmtimePluginRuntimeError, WasmtimeWorkspaceObserveTaskEnqueueError};
use crate::plugin::{
    PluginHostOwnerBatches, PluginHostOwnerDiscardReport, PluginIdentity, PluginOperationalEvent,
    PluginRevocationReport, PluginWorkspaceObserveTaskCancellationReport,
    PluginWorkspaceObserveTaskDiscardReport, PluginWorkspaceObserveTaskEnqueueReport,
    SealedPluginEffectBatch, SealedPluginWorkspaceIoBatch,
};
use std::fmt::{Debug, Formatter};

/// Runtime cleanup produced while revoking a matching Wasmtime plugin instance.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct WasmtimePluginRevocationCleanup {
    /// Lifecycle revocation proof from the host state.
    pub(super) revocation: PluginRevocationReport,
    /// Runtime-owned workspace observation task cleanup.
    pub(super) workspace_observe_tasks: PluginWorkspaceObserveTaskCancellationReport,
}

impl WasmtimePluginRevocationCleanup {
    /// Returns the revoked plugin identity for display and serialization.
    #[must_use]
    pub fn identity(&self) -> &str {
        self.revocation.identity()
    }

    /// Returns the validated revoked identity.
    #[must_use]
    pub const fn identity_proof(&self) -> &PluginIdentity {
        self.revocation.identity_proof()
    }

    /// Returns the lifecycle revocation proof.
    #[must_use]
    pub const fn revocation(&self) -> &PluginRevocationReport {
        &self.revocation
    }

    /// Returns runtime-owned workspace observation task cleanup.
    #[must_use]
    pub const fn workspace_observe_tasks(&self) -> &PluginWorkspaceObserveTaskCancellationReport {
        &self.workspace_observe_tasks
    }

    /// Splits lifecycle revocation from runtime-owned cleanup.
    #[must_use]
    pub fn into_parts(self) -> WasmtimePluginRevocationCleanupParts {
        WasmtimePluginRevocationCleanupParts {
            revocation: self.revocation,
            workspace_observe_tasks: self.workspace_observe_tasks,
        }
    }
}

/// Revocation cleanup split by lifecycle and runtime-owned task cleanup.
pub struct WasmtimePluginRevocationCleanupParts {
    /// Lifecycle revocation proof from the host state.
    pub revocation: PluginRevocationReport,
    /// Runtime-owned workspace observation task cleanup.
    pub workspace_observe_tasks: PluginWorkspaceObserveTaskCancellationReport,
}

/// Successful Wasmtime update with workspace observation tasks already scheduled.
pub struct WasmtimePluginScheduledUpdate {
    /// Successful-return work for non-runtime owners.
    owner_batches: PluginHostOwnerBatches,
    /// Task ids admitted to the runtime-owned observation queue.
    scheduled_workspace_observe_tasks: PluginWorkspaceObserveTaskEnqueueReport,
}

/// Scheduled update work split by the owners that must consume it next.
pub struct WasmtimePluginScheduledUpdateParts {
    /// Successful-return work for non-runtime owners.
    pub owner_batches: PluginHostOwnerBatches,
    /// Task ids already admitted to the runtime-owned observation queue.
    pub scheduled_workspace_observe_tasks: PluginWorkspaceObserveTaskEnqueueReport,
}

impl WasmtimePluginScheduledUpdate {
    /// Builds the scheduled-update proof after runtime task admission succeeds.
    pub(super) fn new(
        owner_batches: PluginHostOwnerBatches,
        scheduled_workspace_observe_tasks: PluginWorkspaceObserveTaskEnqueueReport,
    ) -> Self {
        assert_eq!(
            owner_batches.identity_proof(),
            scheduled_workspace_observe_tasks.identity_proof(),
            "scheduled Wasmtime update must share one plugin identity",
        );
        Self {
            owner_batches,
            scheduled_workspace_observe_tasks,
        }
    }

    /// Returns the plugin identity for display and serialization.
    #[must_use]
    pub fn identity(&self) -> &str {
        self.owner_batches.identity()
    }

    /// Returns the identity proof shared by all scheduled update work.
    #[must_use]
    pub const fn identity_proof(&self) -> &PluginIdentity {
        self.owner_batches.identity_proof()
    }

    /// Returns the sealed editor effects.
    #[must_use]
    pub const fn effects(&self) -> &SealedPluginEffectBatch {
        self.owner_batches.effects()
    }

    /// Returns the sealed workspace I/O batch.
    #[must_use]
    pub const fn workspace_io(&self) -> &SealedPluginWorkspaceIoBatch {
        self.owner_batches.workspace_io()
    }

    /// Returns the scheduled workspace observation tasks.
    #[must_use]
    pub const fn scheduled_workspace_observe_tasks(
        &self,
    ) -> &PluginWorkspaceObserveTaskEnqueueReport {
        &self.scheduled_workspace_observe_tasks
    }

    /// Returns the successful-return work that must still reach non-runtime owners.
    #[must_use]
    pub const fn owner_batches(&self) -> &PluginHostOwnerBatches {
        &self.owner_batches
    }

    /// Splits scheduled update work by runtime and non-runtime owner boundaries.
    #[must_use]
    pub fn into_parts(self) -> WasmtimePluginScheduledUpdateParts {
        WasmtimePluginScheduledUpdateParts {
            owner_batches: self.owner_batches,
            scheduled_workspace_observe_tasks: self.scheduled_workspace_observe_tasks,
        }
    }
}

impl Debug for WasmtimePluginScheduledUpdate {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("WasmtimePluginScheduledUpdate")
            .field("identity", self.identity_proof())
            .field("effect_count", &self.owner_batches.effects().effect_count())
            .field(
                "workspace_io_request_count",
                &self.owner_batches.workspace_io().request_count(),
            )
            .field(
                "scheduled_workspace_observe_task_count",
                &self.scheduled_workspace_observe_tasks.task_count(),
            )
            .finish()
    }
}

/// Workspace observation tasks that could not be scheduled after a successful update.
///
/// The guest update has already crossed the successful-return boundary. Owner work is still
/// unpublished, and the observe-task batch remains retryable through the enqueue error.
#[derive(thiserror::Error)]
#[error("plugin workspace observe task scheduling failed: {source}")]
pub struct WasmtimeWorkspaceObserveTaskScheduleError {
    /// Successful-return owner work that was not yet published.
    owner_batches: Box<PluginHostOwnerBatches>,
    /// Retryable task scheduling failure.
    #[source]
    source: Box<WasmtimeWorkspaceObserveTaskEnqueueError>,
}

/// Post-update scheduling failure split by retry owner.
pub struct WasmtimeWorkspaceObserveTaskScheduleErrorParts {
    /// Successful-return owner work that was not yet published.
    pub owner_batches: PluginHostOwnerBatches,
    /// Retryable task scheduling failure.
    pub enqueue_error: WasmtimeWorkspaceObserveTaskEnqueueError,
}

impl WasmtimeWorkspaceObserveTaskScheduleError {
    /// Builds a post-update schedule failure while keeping owner batches paired.
    pub(super) fn new(
        owner_batches: PluginHostOwnerBatches,
        source: WasmtimeWorkspaceObserveTaskEnqueueError,
    ) -> Self {
        assert_eq!(
            owner_batches.identity_proof(),
            source.batch().identity_proof(),
            "Wasmtime observe-task schedule error must share one plugin identity",
        );
        Self {
            owner_batches: Box::new(owner_batches),
            source: Box::new(source),
        }
    }

    /// Returns the plugin identity for display and serialization.
    #[must_use]
    pub fn identity(&self) -> &str {
        self.owner_batches.identity()
    }

    /// Returns the identity proof for the unpublished owner work.
    #[must_use]
    pub const fn identity_proof(&self) -> &PluginIdentity {
        self.owner_batches.identity_proof()
    }

    /// Returns the unpublished editor effects.
    #[must_use]
    pub fn effects(&self) -> &SealedPluginEffectBatch {
        self.owner_batches.effects()
    }

    /// Returns the unpublished workspace I/O.
    #[must_use]
    pub fn workspace_io(&self) -> &SealedPluginWorkspaceIoBatch {
        self.owner_batches.workspace_io()
    }

    /// Returns the unpublished owner work as one identity proof.
    #[must_use]
    pub fn owner_batches(&self) -> &PluginHostOwnerBatches {
        &self.owner_batches
    }

    /// Returns the retryable task enqueue failure.
    #[must_use]
    pub fn enqueue_error(&self) -> &WasmtimeWorkspaceObserveTaskEnqueueError {
        &self.source
    }

    /// Redacted operational event for the scheduling failure, when one is useful.
    #[must_use]
    pub fn operational_event(&self) -> Option<PluginOperationalEvent> {
        self.source.operational_event()
    }

    /// Splits successful-return work from the retryable task enqueue failure.
    #[must_use]
    pub fn into_parts(self) -> WasmtimeWorkspaceObserveTaskScheduleErrorParts {
        WasmtimeWorkspaceObserveTaskScheduleErrorParts {
            owner_batches: *self.owner_batches,
            enqueue_error: *self.source,
        }
    }

    /// Discards unpublished owner work and unscheduled observe-task work.
    #[must_use]
    pub fn discard(self) -> WasmtimeWorkspaceObserveTaskScheduleDiscardReport {
        let WasmtimeWorkspaceObserveTaskScheduleErrorParts {
            owner_batches,
            enqueue_error,
        } = self.into_parts();
        WasmtimeWorkspaceObserveTaskScheduleDiscardReport::new(
            owner_batches.discard(),
            enqueue_error.discard_batch(),
        )
    }
}

impl Debug for WasmtimeWorkspaceObserveTaskScheduleError {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("WasmtimeWorkspaceObserveTaskScheduleError")
            .field("identity", self.identity_proof())
            .field("effect_count", &self.owner_batches.effects().effect_count())
            .field(
                "workspace_io_request_count",
                &self.owner_batches.workspace_io().request_count(),
            )
            .field("enqueue_error_kind", &self.source.kind())
            .field(
                "workspace_observe_task_count",
                &self.source.batch().task_count(),
            )
            .finish()
    }
}

/// Discard report for post-update work when observe-task scheduling is abandoned.
#[derive(Eq, PartialEq)]
pub struct WasmtimeWorkspaceObserveTaskScheduleDiscardReport {
    /// Successful-return owner work discarded instead of published.
    owner_work: PluginHostOwnerDiscardReport,
    /// Observe-task batch discarded before filesystem policy execution.
    workspace_observe_tasks: PluginWorkspaceObserveTaskDiscardReport,
}

/// Post-update schedule discard report split by owner boundary.
pub struct WasmtimeWorkspaceObserveTaskScheduleDiscardReportParts {
    /// Successful-return owner work discarded instead of published.
    pub owner_work: PluginHostOwnerDiscardReport,
    /// Observe-task batch discarded before filesystem policy execution.
    pub workspace_observe_tasks: PluginWorkspaceObserveTaskDiscardReport,
}

impl WasmtimeWorkspaceObserveTaskScheduleDiscardReport {
    /// Builds a paired discard report for a post-update schedule failure.
    pub(super) fn new(
        owner_work: PluginHostOwnerDiscardReport,
        workspace_observe_tasks: PluginWorkspaceObserveTaskDiscardReport,
    ) -> Self {
        assert_eq!(
            owner_work.identity_proof(),
            workspace_observe_tasks.identity_proof(),
            "Wasmtime observe-task schedule discard report must share one plugin identity",
        );
        Self {
            owner_work,
            workspace_observe_tasks,
        }
    }

    /// Returns the plugin identity whose post-update work was discarded.
    #[must_use]
    pub fn identity(&self) -> &str {
        self.identity_proof().as_str()
    }

    /// Returns the validated identity shared by both report halves.
    #[must_use]
    pub const fn identity_proof(&self) -> &PluginIdentity {
        self.owner_work.identity_proof()
    }

    /// Returns the discarded owner work report.
    #[must_use]
    pub const fn owner_work(&self) -> &PluginHostOwnerDiscardReport {
        &self.owner_work
    }

    /// Returns the discarded observe-task work report.
    #[must_use]
    pub const fn workspace_observe_tasks(&self) -> &PluginWorkspaceObserveTaskDiscardReport {
        &self.workspace_observe_tasks
    }

    /// Splits the paired discard report by owner boundary.
    #[must_use]
    pub fn into_parts(self) -> WasmtimeWorkspaceObserveTaskScheduleDiscardReportParts {
        WasmtimeWorkspaceObserveTaskScheduleDiscardReportParts {
            owner_work: self.owner_work,
            workspace_observe_tasks: self.workspace_observe_tasks,
        }
    }
}

impl Debug for WasmtimeWorkspaceObserveTaskScheduleDiscardReport {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("WasmtimeWorkspaceObserveTaskScheduleDiscardReport")
            .field("identity", self.identity_proof())
            .field(
                "discarded_effect_count",
                &self.owner_work.effects().discarded_effects(),
            )
            .field(
                "discarded_workspace_io_request_count",
                &self.owner_work.workspace_io().discarded_requests(),
            )
            .field(
                "discarded_workspace_observe_task_count",
                &self.workspace_observe_tasks.discarded_tasks(),
            )
            .finish()
    }
}

/// Failure while running an update and scheduling its workspace observation tasks.
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum WasmtimePluginUpdateScheduleError {
    /// Guest update failed before successful-return task scheduling.
    #[error(transparent)]
    Update(#[from] WasmtimePluginRuntimeError),
    /// Task scheduling failed after the guest update returned successfully.
    #[error(transparent)]
    WorkspaceObserveTasks(#[from] WasmtimeWorkspaceObserveTaskScheduleError),
}

impl WasmtimePluginUpdateScheduleError {
    /// Returns the update failure when scheduling never started.
    #[must_use]
    pub const fn update_error(&self) -> Option<&WasmtimePluginRuntimeError> {
        match self {
            Self::Update(source) => Some(source),
            Self::WorkspaceObserveTasks(_) => None,
        }
    }

    /// Returns the post-update task schedule failure.
    #[must_use]
    pub const fn workspace_observe_task_schedule_error(
        &self,
    ) -> Option<&WasmtimeWorkspaceObserveTaskScheduleError> {
        match self {
            Self::WorkspaceObserveTasks(source) => Some(source),
            Self::Update(_) => None,
        }
    }

    /// Returns the task scheduling failure when the guest update returned successfully.
    #[must_use]
    pub fn workspace_observe_task_enqueue_error(
        &self,
    ) -> Option<&WasmtimeWorkspaceObserveTaskEnqueueError> {
        match self {
            Self::WorkspaceObserveTasks(source) => Some(source.enqueue_error()),
            Self::Update(_) => None,
        }
    }

    /// Redacted operational event for this update or post-update scheduling failure.
    #[must_use]
    pub fn operational_event(&self) -> Option<PluginOperationalEvent> {
        match self {
            Self::Update(source) => source.operational_event(),
            Self::WorkspaceObserveTasks(source) => source.operational_event(),
        }
    }

    /// Consumes the top-level error and returns the paired post-update schedule failure.
    #[must_use]
    pub fn into_workspace_observe_task_schedule_error(
        self,
    ) -> Option<WasmtimeWorkspaceObserveTaskScheduleError> {
        match self {
            Self::WorkspaceObserveTasks(source) => Some(source),
            Self::Update(_) => None,
        }
    }
}