daemonic_error 0.1.0

//! Glass<GLASS> — The observation effect.
//!
//! Models a transition that produced (or failed to produce) a GLASS object (mirror).
//! GLASS is not inside the Glass. GLASS IS what was reflected through it.
//! The glass state describes what happened during the transition.
//!
//! Glass is the step, not the destination.
//! Meaning lives in the steps between nodes.
//!
//! # Glass as Pattern Matching Engine
//!
//! Glass<GLASS> is the type-level expression of a self-bootstrapping pattern matcher.
//! Every Glass implementation is a template. Every observation through Glass is a match
//! operation. Every match result is a new template. The system generates its own matching
//! patterns through operation.
//!
//! # Sizing Invariant
//!
//! Glass is FRAME AGNOSTIC with respect to sizing. Both Sized and Unsized types
//! can implement this trait. The `GLASS` type parameter carries no `Sized` bound.
//! Methods that require moving the payload by value (`into_payload`) are gated
//! behind `where Self: Sized`. This is not a limitation — it's correct behavior.
//! An unsized type's Glass can be observed but not consumed.
//!
//! If the Glass can only handle Sized OR Unsized objects but not both,
//! that is DESIGN FAILURE.
// pub use crate::daemonic::observation::display::*;
use alloc::string::{String, ToString};
use core::fmt::Pointer;
use core::ops::{ControlFlow, FromResidual, Try};
use crate::daemonic::{
	// Anchorable,
                      Daemonic, SymbolicAnchor, TopologySegment};
use crate::daemonic::{Anchor, AnchorDomainSet, TemporalAnchor};
use crate::{const_daemonic_hash, DaemonicError, AXIOM_OFFSET};
pub mod error;
pub mod states;
pub mod primitive_implementations;
pub mod daemonic_path_buffer;
pub use error::*;
use crate::daemonic::glass::daemonic_system_call::DaemonicSystemCall;
use crate::daemonic::TopologyAnchor;


// ═══════════════════════════════════════════════════════════════
// SEVERITY (Primary axis: match quality)
// ═══════════════════════════════════════════════════════════════

/// Primary axis: what survived the transition.
///
/// Severity is the MATCH QUALITY of the observation — how well the input
/// resolved against the Glass. Every Glass observation produces a Severity.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Severity {
	/// Perfect match. Payload guaranteed.
	Stable,
	/// Partial match with minor discrepancies. Payload present but annotated.
	Cracked,
	/// Partial match with significant loss. Payload may or may not be present.
	Fracture,
	/// The observation changed between measurements.
	Drift,
	/// The observation came back different from what was sent.
	Warp,
	/// Complete match failure. No usable payload.
	Shattered,
	/// This state should not exist. Physics/axiom violation.
	Impossible,
	/// Multiple contradictory but individually valid matches.
	Paradox,
	/// Match exists but cannot be observed from this reference frame.
	Opaque,
	/// Valid observation from a different temporal frame.
	Echo,
	/// Matching has not been attempted.
	Unknown,
}

// ═══════════════════════════════════════════════════════════════
// OBSERVATION TIER
// ═══════════════════════════════════════════════════════════════

/// At what abstraction tier was this observation made?
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ObservationTier {
	/// Cannot be broken down further. Finite, fully enumerable.
	Absolute,
	/// Conceptually atomic but substrate-decomposable. u8, i32, bool, char.
	Primitive,
	/// Structures composed from primitives. Most application types.
	Composed,
	/// Symbols that carry their own instruction logic. Glass states, errors.
	GlyphicExecutable,
}

// ═══════════════════════════════════════════════════════════════
// SUPPORTING ENUMS
// ═══════════════════════════════════════════════════════════════

/// What's attached to the observation
#[derive(Debug, Clone)]
pub enum Annotation {
	None,
	Note(String),
	Help(String),
	Suggestion(String),
	/// Sensitive annotation — redacted in serialized output
	Sensitive(String),
}

/// When did this observation originate relative to current frame
#[derive(Debug, Clone)]
pub enum Temporal {
	Current,
	Echo { original_tick: u64 },
	Drift { from_severity: Severity, to_severity: Severity },
}

impl Anchor for Temporal {
	fn anchor_domains(&self) -> AnchorDomainSet {
		AnchorDomainSet::TEMPORAL
	}
}

impl TemporalAnchor for Temporal {
	fn anchor_tick(&self) -> u64 {
		1
	}
}
/// Can the observer see through
#[derive(Debug, Clone)]
pub enum Accessibility {
	Clear,
	Opaque { reason: String },
}


/// One observation or contradictory multiples
#[derive(Debug, Clone, Copy)]
pub enum Consistency {
	Singular,
	Paradox,
}

/// Has fidelity been assessed
#[derive(Debug, Clone, Copy)]
pub enum Assessment {
	Assessed,
	Unknown,
}

/// What should the observer do
#[derive(Debug, Clone, Copy)]
pub enum FidelityAction {
	Continue,
	Attend,
	Warn,
	Halt,
	Abort,
	/// Emergency containment — destroy the Glass to prevent propagation.
	Drop,
}

// ═══════════════════════════════════════════════════════════════
// GLASS TRAIT
// ═══════════════════════════════════════════════════════════════

/// The core observation trait. Everything passes through Glass.
/// ```text
/// Glass ≅ ∀F. (Glass → F(Glass)) → F(Glass)
/// ```
pub trait Glass<GLASS: ?Sized>:
// ?Send
// + ?Sync
// + DaemonicSystemCall
{
	type Anchor: TopologyAnchor;
	// ── Axes (what happened during this transition) ─────
	
	fn position(&self) -> &TopologySegment;
	fn severity(&self) -> Severity;
	
	fn annotation(&self) -> Annotation {
		Annotation::None
	}
	
	fn temporal(&self) -> Temporal {
		Temporal::Current
	}
	
	fn accessibility(&self) -> Accessibility {
		Accessibility::Clear
	}
	
	fn consistency(&self) -> Consistency {
		Consistency::Singular
	}
	
	fn assessment(&self) -> Assessment {
		Assessment::Unknown
	}
	
	fn tier(&self) -> ObservationTier {
		ObservationTier::Composed
	}
	
	// ── Payload (what resulted from this transition) ────
	
	fn payload(&self) -> Option<&GLASS>;
	
	fn into_payload(self) -> Option<GLASS>
		where
			Self: Sized,
			GLASS: Sized;
	
	// ── Derived (free, computed from axes) ──────────────
	
	fn fidelity_action(&self) -> FidelityAction {
		severity_to_fidelity(self.severity())
	}
	
	fn has_payload(&self) -> bool {
		self.payload().is_some()
	}
	
	fn is_clear(&self) -> bool {
		matches!(self.severity(), Severity::Stable)
			&& matches!(self.assessment(), Assessment::Assessed)
	}
	
	// ── Reporting (type-erased observation export) ──────
	
	fn as_report(&self) -> GlassReport {
		GlassReport {
			position: self.position().clone(),
			severity: self.severity(),
			tier: self.tier(),
			annotation: self.annotation(),
			temporal: self.temporal(),
			accessibility: self.accessibility(),
			consistency: self.consistency(),
			assessment: self.assessment(),
			fidelity_action: self.fidelity_action(),
		}
	}
}

/// Map severity to fidelity action.
pub fn severity_to_fidelity(severity: Severity) -> FidelityAction {
	match severity {
		Severity::Stable => FidelityAction::Continue,
		Severity::Cracked => FidelityAction::Warn,
		Severity::Fracture => FidelityAction::Halt,
		Severity::Warp => FidelityAction::Halt,
		Severity::Shattered => FidelityAction::Halt,
		Severity::Impossible => FidelityAction::Abort,
		Severity::Unknown => FidelityAction::Attend,
		Severity::Drift => FidelityAction::Attend,
		Severity::Paradox => FidelityAction::Warn,
		Severity::Opaque => FidelityAction::Halt,
		Severity::Echo => FidelityAction::Attend,
	}
}

// ═══════════════════════════════════════════════════════════════
// GLASS REPORT (type-erased observation)
// ═══════════════════════════════════════════════════════════════

/// Type-erased Glass observation report.
/// Contains all observation AXES but not the PAYLOAD.
/// Universal exchange format for Glass observations.
// #[derive(Debug, Clone)]
pub struct GlassReport {
	pub position: TopologySegment,
	pub severity: Severity,
	pub tier: ObservationTier,
	pub annotation: Annotation,
	pub temporal: Temporal,
	pub accessibility: Accessibility,
	pub consistency: Consistency,
	pub assessment: Assessment,
	pub fidelity_action: FidelityAction,
}

impl GlassReport {
	pub fn is_clear(&self) -> bool {
		matches!(self.severity, Severity::Stable)
			&& matches!(self.assessment, Assessment::Assessed)
	}
	
	pub fn needs_attention(&self) -> bool {
		!matches!(self.fidelity_action, FidelityAction::Continue)
	}
	
	pub fn category(&self) -> &str {
		todo!(
			"GlassReport::category() is not yet implemented"
		)
	}
}

// ═══════════════════════════════════════════════════════════════
// GLASS STATE TRAITS
// ═══════════════════════════════════════════════════════════════

/// Guaranteed payload — Stable ALWAYS has a value.
pub use states::*;
/// Clear glass. Payload guaranteed. Passthrough.
///
/// Types implementing GlassStable are making a compile-time
/// promise: there IS a value here. Not Option. Not maybe.
/// The transition succeeded fully.
pub use {GlassStable, StableAnnotation};
/// Damaged but contained. Non-propagating.
/// The crack exists but isn't spreading.
/// Key property: can_cascade returns false.
pub use {GlassCracked, CrackedAnnotation};
/// Information lost. Structure holds but data is incomplete.
/// Unlike Cracked, Fracture CAN cascade.
pub use {GlassFracture, FractureAnnotation};
/// Total information loss. Nothing came through.
/// The glass absorbed everything.
/// May carry debris — fragments that can be inspected
/// but not used as values.
pub use {GlassShattered, ShatteredAnnotation};
/// Unassessed observation. Fidelity genuinely unknown.
/// Payload may or may not exist.
/// Not an error — just hasn't been evaluated yet.
/// Resolution: re-observe with more context.
pub use {GlassUnknown, UnknownAnnotation};
/// Temporally displaced observation.
/// Data may be perfect but it's from a different time.
/// The reflection arrived late.
pub use {GlassEcho, EchoAnnotation};
/// Should not exist. Medium or observer is broken.
/// Propagation ceiling exceeded. Laws violated.
/// If you're holding this, something is deeply wrong
/// and it's not the data — it's the system.
/// Impossible (hard): The state CANNOT be constructed. The type system prevents it. 
/// If you're holding an Impossible, a language invariant broke — the compiler failed to prevent something it should have prevented. 
/// This is a substrate-level failure. The entity didn't do anything wrong. The floor fell out from under it. 
/// The correct response is Broken Sword — document everything and terminate, 
/// because the system's guarantees have been violated and nothing can be trusted.
/// Paradox (soft impossible): The state LOOKS impossible from the current reference 
/// frame but might be valid from another frame. Incomplete context produces apparent 
/// impossibility. Two observations that each survive adversarial testing independently but 
/// contradict each other. This isn't a substrate failure — it's an information failure. The
/// correct response is Attend, not Abort. Gather more context. Check other frames. The paradox
/// might resolve with additional observation.
pub use {GlassImpossible, ImpossibleAnnotation};
/// Faithful but uninterpretable by current observer.
/// Information exists behind the glass but can't be seen through.
/// The Black glass protocol's external face.
pub use {GlassOpaque, OpaqueAnnotation};
/// Irreversible transformation. State cannot be trusted.
/// What came back is not what was sent.
/// Non-reversible by definition.
pub use {GlassWarp, WarpAnnotation};
/// glass state changed during observation.
/// The observation is smeared across a fidelity transition.
/// Need both the starting and ending state to interpret.
pub use {GlassDrift, DriftAnnotation};
// use libc::libc::c_int;
use crate::daemonic::topology::TOPOLOGY_ANCHOR;
// ═══════════════════════════════════════════════════════════════
// CONCRETE OBSERVATION TYPE
// ═══════════════════════════════════════════════════════════════

/// A generic struct representing an observation. It holds information about 
/// the observation's position, severity, tier, annotation, temporal context, 
/// and an optional payload containing additional data.
///
/// # Type Parameters
/// - `GLASS`: A generic type representing the payload data associated with the 
///   observation. This can be used to store additional information specific to 
///   the observation's context or domain.
///
/// # Fields
/// - `position` (`Position`): The spatial information or location associated 
///   with the observation.
/// - `severity` (`Severity`): A measure of the seriousness or importance of 
///   the observation.
/// - `tier` (`ObservationTier`): The classification or level of the observation, 
///   providing additional contextual grouping.
/// - `annotation` (`Annotation`): Any textual notes or metadata that further 
///   detail or explain the observation.
/// - `temporal` (`Temporal`): The time-related information or timestamp 
///   describing when the observation occurred or applies.
/// - `payload` (`Option<GLASS>`): Optional additional data related to the 
///   observation, which can be of any type determined by the `GLASS` parameter.
pub struct Observation<GLASS> {
	pub position: &'static TopologySegment,
	pub severity: Severity,
	pub tier: ObservationTier,
	pub annotation: Annotation,
	pub temporal: Temporal,
	pub payload: Option<GLASS>,
}

impl<GLASS> Observation<GLASS> {
	pub(crate) fn to_errno(&self) -> i32 {
		0i32
		// todo fix this
		// escalated observations store negative syscall return
		// negate to get positive errno
		// -(self.payload.unwrap_or(0)) as i32
		
	}
}


/// Observation implements Try so ? works in formatting chains.
/// Stable/Cracked → Continue (formatting succeeded, proceed).
/// Everything else → Break (formatting failed, propagate).
impl<GLASS> Try for Observation<GLASS> {
	type Output = GLASS;
	type Residual = Observation<core::convert::Infallible>;
	
	fn from_output(output: Self::Output) -> Self {
		Observation::stable(output, &TopologySegment::new(&"Daemonic::Glass::Try::stable"))
	}
	
	fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
		match self.severity {
			Severity::Stable | Severity::Cracked => {
				match self.payload {
					Some(value) => ControlFlow::Continue(value),
					None => ControlFlow::Break(Observation {
						position: self.position,
						severity: self.severity,
						tier: self.tier,
						annotation: self.annotation,
						temporal: self.temporal,
						payload: None,
					}),
				}
			}
			_ => ControlFlow::Break(Observation {
				position: self.position,
				severity: self.severity,
				tier: self.tier,
				annotation: self.annotation,
				temporal: self.temporal,
				payload: None,
			}),
		}
	}
}
impl<GLASS> FromResidual<Observation<core::convert::Infallible>> for Observation<GLASS> {
	fn from_residual(residual: Observation<core::convert::Infallible>) -> Self {
		Observation {
			position: residual.position,
			severity: residual.severity,
			tier: residual.tier,
			annotation: residual.annotation,
			temporal: residual.temporal,
			payload: None,
		}
	}
}

// Also implement FromResidual for Result interop
// so ? works on Result inside formatting functions
impl<GLASS> FromResidual<Result<core::convert::Infallible, core::fmt::Error>> for Observation<GLASS> {
	fn from_residual(_residual: Result<core::convert::Infallible, core::fmt::Error>) -> Self {
		Observation::shattered(
			&TopologySegment::new(&"Daemonic::Glass::Try::fmt_error")
		).with_note("std::fmt::Error converted to Glass")
	}
}
static OBSERVATION_TOPOLOGY_ANCH0R: TopologySegment = TopologySegment {
	label: "Daemonic::Glass::Observation<()>",
	hash: const_daemonic_hash(
		"Daemonic::Glass::Observation<()>".as_bytes(),
		AXIOM_OFFSET,
	),
	crypto_id: const_daemonic_hash("Daemonic::Glass::Observation<()>".as_bytes(), TOPOLOGY_ANCHOR),
	depth: 3u16,
};
impl<GLASS> Observation<GLASS> {
	/// Construct a Stable observation with payload
	pub fn stable(value: GLASS, position: &TopologySegment) -> Self {
		Self {
			//todo: unfuck this
			position: &OBSERVATION_TOPOLOGY_ANCH0R,
			severity: Severity::Stable,
			tier: ObservationTier::Composed,
			annotation: Annotation::None,
			temporal: Temporal::Current,
			payload: Some(value),
		}
	}
	pub fn cracked(value: Option<GLASS>, position: &TopologySegment) -> Self {
		Self {
			//todo: unfuck this
			position: &OBSERVATION_TOPOLOGY_ANCH0R,
			severity: Severity::Cracked,
			tier: ObservationTier::Composed,
			annotation: Annotation::None,
			temporal: Temporal::Current,
			payload: value,
		}
	}
	pub fn warp(value: Option<GLASS>, position: &TopologySegment) -> Self
		where
			Self: Sized,
	{
		Self {
			//todo: unfuck this
			position: &OBSERVATION_TOPOLOGY_ANCH0R,
			severity: Severity::Warp,
			tier: ObservationTier::Composed,
			annotation: Annotation::None,
			temporal: Temporal::Current,
			payload: value,
		}
	}
	pub fn drift(value: Option<GLASS>, position: &TopologySegment) -> Self
		where
			Self: Sized,
	{
		Self {
			//todo: unfuck this
			position: &OBSERVATION_TOPOLOGY_ANCH0R,
			severity: Severity::Drift,
			tier: ObservationTier::Composed,
			annotation: Annotation::None,
			temporal: Temporal::Current,
			payload: value,
		}
	}
	pub fn opaque(position: &TopologySegment) -> Self
		where
			Self: Sized,
	{
		Self {
			//todo: unfuck this
			position: &OBSERVATION_TOPOLOGY_ANCH0R,
			severity: Severity::Opaque,
			tier: ObservationTier::Composed,
			annotation: Annotation::None,
			temporal: Temporal::Current,
			payload: None,
		}
	}
	/// Construct a Shattered observation (no payload)
	pub fn shattered(position: &TopologySegment) -> Self
		where
			Self: Sized,
	{
		Self {
			//todo: unfuck this
			position: &OBSERVATION_TOPOLOGY_ANCH0R,
			severity: Severity::Shattered,
			tier: ObservationTier::Composed,
			annotation: Annotation::None,
			temporal: Temporal::Current,
			payload: None,
		}
	}
	
	/// Construct an Unknown observation (no payload)
	pub fn unknown(position: &TopologySegment) -> Self {
		Self {
			//todo: unfuck this
			position: &OBSERVATION_TOPOLOGY_ANCH0R,
			severity: Severity::Unknown,
			tier: ObservationTier::Composed,
			annotation: Annotation::None,
			temporal: Temporal::Current,
			payload: None,
		}
	}
	
	/// Construct with specific severity
	pub fn with_severity(severity: Severity, position: &TopologySegment) -> Self {
		Self {
			//todo: unfuck this
			position: &OBSERVATION_TOPOLOGY_ANCH0R,
			severity,
			tier: ObservationTier::Composed,
			annotation: Annotation::None,
			temporal: Temporal::Current,
			payload: None,
		}
	}
	
	/// Attach an annotation
	pub fn with_note(mut self, note: impl Into<String>) -> Self {
		self.annotation = Annotation::Note(note.into());
		self
	}
	
	/// Set the observation tier
	pub fn at_tier(mut self, tier: ObservationTier) -> Self {
		self.tier = tier;
		self
	}
	
	/// Set temporal state
	pub fn with_temporal(mut self, temporal: Temporal) -> Self {
		self.temporal = temporal;
		self
	}
}

// SAFETY: Observation is Send + Sync if GLASS is Send + Sync
// #[allow(unsafe_code)]
// unsafe impl<GLASS: Send> Send for Observation<GLASS> {}
// #[allow(unsafe_code)]
// unsafe impl<GLASS: Sync> Sync for Observation<GLASS> {}


#[allow(unsafe_code)]
unsafe impl<GLASS> DaemonicSystemCall for Observation<GLASS> {}

impl<GLASS> Glass<Observation<GLASS>> for Observation<GLASS>
	where
		GLASS: Glass<GLASS>,
{
	type Anchor = TopologySegment;

	fn position(&self) -> &TopologySegment {
		&self.position
	}

	fn severity(&self) -> Severity {
		self.severity
	}

	fn annotation(&self) -> Annotation {
		self.annotation.clone()
	}

	fn temporal(&self) -> Temporal {
		self.temporal.clone()
	}

	fn tier(&self) -> ObservationTier {
		self.tier
	}

	fn payload(&self) -> Option<&Observation<GLASS>> {
		Some(self)
	}

	fn into_payload(self) -> Option<Observation<GLASS>> {
		Some(self)
	}
}

// ═══════════════════════════════════════════════════════════════
// BOUNDARY PROTOCOL (Glass ↔ Result/Option)
// ═══════════════════════════════════════════════════════════════

/// Convert Result to Glass observation (information-adding)
impl<T, E: core::fmt::Display> From<Result<T, E>> for Observation<T> {
	fn from(result: Result<T, E>) -> Self {
		match result {
			Ok(value) => Observation::stable(value, &TopologySegment::new("Daemonic::Glass::Boundary::Ok")),
			Err(e) => Observation::shattered(&TopologySegment::new("Daemonic::Glass::Boundary::Err"))
				.with_note(e.to_string()),
		}
	}
}

/// Convert Option to Glass observation (None = Unknown)
impl<T> From<Option<T>> for Observation<T> {
	fn from(opt: Option<T>) -> Self {
		match opt {
			Some(value) => Observation::stable(value, &TopologySegment::new("Daemonic::Glass::Boundary::Option::Some")),
			None => Observation::unknown(&TopologySegment::new("Daemonic::Glass::Boundary::Option::None")),
		}
	}
}

pub(crate) mod daemonic_system_call;