use std::sync::Arc;
use unityrs_core::env::{Environment, resource_candidates};
use unityrs_core::files::{BundleFile, File, ParentKind, SerializedFile};
use unityrs_core::limits::{ChargeError, Meter};
use unityrs_core::pystr::{lower_eq, ntpath_basename, simplify_name_vec};
use unityrs_core::{Bytes, RawStr};
#[derive(Clone, Debug)]
pub struct Stream {
pub path: RawStr,
pub offset: i128,
pub size: i128,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Span {
Range(u64, u64),
Slice(i128, i128),
}
impl Stream {
#[must_use]
pub fn span(&self) -> Span {
if self.size == 0 {
return Span::Range(0, 0);
}
if self.size == -1 {
return Span::Slice(self.offset, i128::MAX);
}
let end = self.offset.checked_add(self.size);
match (
u64::try_from(self.offset),
u64::try_from(self.size),
end.and_then(|e| u64::try_from(e).ok()),
) {
(Ok(o), Ok(n), Some(_)) => Span::Range(o, n),
_ => Span::Slice(self.offset, end.unwrap_or(i128::MAX)),
}
}
}
#[must_use]
pub fn python_slice(len: usize, start: i128, stop: i128) -> std::ops::Range<usize> {
let n = i128::try_from(len).unwrap_or(i128::MAX);
let at = |i: i128| {
let i = if i < 0 { i.saturating_add(n) } else { i };
usize::try_from(i.clamp(0, n)).unwrap_or(len)
};
let (a, b) = (at(start), at(stop));
a..b.max(a)
}
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error(transparent)]
Charge(#[from] ChargeError),
#[error("texture data: {0}")]
Data(#[source] unityrs_core::Error),
#[error("texture resource: {error}")]
Resource {
#[source]
error: unityrs_core::Error,
path: RawStr,
},
#[error("texture resource is a SerializedFile")]
Serialized,
#[error("texture resource is a WebFile")]
Web,
}
pub trait Hooks {
type Error;
fn probe<T>(&self, f: impl FnOnce() -> Result<T, Error>) -> Result<T, Self::Error>
where
Self: Sized;
fn env_call<T>(&self, f: impl FnOnce() -> Result<T, Error>) -> Result<T, Self::Error>
where
Self: Sized;
fn row_error(&self, error: Error) -> Self::Error;
}
struct Direct;
impl Hooks for Direct {
type Error = Error;
fn probe<T>(&self, f: impl FnOnce() -> Result<T, Error>) -> Result<T, Error> {
f()
}
fn env_call<T>(&self, f: impl FnOnce() -> Result<T, Error>) -> Result<T, Error> {
f()
}
fn row_error(&self, error: Error) -> Error {
error
}
}
fn parent_bundle(kind: Option<&ParentKind>) -> Option<Arc<BundleFile>> {
match kind? {
ParentKind::Bundle { bundle, .. } => bundle.upgrade(),
ParentKind::Web { .. } => None,
}
}
fn read_span(s: &Stream) -> (u64, u64, Option<(i128, i128)>) {
match s.span() {
Span::Range(offset, size) => (offset, size, None),
Span::Slice(start, stop) => (0, u64::MAX, Some((start, stop))),
}
}
fn sliced(bytes: Bytes, slice: Option<(i128, i128)>) -> Bytes {
match slice {
None => bytes,
Some((start, stop)) => bytes.slice(python_slice(bytes.len(), start, stop)),
}
}
fn own_chain<H: Hooks>(
from: &SerializedFile,
s: &Stream,
meter: &Arc<Meter>,
hooks: &H,
) -> Result<Option<Bytes>, H::Error> {
let work = |n: usize| {
hooks.probe(|| {
meter
.count_decode(u64::try_from(n).unwrap_or(u64::MAX))
.map_err(Error::Charge)
})
};
work(s.path.len())?;
for candidate in &resource_candidates(&s.path) {
work(candidate.len())?;
let name = hooks.probe(|| candidate.joined_vec(meter).map_err(Error::Charge))?;
let key =
hooks.probe(|| simplify_name_vec(name.as_slice(), meter).map_err(Error::Charge))?;
let mut container = parent_bundle(from.parent().map(|p| &p.kind));
while let Some(b) = container {
work(b.directory().len().saturating_add(1))?;
for (i, row) in b.directory().iter().enumerate().rev() {
work(row.path.len())?;
if !lower_eq(ntpath_basename(row.path.as_bytes()), key.as_slice()) {
continue;
}
match hooks.probe(|| b.entry(i).map_err(Error::Data))? {
File::Raw(_) => {
let (offset, size, slice) = read_span(s);
let bytes = hooks.probe(|| {
b.entry_range(i, offset..offset.saturating_add(size))
.map_err(Error::Data)
})?;
return Ok(Some(sliced(bytes, slice)));
}
File::Serialized(_) => return Err(hooks.row_error(Error::Serialized)),
File::Web(_) => return Err(hooks.row_error(Error::Web)),
File::Bundle(_) => {}
}
}
container = parent_bundle(b.parent().map(|p| &p.kind));
}
}
Ok(None)
}
pub fn fetch(
env: &Environment,
from: &Arc<SerializedFile>,
inline: &Bytes,
stream: Option<&Stream>,
meter: &Arc<Meter>,
) -> Result<Bytes, Error> {
fetch_with(env, from, inline, stream, meter, &Direct)
}
pub fn fetch_with<H: Hooks>(
env: &Environment,
from: &Arc<SerializedFile>,
inline: &Bytes,
stream: Option<&Stream>,
meter: &Arc<Meter>,
hooks: &H,
) -> Result<Bytes, H::Error> {
if !inline.is_empty() {
return Ok(inline.clone());
}
let Some(s) = stream.filter(|s| !s.path.is_empty()) else {
return Ok(Bytes::new());
};
if let Some(bytes) = own_chain(from, s, meter, hooks)? {
return Ok(bytes);
}
let (offset, size, slice) = read_span(s);
hooks.env_call(|| {
env.resource(from, &s.path, offset, size)
.map(|bytes| sliced(bytes, slice))
.map_err(|error| Error::Resource {
error,
path: s.path.clone(),
})
})
}
const _: () = crate::send_sync::<Stream>();
const _: () = crate::send_sync::<Span>();
const _: () = crate::send_sync::<Error>();
const _: () = crate::send_sync::<dyn Hooks<Error = Error> + Send + Sync>();