alma 0.1.1

use super::{
    display::{Operational, write_list},
    effect::PluginRuntimeTraceEffect,
    proposal::PluginRuntimeTraceProposalReceipt,
    workspace::{
        PluginRuntimeTraceWorkspaceIoCompletion, PluginRuntimeTraceWorkspaceObserveTaskOutcome,
    },
};
use crate::ecs::events::edit::PluginBufferEditProposalReceipt;
#[cfg(feature = "plugin-runtime")]
use crate::plugin::WasmtimeWorkspaceObserveTaskScheduleDiscardReport;
use crate::plugin::{
    DrainedPluginEffectReport, PluginEffectDiscardReport, PluginHostImportDiscardReport,
    PluginHostOwnerDiscardReport, PluginIdentity, PluginOperationalEvent,
    PluginOperationalEventKind, PluginWorkspaceIoCancellationReport,
    PluginWorkspaceIoDiscardReport, PluginWorkspaceIoReport,
    PluginWorkspaceObserveTaskCancellationReport, PluginWorkspaceObserveTaskCompletion,
    PluginWorkspaceObserveTaskCompletionShape, PluginWorkspaceObserveTaskDiscardReport,
};
use std::fmt::{Display, Formatter};

/// One redacted event in a future plugin runtime replay trace.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PluginRuntimeTraceEvent {
    /// Stable identity when the lower boundary can attribute the event.
    identity: Option<PluginIdentity>,
    /// Redacted event payload.
    kind: PluginRuntimeTraceEventKind,
}

impl PluginRuntimeTraceEvent {
    /// Adapts drained effects after the successful guest-return boundary.
    #[must_use]
    pub fn drained_effects(report: &DrainedPluginEffectReport) -> Self {
        Self::scoped(
            report.identity_proof().clone(),
            PluginRuntimeTraceEventKind::EffectsDrained {
                effects: report
                    .buffer_edits()
                    .iter()
                    .map(PluginRuntimeTraceEffect::from)
                    .chain(
                        report
                            .status_messages()
                            .iter()
                            .map(PluginRuntimeTraceEffect::from),
                    )
                    .collect(),
            },
        )
    }

    /// Adapts a failed update discard report.
    #[must_use]
    pub fn update_discarded(report: &PluginHostImportDiscardReport) -> Self {
        Self::discarded_update_work(
            report.effects().identity_proof().clone(),
            report.effects().discarded_effects(),
            report.workspace_io().discarded_requests(),
            report.workspace_observe_tasks().discarded_tasks(),
        )
    }

    /// Adapts discarded owner work after successful guest return.
    #[must_use]
    pub fn owner_work_discarded(report: &PluginHostOwnerDiscardReport) -> Self {
        Self::discarded_update_work(
            report.identity_proof().clone(),
            report.effects().discarded_effects(),
            report.workspace_io().discarded_requests(),
            0,
        )
    }

    /// Adapts an effect discard report when no workspace report is available.
    #[must_use]
    pub fn effects_discarded(report: &PluginEffectDiscardReport) -> Self {
        Self::discarded_update_work(
            report.identity_proof().clone(),
            report.discarded_effects(),
            0,
            0,
        )
    }

    /// Adapts a workspace I/O discard report when no effect report is available.
    #[must_use]
    pub fn workspace_io_discarded(report: &PluginWorkspaceIoDiscardReport) -> Self {
        Self::discarded_update_work(
            report.identity_proof().clone(),
            0,
            report.discarded_requests(),
            0,
        )
    }

    /// Adapts a workspace observation task discard report when no effect report is available.
    #[must_use]
    pub fn workspace_observe_tasks_discarded(
        report: &PluginWorkspaceObserveTaskDiscardReport,
    ) -> Self {
        Self::discarded_update_work(
            report.identity_proof().clone(),
            0,
            0,
            report.discarded_tasks(),
        )
    }

    /// Adapts discarded post-update schedule work.
    #[cfg(feature = "plugin-runtime")]
    #[must_use]
    pub fn workspace_observe_task_schedule_discarded(
        report: &WasmtimeWorkspaceObserveTaskScheduleDiscardReport,
    ) -> Self {
        Self::discarded_update_work(
            report.identity_proof().clone(),
            report.owner_work().effects().discarded_effects(),
            report.owner_work().workspace_io().discarded_requests(),
            report.workspace_observe_tasks().discarded_tasks(),
        )
    }

    /// Adapts completed workspace I/O after filesystem-policy execution.
    #[must_use]
    pub fn workspace_io_completed(report: &PluginWorkspaceIoReport) -> Self {
        Self::scoped(
            report.identity_proof().clone(),
            PluginRuntimeTraceEventKind::WorkspaceIoCompleted {
                completions: report
                    .completions()
                    .iter()
                    .map(PluginRuntimeTraceWorkspaceIoCompletion::from)
                    .collect(),
            },
        )
    }

    /// Adapts canceled workspace I/O after revocation or shutdown cleanup.
    #[must_use]
    pub fn workspace_io_canceled(report: &PluginWorkspaceIoCancellationReport) -> Self {
        Self::scoped(
            report.identity_proof().clone(),
            PluginRuntimeTraceEventKind::WorkspaceIoCanceled {
                canceled_batches: report.canceled_batches(),
                canceled_requests: report.canceled_requests(),
            },
        )
    }

    /// Adapts a completed workspace observation task after filesystem-policy execution.
    #[must_use]
    pub fn workspace_observe_task_completed(
        completion: &PluginWorkspaceObserveTaskCompletion,
    ) -> Self {
        let shape = completion.shape();
        Self::scoped(
            shape.identity_proof().clone(),
            PluginRuntimeTraceEventKind::WorkspaceObserveTaskCompleted { completion: shape },
        )
    }

    /// Adapts canceled workspace observation task state after revocation or shutdown cleanup.
    #[must_use]
    pub fn workspace_observe_tasks_canceled(
        report: &PluginWorkspaceObserveTaskCancellationReport,
    ) -> Self {
        Self::scoped(
            report.identity_proof().clone(),
            PluginRuntimeTraceEventKind::WorkspaceObserveTasksCanceled {
                canceled_pending: report.canceled_pending(),
                discarded_retained: report.discarded_retained(),
            },
        )
    }

    /// Adapts an operational runtime event.
    #[must_use]
    pub fn operational(event: &PluginOperationalEvent) -> Self {
        Self {
            identity: event.identity_proof().cloned(),
            kind: PluginRuntimeTraceEventKind::Operational { kind: event.kind() },
        }
    }

    /// Adapts a proposal receipt after an owner boundary decision.
    #[must_use]
    pub fn proposal_receipt(receipt: &PluginBufferEditProposalReceipt) -> Self {
        Self::scoped(
            receipt.source_identity_proof().clone(),
            PluginRuntimeTraceEventKind::ProposalReceipt {
                receipt: PluginRuntimeTraceProposalReceipt::from(receipt),
            },
        )
    }

    /// Returns the attributed plugin identity for display and serialization.
    #[must_use]
    pub fn identity(&self) -> Option<&str> {
        self.identity_proof().map(PluginIdentity::as_str)
    }

    /// Returns the attributed identity proof, if this event has one.
    #[must_use]
    pub const fn identity_proof(&self) -> Option<&PluginIdentity> {
        self.identity.as_ref()
    }

    /// Returns the redacted trace payload.
    #[must_use]
    pub const fn kind(&self) -> &PluginRuntimeTraceEventKind {
        &self.kind
    }

    /// Returns the top-level trace event class.
    #[must_use]
    pub const fn class(&self) -> PluginRuntimeTraceEventClass {
        self.kind.class()
    }

    /// Builds an identity-scoped trace event.
    const fn scoped(identity: PluginIdentity, kind: PluginRuntimeTraceEventKind) -> Self {
        Self {
            identity: Some(identity),
            kind,
        }
    }

    /// Builds a trace event for discarded unpublished update work.
    const fn discarded_update_work(
        identity: PluginIdentity,
        discarded_effects: usize,
        discarded_workspace_requests: usize,
        discarded_workspace_observe_tasks: usize,
    ) -> Self {
        Self::scoped(
            identity,
            PluginRuntimeTraceEventKind::UpdateDiscarded {
                discarded_effects,
                discarded_workspace_requests,
                discarded_workspace_observe_tasks,
            },
        )
    }
}

impl Display for PluginRuntimeTraceEvent {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
        match self.identity() {
            Some(identity) => write!(formatter, "plugin {identity:?} trace {}", self.kind),
            None => write!(formatter, "plugin trace {}", self.kind),
        }
    }
}

impl From<&DrainedPluginEffectReport> for PluginRuntimeTraceEvent {
    fn from(report: &DrainedPluginEffectReport) -> Self {
        Self::drained_effects(report)
    }
}

impl From<&PluginHostImportDiscardReport> for PluginRuntimeTraceEvent {
    fn from(report: &PluginHostImportDiscardReport) -> Self {
        Self::update_discarded(report)
    }
}

impl From<&PluginHostOwnerDiscardReport> for PluginRuntimeTraceEvent {
    fn from(report: &PluginHostOwnerDiscardReport) -> Self {
        Self::owner_work_discarded(report)
    }
}

impl From<&PluginEffectDiscardReport> for PluginRuntimeTraceEvent {
    fn from(report: &PluginEffectDiscardReport) -> Self {
        Self::effects_discarded(report)
    }
}

impl From<&PluginWorkspaceIoDiscardReport> for PluginRuntimeTraceEvent {
    fn from(report: &PluginWorkspaceIoDiscardReport) -> Self {
        Self::workspace_io_discarded(report)
    }
}

impl From<&PluginWorkspaceObserveTaskDiscardReport> for PluginRuntimeTraceEvent {
    fn from(report: &PluginWorkspaceObserveTaskDiscardReport) -> Self {
        Self::workspace_observe_tasks_discarded(report)
    }
}

#[cfg(feature = "plugin-runtime")]
impl From<&WasmtimeWorkspaceObserveTaskScheduleDiscardReport> for PluginRuntimeTraceEvent {
    fn from(report: &WasmtimeWorkspaceObserveTaskScheduleDiscardReport) -> Self {
        Self::workspace_observe_task_schedule_discarded(report)
    }
}

impl From<&PluginWorkspaceIoReport> for PluginRuntimeTraceEvent {
    fn from(report: &PluginWorkspaceIoReport) -> Self {
        Self::workspace_io_completed(report)
    }
}

impl From<&PluginWorkspaceIoCancellationReport> for PluginRuntimeTraceEvent {
    fn from(report: &PluginWorkspaceIoCancellationReport) -> Self {
        Self::workspace_io_canceled(report)
    }
}

impl From<&PluginWorkspaceObserveTaskCompletion> for PluginRuntimeTraceEvent {
    fn from(completion: &PluginWorkspaceObserveTaskCompletion) -> Self {
        Self::workspace_observe_task_completed(completion)
    }
}

impl From<&PluginWorkspaceObserveTaskCancellationReport> for PluginRuntimeTraceEvent {
    fn from(report: &PluginWorkspaceObserveTaskCancellationReport) -> Self {
        Self::workspace_observe_tasks_canceled(report)
    }
}

impl From<&PluginOperationalEvent> for PluginRuntimeTraceEvent {
    fn from(event: &PluginOperationalEvent) -> Self {
        Self::operational(event)
    }
}

impl From<&PluginBufferEditProposalReceipt> for PluginRuntimeTraceEvent {
    fn from(receipt: &PluginBufferEditProposalReceipt) -> Self {
        Self::proposal_receipt(receipt)
    }
}

/// Top-level trace event class.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PluginRuntimeTraceEventClass {
    /// Effects drained into owner requests.
    EffectsDrained,
    /// Unpublished update work was discarded.
    UpdateDiscarded,
    /// Workspace I/O completed after successful guest return.
    WorkspaceIoCompleted,
    /// Workspace I/O canceled before filesystem-policy execution.
    WorkspaceIoCanceled,
    /// Workspace observation task completed for guest polling.
    WorkspaceObserveTaskCompleted,
    /// Workspace observation task state canceled before guest delivery.
    WorkspaceObserveTasksCanceled,
    /// Runtime operational event.
    Operational,
    /// Proposal receipt from an owner decision.
    ProposalReceipt,
}

impl PluginRuntimeTraceEventClass {
    /// Stable trace class text.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::EffectsDrained => "effects-drained",
            Self::UpdateDiscarded => "update-discarded",
            Self::WorkspaceIoCompleted => "workspace-io-completed",
            Self::WorkspaceIoCanceled => "workspace-io-canceled",
            Self::WorkspaceObserveTaskCompleted => "workspace-observe-task-completed",
            Self::WorkspaceObserveTasksCanceled => "workspace-observe-tasks-canceled",
            Self::Operational => "operational",
            Self::ProposalReceipt => "proposal-receipt",
        }
    }
}

impl Display for PluginRuntimeTraceEventClass {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
        formatter.write_str(self.as_str())
    }
}

/// Redacted plugin runtime trace payload.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum PluginRuntimeTraceEventKind {
    /// Effects drained into typed owner requests.
    EffectsDrained {
        /// Ordered drained effects.
        effects: Vec<PluginRuntimeTraceEffect>,
    },
    /// Unpublished update work was discarded.
    UpdateDiscarded {
        /// Editor effects discarded.
        discarded_effects: usize,
        /// Workspace I/O requests discarded.
        discarded_workspace_requests: usize,
        /// Workspace observation task requests discarded.
        discarded_workspace_observe_tasks: usize,
    },
    /// Workspace I/O report after filesystem-policy execution.
    WorkspaceIoCompleted {
        /// Ordered workspace completions.
        completions: Vec<PluginRuntimeTraceWorkspaceIoCompletion>,
    },
    /// Workspace I/O removed before filesystem-policy execution.
    WorkspaceIoCanceled {
        /// Queued sealed batches removed.
        canceled_batches: usize,
        /// Workspace operations removed.
        canceled_requests: usize,
    },
    /// Workspace observation task result retained for guest polling.
    WorkspaceObserveTaskCompleted {
        /// Identity-scoped redacted completion shape.
        completion: PluginWorkspaceObserveTaskCompletionShape,
    },
    /// Workspace observation task state removed before guest delivery.
    WorkspaceObserveTasksCanceled {
        /// Pending reads removed before filesystem policy.
        canceled_pending: usize,
        /// Retained outcomes discarded before guest delivery.
        discarded_retained: usize,
    },
    /// Operational event projection.
    Operational {
        /// Closed operational event kind.
        kind: PluginOperationalEventKind,
    },
    /// Proposal receipt projection.
    ProposalReceipt {
        /// Redacted receipt.
        receipt: PluginRuntimeTraceProposalReceipt,
    },
}

impl PluginRuntimeTraceEventKind {
    /// Returns the top-level trace event class.
    #[must_use]
    pub const fn class(&self) -> PluginRuntimeTraceEventClass {
        match self {
            Self::EffectsDrained { .. } => PluginRuntimeTraceEventClass::EffectsDrained,
            Self::UpdateDiscarded { .. } => PluginRuntimeTraceEventClass::UpdateDiscarded,
            Self::WorkspaceIoCompleted { .. } => PluginRuntimeTraceEventClass::WorkspaceIoCompleted,
            Self::WorkspaceIoCanceled { .. } => PluginRuntimeTraceEventClass::WorkspaceIoCanceled,
            Self::WorkspaceObserveTaskCompleted { .. } => {
                PluginRuntimeTraceEventClass::WorkspaceObserveTaskCompleted
            }
            Self::WorkspaceObserveTasksCanceled { .. } => {
                PluginRuntimeTraceEventClass::WorkspaceObserveTasksCanceled
            }
            Self::Operational { .. } => PluginRuntimeTraceEventClass::Operational,
            Self::ProposalReceipt { .. } => PluginRuntimeTraceEventClass::ProposalReceipt,
        }
    }
}

impl Display for PluginRuntimeTraceEventKind {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::EffectsDrained { effects } => {
                write!(formatter, "effects-drained effects=[")?;
                write_list(formatter, effects)?;
                formatter.write_str("]")
            }
            Self::UpdateDiscarded {
                discarded_effects,
                discarded_workspace_requests,
                discarded_workspace_observe_tasks,
            } => write!(
                formatter,
                "update-discarded effects={discarded_effects} workspace_io={discarded_workspace_requests} workspace_observe_tasks={discarded_workspace_observe_tasks}"
            ),
            Self::WorkspaceIoCompleted { completions } => {
                write!(formatter, "workspace-io-completed completions=[")?;
                write_list(formatter, completions)?;
                formatter.write_str("]")
            }
            Self::WorkspaceIoCanceled {
                canceled_batches,
                canceled_requests,
            } => write!(
                formatter,
                "workspace-io-canceled batches={canceled_batches} requests={canceled_requests}"
            ),
            Self::WorkspaceObserveTaskCompleted { completion } => {
                let task_id = completion.task_id();
                let outcome =
                    PluginRuntimeTraceWorkspaceObserveTaskOutcome::from(completion.outcome_shape());
                write!(
                    formatter,
                    "workspace-observe-task-completed task_id={task_id} outcome={outcome}"
                )
            }
            Self::WorkspaceObserveTasksCanceled {
                canceled_pending,
                discarded_retained,
            } => write!(
                formatter,
                "workspace-observe-tasks-canceled pending={canceled_pending} retained={discarded_retained}"
            ),
            Self::Operational { kind } => write!(formatter, "operational {}", Operational(kind)),
            Self::ProposalReceipt { receipt } => write!(formatter, "proposal-receipt {receipt}"),
        }
    }
}