daemonic_error 1.0.0

use alloc::borrow::ToOwned;
use alloc::string::String;
use core::ops::Deref;
use daemonic_error::GlassParadox;
use crate::{Annotation, DaemonicEmission, DaemonicError, Glass, ObservationTier, Severity, Temporal, TopologySegment};
use crate::daemonic::observation::obs_states::Opaque;
use super::super::super::glass_flags::GlassFlags;
#[derive(Clone, Debug)]
pub struct Paradox<GLASS> {
	position: &'static TopologySegment,
	severity: Severity,
	tier: ObservationTier,
	annotation: Annotation,
	temporal: Temporal,
	absolute_payload: GLASS,
	asserted_payload: Option<GLASS>,
	flags: GlassFlags,
}
impl<GLASS> Paradox<GLASS> {
	pub fn new(absolute_payload: GLASS, asserted_payload: Option<GLASS>, position: &'static TopologySegment,
	           // flags: Option<GlassFlags>,
	) -> Self {
		Paradox {
			position,
			severity: Severity::Paradox,
			tier: ObservationTier::Composed,
			annotation: Annotation::None,
			temporal: Temporal::Current,
			absolute_payload,
			asserted_payload,
			// flags: (if flags.is_some() { flags.unwrap() } else { GlassFlags::paradox_defaults() }),
			flags: GlassFlags::paradox_defaults(),
		}
	}
	pub fn extract_flags(&self) -> GlassFlags { self.flags.clone() }
	/// Contradictory value paradox.
	/// "I got X but expected Y."
	pub fn contradiction(
		actual: GLASS,
		expected: GLASS,
		position: &'static TopologySegment,
		annotation: Annotation,
		flags: Option<GlassFlags>,
	) -> Self {
		Paradox {
			position,
			severity: Severity::Paradox,
			tier: ObservationTier::Composed,
			annotation,
			temporal: Temporal::Current,
			absolute_payload: actual,
			asserted_payload: Some(expected),
			flags: (if flags.is_some() { flags.unwrap() } else { GlassFlags::paradox_defaults() }),
		}
	}
	
	/// Existence paradox.
	/// "This exists but shouldn't."
	pub fn should_not_exist(
		exists: GLASS,
		position: &'static TopologySegment,
		annotation: Annotation,
		flags: Option<GlassFlags>,
	) -> Self {
		Paradox {
			position,
			severity: Severity::Paradox,
			tier: ObservationTier::Composed,
			annotation,
			temporal: Temporal::Current,
			absolute_payload: exists,
			asserted_payload: None,
			flags: (if flags.is_some() { flags.unwrap() } else { GlassFlags::paradox_defaults() }),
		}
	}
	
	/// What computation actually produced.
	pub fn actual(&self) -> &GLASS {
		&self.absolute_payload
	}
	
	/// What was expected, if anything.
	pub fn expected(&self) -> Option<&GLASS> {
		self.asserted_payload.as_ref()
	}
	
	/// Is this a "wrong value" or "shouldn't exist" paradox?
	pub fn is_existence_paradox(&self) -> bool {
		self.asserted_payload.is_none()
	}
	
	/// Classify as benign or dangerous.
	/// Requires external assessment, so returns the inputs for it.
	pub fn classification_inputs(&self) -> ParadoxInputs<GLASS> {
		todo!(" This code is not working like i fucking want it to and im done fucking with it for now \
		Dated: 2026-09-21 \
		Time Spent: 4 hours \
		Comments:FUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUCK")
		// let actual = Self::extract_owned_absolute_payload(<Paradox<GLASS> as Clone>::clone(&*self));
		// let expected = Self::extract_owned_asserted_payload(<Paradox<GLASS> as Clone>::clone(&*self));
		// // let actual = self.extract_referent_absolute_payload();
		// // let expected = self.extract_referent_asserted_payload();
		// let annotation = self.extract_annotation();
		// ParadoxInputs {
		// 	actual,
		// 	//todo fix this because this isnt correct but fuck it it works for now
		// 	expected,
		// 	annotation,
		// }
	}
	pub fn extract_position(&self) -> &'static TopologySegment {
		self.position
	}
	pub fn extract_position_label(&self) -> &str {
		self.position.label
	}
	pub fn extract_tier(&self) -> ObservationTier {
		self.tier
	}
	pub fn extract_annotation(&self) -> Annotation {
		self.annotation.clone()
	}
	pub fn extract_temporal(&self) -> Temporal {
		self.temporal
	}
	pub fn extract_absolute_payload(&self) -> &GLASS {
		&self.absolute_payload
	}
	/// if asserted payload observation present, returns it, else returns None
	pub fn query_asserted_payload(&self) -> Option<&GLASS> {
		self.extract_referent_asserted_payload()
	}
	/// This method seems redundant, but theres a reason for its existence, States declare their own severity
	/// as well as the label. One reason is due to a ton of shit already using severity, but also
	/// explicitness.
	/// The old Observation State struct had public fields and was generic by design, States should
	/// be equated with Severity.
	/// IE Severity == State == Severity
	/// So as an additional safety precaution, the new structures are no longer field public, constructors
	/// extract data and pass to the consumer. Call site declarations should reflect this.
	/// Use extractor functions, dont exfil field data.
	pub fn extract_severity(&self) -> Severity {
		self.severity
	}
	pub fn with_note(mut self, note: impl Into<String>) -> Self {
		self.annotation = Annotation::Note(note.into());
		self
		// Paradox {
		// 	position: &Self::extract_position(&self),
		// 	severity: Severity::Paradox,
		// 	tier: Self::extract_tier(&self),
		// 	annotation: Annotation::Note(note.into()),
		// 	temporal: Temporal::Current,
		// 	absolute_payload: self.absolute_payload,
		// 	asserted_payload: self.asserted_payload,
		// 	flags: self.extract_flags(),
		// }
	}
	pub fn with_suggestion(mut self, suggestion: impl Into<String>) -> Self {
		self.annotation = Annotation::Suggestion(suggestion.into());
		self
		// Paradox {
		// 	position: &Self::extract_position(&self),
		// 	severity: Severity::Paradox,
		// 	tier: Self::extract_tier(&self),
		// 	annotation: Annotation::Suggestion(suggestion.into()),
		// 	temporal: Temporal::Current,
		// 	absolute_payload: self.absolute_payload,
		// 	asserted_payload: self.asserted_payload,
		// 	flags: self.extract_flags(),
		// }
	}
	pub fn with_help(mut self, help: impl Into<String>) -> Self {
		self.annotation = Annotation::Suggestion(help.into());
		self
		// Paradox {
		// 	position: &Self::extract_position(&self),
		// 	severity: Severity::Paradox,
		// 	tier: Self::extract_tier(&self),
		// 	annotation: Annotation::Help(help.into()),
		// 	temporal: Temporal::Current,
		// 	absolute_payload: self.absolute_payload,
		// 	asserted_payload: self.asserted_payload,
		// 	flags: self.extract_flags(),
		// }
	}
	pub fn mutate_annotation(&mut self, a: Annotation) {
		self.annotation = a;
	}
	pub fn mutate_tier(mut self, tier: impl Into<ObservationTier>) -> Self {
		self.tier = tier.into();
		self
		// Self {
		// 	position: &self.position,
		// 	severity: self.severity,
		// 	tier,
		// 	annotation: self.annotation.clone(),
		// 	temporal: self.temporal,
		// 	absolute_payload: self.absolute_payload,
		// 	asserted_payload: self.asserted_payload,
		// 	flags: self.extract_flags(),
		// }
	}
	pub fn extract_referent_absolute_payload(&self) -> &GLASS {
		&self.absolute_payload
	}
	pub fn extract_owned_absolute_payload(self) -> GLASS {
		self.absolute_payload
	}
	pub fn extract_referent_asserted_payload(&self) -> Option<&GLASS> {
		self.asserted_payload.as_ref()
	}
	pub fn extract_owned_asserted_payload(self) -> Option<GLASS> {
		self.asserted_payload
	}
}
struct ParadoxInputs<GLASS> {
	actual: GLASS,
	expected: Option<GLASS>,
	annotation: Annotation,
}
impl<GLASS: Glass<Paradox<GLASS>> + Glass<GLASS>> GlassParadox<GLASS> for Paradox<GLASS>
	where
		GLASS: for<'error> DaemonicError<'error>,
{
	fn observations(&self) -> &[GLASS] {
		todo!()
	}
	fn contradiction_description(&self) -> &str {
		todo!()
	}
	
	fn collapse(self, chosen_index: usize) -> Option<GLASS> {
		todo!()
	}
	fn should_continue(&self) -> bool { false }
}
impl<GLASS> DaemonicError<'_> for Paradox<GLASS>
	where
		GLASS: for<'error> DaemonicError<'error>,
{
	fn emit(self) -> DaemonicEmission {
		todo!()
	}
	
	fn position(&self) -> &TopologySegment {
		self.extract_position()
	}
}
impl<GLASS> Glass<GLASS> for Paradox<GLASS> {
	type Anchor = TopologySegment;
	
	fn position(&self) -> &TopologySegment {
		self.extract_position()
	}
	
	fn severity(&self) -> Severity {
		self.extract_severity()
	}
	
	fn payload(&self) -> Option<&GLASS> {
		Some(self.extract_referent_absolute_payload())
	}
	
	fn into_payload(self) -> Option<GLASS>
		where
			Self: Sized,
			GLASS: Sized,
	{
		Some(self.extract_owned_absolute_payload())
	}
}