use super::sequents::Sequent;
use crate::limits::Limits;
use crate::linear::fragment::Mode;
use crate::linear::occurrences::{Forest, Member, Side, Written};
use crate::linear::proofs::interactive::Interactive as State;
use crate::linear::proofs::interactive::{PartTerm, Parts};
use crate::linear::proofs::{InfId, Inference, Named, Rule};
use crate::wire::{self, Readable};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
#[derive(Clone, Debug, Serialize, Deserialize)]
struct Step {
sequent: Vec<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
rule: Option<Named>,
#[serde(default, skip_serializing_if = "Option::is_none")]
principal: Option<usize>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
premises: Vec<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
cut: Option<u32>,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub(super) struct Interactive {
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "wire::version"
)]
version: Option<u32>,
sequent: Sequent,
mode: Mode,
inferences: Vec<Step>,
history: Vec<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
written: Option<WrittenForm>,
#[serde(default, skip_serializing_if = "Option::is_none")]
instances: Option<InstancesForm>,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
struct InstancesForm {
members: Vec<(u32, u32)>,
frames: Vec<(Option<u32>, u32)>,
terms: Vec<TermForm>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
metas: Vec<u32>,
eigens: u32,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
constants: Vec<u32>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
bindings: Vec<(u32, u32, u32)>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
marks: Vec<(u32, u32, u32, u32, u32, u32)>,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
enum TermForm {
#[serde(rename = "F")]
App(u32, Vec<u32>),
#[serde(rename = "E")]
Eigen(u32),
#[serde(rename = "M")]
Meta(u32),
}
impl From<Parts> for InstancesForm {
fn from(parts: Parts) -> Self {
Self {
members: parts.members,
frames: parts.frames,
terms: parts
.terms
.into_iter()
.map(|t| match t {
PartTerm::App(f, args) => TermForm::App(f, args),
PartTerm::Eigen(a) => TermForm::Eigen(a),
PartTerm::Meta(k) => TermForm::Meta(k),
})
.collect(),
metas: parts.metas,
eigens: parts.eigens,
constants: parts.constants,
bindings: parts.bindings,
marks: parts.marks,
}
}
}
impl From<InstancesForm> for Parts {
fn from(form: InstancesForm) -> Self {
Self {
members: form.members,
frames: form.frames,
terms: form
.terms
.into_iter()
.map(|t| match t {
TermForm::App(f, args) => PartTerm::App(f, args),
TermForm::Eigen(a) => PartTerm::Eigen(a),
TermForm::Meta(k) => PartTerm::Meta(k),
})
.collect(),
metas: form.metas,
eigens: form.eigens,
constants: form.constants,
bindings: form.bindings,
marks: form.marks,
}
}
}
#[derive(Clone, Debug, Serialize, Deserialize)]
struct WrittenForm {
inputs: Vec<u32>,
implications: Vec<u32>,
}
impl WrittenForm {
fn of(writing: &[Written]) -> Self {
let ids = |keep: fn(Written) -> bool| {
(0..writing.len() as u32)
.filter(|&o| keep(writing[o as usize]))
.collect()
};
Self {
inputs: ids(|w| w.side() == Side::Input),
implications: ids(Written::is_implication),
}
}
fn record(&self, len: usize) -> Result<Box<[Written]>, crate::Error> {
let mut writing = vec![Written::new(Side::Output, false); len];
for (list, implication) in [(&self.inputs, false), (&self.implications, true)] {
if !list.is_sorted_by(|a, b| a < b) {
return Err(crate::Error::InconsistentSession {
reason: "a list of the record is not ascending",
});
}
for &o in list {
let Some(written) = writing.get_mut(o as usize) else {
return Err(crate::Error::IndexOutOfBounds {
space: crate::limits::Space::Occurrence,
index: o as usize,
len,
});
};
*written = if implication {
Written::new(written.side(), true)
} else {
Written::new(Side::Input, written.is_implication())
};
}
}
Ok(writing.into_boxed_slice())
}
}
impl From<&State> for Interactive {
fn from(state: &State) -> Self {
Self {
version: Some(
wire::level_in(Some(state.mode())).max(wire::level_of_sequent(state.sequent())),
),
sequent: Sequent::from(state.sequent()),
mode: state.mode(),
inferences: state
.inferences()
.iter()
.map(|inference| Step {
sequent: inference.sequent.iter().map(|o| o.get()).collect(),
rule: (inference.rule.rule != Rule::Open).then_some(inference.rule),
principal: inference.principal,
premises: inference.premises.iter().map(|p| p.get()).collect(),
cut: inference.cut.map(Member::get),
})
.collect(),
history: state.history().iter().map(|id| id.get()).collect(),
written: state.writing().map(WrittenForm::of),
instances: state.parts().map(InstancesForm::from),
}
}
}
impl Interactive {
fn within(self, limits: &Limits) -> Result<State, crate::Error> {
let proxy = self;
let sequent = crate::linear::Sequent::try_from(proxy.sequent)?;
let forest = Forest::from_owned(sequent, limits)?;
let inferences = proxy
.inferences
.into_iter()
.map(|step| Inference {
sequent: step.sequent.into_iter().map(Member::new).collect(),
rule: step.rule.unwrap_or_else(|| Rule::Open.into()),
principal: step.principal,
premises: step.premises.into_iter().map(InfId::new).collect(),
times: 1,
cut: step.cut.map(Member::new),
node: None,
})
.collect();
let history = proxy.history.into_iter().map(InfId::new).collect();
let len = forest.len();
if let Some(instances) = &proxy.instances {
let entries = (instances.members.len() as u64)
.saturating_add(instances.frames.len() as u64)
.saturating_add(instances.terms.len() as u64);
if let Some(limit) = limits.terms
&& entries > limit
{
return Err(crate::Error::Refused(crate::limits::Refusal::Terms {
terms: entries,
limit,
}));
}
}
let parts = proxy.instances.map(Parts::from);
let mut state = State::from_parts(forest, proxy.mode, inferences, history, parts, limits)?;
if let Some(written) = proxy.written {
state.keep_writing(written.record(len)?)?;
}
Ok(state)
}
}
impl Serialize for State {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
Interactive::from(self).serialize(serializer)
}
}
impl<'a> Deserialize<'a> for State {
fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
Self::read(deserializer, &Limits::default())
}
}
impl crate::sealed::Readable for State {}
impl Readable for State {
const FORM: &'static str = "session";
fn read<'de, D: Deserializer<'de>>(deserializer: D, limits: &Limits) -> Result<Self, D::Error> {
Interactive::deserialize(deserializer)?
.within(limits)
.map_err(wire::fail)
}
}