#![allow(missing_docs)]

//! Parse binary data

//!

//! The is module provides the basis for all font parsing in Allsorts. The parsing approach

//! is inspired by the paper,

//! [The next 700 data description languages](https://collaborate.princeton.edu/en/publications/the-next-700-data-description-languages) by Kathleen Fisher, Yitzhak Mandelbaum, David P. Walker.

use crate::binary::{I16Be, I32Be, I64Be, U16Be, U24Be, U32Be, U64Be, I8, U8};

use crate::error::ParseError;

use crate::layout::{LayoutCache, LayoutTableType};

use crate::{size, SafeFrom};

use std::borrow::Cow;

use std::cmp;

use std::cmp::Ordering;

// [azul web-lift] BTreeMap not HashMap for ReadCache: this cache (coverages/classdefs etc.) starts

// EMPTY (cap-0) and the FIRST insert during GSUB/GPOS shaping hits the lifted hashbrown EMPTY-INSERT

// mis-lift (reserve_rehash-from-0) → the remill-lifted web backend HANGS in shape_text. BTreeMap has

// no ctrl-group/empty-static → immune. Key is `usize` (Ord); entry API is identical.

use std::collections::btree_map::Entry;

use std::collections::BTreeMap;

use std::fmt;

use std::marker::PhantomData;

use std::sync::Arc;

#[derive(Debug, Copy, Clone)]

pub struct ReadEof {}

pub struct ReadBuf<'a> {

    data: Cow<'a, [u8]>,

}

#[derive(Copy, Clone, PartialEq)]

pub struct ReadScope<'a> {

    base: usize,

    data: &'a [u8],

}

pub struct ReadScopeOwned {

    base: usize,

    data: Box<[u8]>,

}

impl ReadScopeOwned {

}

#[derive(Clone)]

pub struct ReadCtxt<'a> {

    scope: ReadScope<'a>,

    offset: usize,

}

pub struct ReadCache<T> {

    map: BTreeMap<usize, Arc<T>>,

}

pub trait ReadBinary {

    type HostType<'a>: Sized; // default = Self

    fn read<'a>(ctxt: &mut ReadCtxt<'a>) -> Result<Self::HostType<'a>, ParseError>;

}

pub trait ReadBinaryDep {

    type Args<'a>: Copy;

    type HostType<'a>: Sized; // default = Self

    fn read_dep<'a>(

        ctxt: &mut ReadCtxt<'a>,

        args: Self::Args<'a>,

    ) -> Result<Self::HostType<'a>, ParseError>;

}

pub trait ReadFixedSizeDep: ReadBinaryDep {

    /// The number of bytes consumed by `ReadBinaryDep::read`.

    fn size(args: Self::Args<'_>) -> usize;

}

/// Read will always succeed if sufficient bytes are available.

pub trait ReadUnchecked {

    type HostType: Sized; // default = Self

    /// The number of bytes consumed by `read_unchecked`.

    const SIZE: usize;

    /// Must read exactly `SIZE` bytes.

    /// Unsafe as it avoids prohibitively expensive per-byte bounds checking.

    unsafe fn read_unchecked(ctxt: &mut ReadCtxt<'_>) -> Self::HostType;

}

pub trait ReadFrom {

    type ReadType: ReadUnchecked;

    fn read_from(value: <Self::ReadType as ReadUnchecked>::HostType) -> Self;

}

impl<T> ReadUnchecked for T

where

    T: ReadFrom,

{

    type HostType = T;

    const SIZE: usize = T::ReadType::SIZE;

}

impl<T> ReadBinary for T

where

    T: ReadUnchecked,

{

    type HostType<'a> = T::HostType;

        // Safe because we have `SIZE` bytes available.

}

impl<T> ReadBinaryDep for T

where

    T: ReadBinary,

{

    type Args<'a> = ();

    type HostType<'a> = T::HostType<'a>;

}

impl<T> ReadFixedSizeDep for T

where

    T: ReadUnchecked,

{

}

pub trait CheckIndex {

    fn check_index(&self, index: usize) -> Result<(), ParseError>;

}

/// Wrapper type for Debug impl of byte slices

pub(crate) struct DebugData<'a>(pub(crate) &'a [u8]);

pub struct ReadArray<'a, T: ReadFixedSizeDep> {

    scope: ReadScope<'a>,

    length: usize,

    stride: usize,

    args: T::Args<'a>,

}

impl<T: ReadFixedSizeDep> Clone for ReadArray<'_, T> {

}

impl<T: ReadFixedSizeDep> Copy for ReadArray<'_, T> {}

pub struct ReadArrayIter<'a, T: ReadUnchecked> {

    scope: ReadScope<'a>,

    index: usize,

    end: usize,

    stride: usize,

    phantom: PhantomData<T>,

}

pub struct ReadArrayDepIter<'a, 'b, T: ReadFixedSizeDep> {

    array: &'b ReadArray<'a, T>,

    index: usize,

}

#[derive(Clone)]

pub enum ReadArrayCow<'a, T>

where

    T: ReadUnchecked,

{

    Owned(Vec<T::HostType>),

    Borrowed(ReadArray<'a, T>),

}

pub struct ReadArrayCowIter<'a, 'b, T: ReadUnchecked> {

    array: &'b ReadArrayCow<'a, T>,

    index: usize,

}

impl<'a, T: ReadUnchecked> ReadArrayCow<'a, T> {

        }

        }

    {

        }

    {

        }

    // subarray and iter_res are not yet implemented

}

impl<T: ReadUnchecked> CheckIndex for ReadArrayCow<'_, T> {

        } else {

        }

}

impl<'a> ReadScope<'a> {

            } else {

            }

        } else {

        }

    {

            }

        }

    {

            }

        }

    {

}

impl fmt::Debug for ReadScope<'_> {

}

impl<T> ReadCache<T> {

}

impl<'a> ReadCtxt<'a> {

    /// ReadCtxt is constructed by calling `ReadScope::ctxt`.

        }

    /// Check a condition, returning `ParseError::BadIndex` if `false`.

    ///

    /// ```

    /// use allsorts::binary::read::ReadScope;

    /// use allsorts::error::ParseError;

    ///

    /// # fn main() -> Result<(), ParseError> {

    /// let ctxt = ReadScope::new(b"some data").ctxt();

    ///

    /// // Demonstration values

    /// let count = 3;

    /// let index = 1;

    /// ctxt.check_index(index < count)?;

    /// # Ok(())

    /// # }

    /// ```

        }

    /// Check a condition, returning `ParseError::BadVersion` if `false`.

    ///

    /// Intended for use in checking versions read from data. Example:

    ///

    /// ```

    /// use allsorts::binary::read::ReadScope;

    /// use allsorts::error::ParseError;

    ///

    /// let scope = ReadScope::new(&[0, 2]);

    /// let mut ctxt = scope.ctxt();

    /// let major_version = ctxt.read_u16be().expect("unable to read version");

    ///

    /// assert!(ctxt.check_version(major_version == 2).is_ok());

    /// assert_eq!(

    ///     ctxt.check_version(major_version == 1),

    ///     Err(ParseError::BadVersion)

    /// );

    /// ```

        }

        }

        // Safe because we have 1 byte available.

        // Safe because we have 1 byte available.

        // Safe because we have 2 bytes available.

        // Safe because we have 2 bytes available.

        // Safe because we have 4 bytes available.

        // Safe because we have 4 bytes available.

        // Safe because we have 8 bytes available.

        // Safe because we have 8 bytes available.

    /// Read up to and including the supplied nibble.

        } else {

        }

}

impl<'a> ReadBuf<'a> {

}

impl<'a> From<&'a [u8]> for ReadBuf<'a> {

}

impl<'a> From<Vec<u8>> for ReadBuf<'a> {

}

impl<'a, T: ReadFixedSizeDep> ReadArray<'a, T> {

        } else {

        }

    {

        } else {

        }

    {

    {

        }

    {

    // This is derived from the function on slice in the standard library

    {

        // INVARIANTS:

        // - 0 <= left <= left + size = right <= self.len()

        // - f returns Less for everything in self[..left]

        // - f returns Greater for everything in self[right..]

            // NOTE(unwrap): the while condition means `size` is strictly positive, so

            // `size/2 < size`. Thus `left + size/2 < left + size`, which

            // coupled with the `left + size <= self.len()` invariant means

            // we have `left + size/2 < self.len()`, and this is in-bounds.

            // SAFTEY: Safe because we have checked that we have `SIZE` bytes available in the

            // offset_length call.

            // let cmp = f(unsafe { self.get_unchecked(mid) });

            // The reason why we use if/else control flow rather than match

            // is because match reorders comparison operations, which is perf sensitive.

            // This is x86 asm for u8: https://rust.godbolt.org/z/8Y8Pra.

            }

        }

}

impl<T: ReadFixedSizeDep> CheckIndex for ReadArray<'_, T> {

        } else {

        }

}

impl<T> CheckIndex for Vec<T> {

        } else {

        }

}

impl<'a, T: ReadUnchecked> IntoIterator for &ReadArray<'a, T> {

    type Item = T::HostType;

    type IntoIter = ReadArrayIter<'a, T>;

}

impl<T: ReadUnchecked> Iterator for ReadArrayIter<'_, T> {

    type Item = T::HostType;

        // From the docs:

        // It is important to note that both back and forth work on the same range,

        // and do not cross: iteration is over when they meet in the middle.

        // SAFETY: Ok because we have (at least) `stride` bytes available and T::SIZE is <= stride.

}

impl<T: ReadUnchecked> DoubleEndedIterator for ReadArrayIter<'_, T> {

        // From the docs:

        // It is important to note that both back and forth work on the same range,

        // and do not cross: iteration is over when they meet in the middle.

        // SAFETY: Ok because we have (at least) `stride` bytes available and T::SIZE is <= stride.

}

impl<T: ReadUnchecked> ExactSizeIterator for ReadArrayIter<'_, T> {}

impl<'a, 'b, T: ReadUnchecked> IntoIterator for &'b ReadArrayCow<'a, T>

where

    T::HostType: Copy,

{

    type Item = T::HostType;

    type IntoIter = ReadArrayCowIter<'a, 'b, T>;

}

impl<T: ReadUnchecked> Iterator for ReadArrayCowIter<'_, '_, T>

where

    T::HostType: Copy,

{

    type Item = T::HostType;

        } else {

        }

}

impl<'a, T: ReadFixedSizeDep> Iterator for ReadArrayDepIter<'a, '_, T> {

    type Item = Result<T::HostType<'a>, ParseError>;

        } else {

        }

        } else {

        }

}

impl<'a, T: ReadUnchecked> ReadArray<'a, T> {

}

impl ReadUnchecked for U8 {

    type HostType = u8;

    const SIZE: usize = size::U8;

}

impl ReadUnchecked for I8 {

    type HostType = i8;

    const SIZE: usize = size::I8;

}

impl ReadUnchecked for U16Be {

    type HostType = u16;

    const SIZE: usize = size::U16;

}

impl ReadUnchecked for I16Be {

    type HostType = i16;

    const SIZE: usize = size::I16;

}

impl ReadUnchecked for U24Be {

    type HostType = u32;

    const SIZE: usize = size::U24;

}

impl ReadUnchecked for U32Be {

    type HostType = u32;

    const SIZE: usize = size::U32;

}

impl ReadUnchecked for I32Be {

    type HostType = i32;

    const SIZE: usize = size::I32;

}

impl ReadUnchecked for U64Be {

    type HostType = u64;

    const SIZE: usize = size::U64;

}

impl ReadUnchecked for I64Be {

    type HostType = i64;

    const SIZE: usize = size::I64;

}

impl<T1, T2> ReadUnchecked for (T1, T2)

where

    T1: ReadUnchecked,

    T2: ReadUnchecked,

{

    type HostType = (T1::HostType, T2::HostType);

    const SIZE: usize = T1::SIZE + T2::SIZE;

}

impl<T1, T2, T3> ReadUnchecked for (T1, T2, T3)

where

    T1: ReadUnchecked,

    T2: ReadUnchecked,

    T3: ReadUnchecked,

{

    type HostType = (T1::HostType, T2::HostType, T3::HostType);

    const SIZE: usize = T1::SIZE + T2::SIZE + T3::SIZE;

}

impl<T1, T2, T3, T4> ReadUnchecked for (T1, T2, T3, T4)

where

    T1: ReadUnchecked,

    T2: ReadUnchecked,

    T3: ReadUnchecked,

    T4: ReadUnchecked,

{

    type HostType = (T1::HostType, T2::HostType, T3::HostType, T4::HostType);

    const SIZE: usize = T1::SIZE + T2::SIZE + T3::SIZE + T4::SIZE;

}

impl<T> fmt::Debug for ReadArrayCow<'_, T>

where

    T: ReadUnchecked,

    <T as ReadUnchecked>::HostType: Copy + fmt::Debug,

{

}

impl<'a, T> fmt::Debug for ReadArray<'a, T>

where

    T: ReadFixedSizeDep,

    T::HostType<'a>: Copy + fmt::Debug,

{

        }

}

impl fmt::Debug for DebugData<'_> {

}

#[cfg(test)]

mod tests {

    use super::*;

    use crate::binary::write::{WriteBuffer, WriteContext};

    #[test]

    fn test_read_u24be() {

        let scope = ReadScope::new(&[1, 2, 3]);

        assert_eq!(scope.read::<U24Be>().unwrap(), 0x10203);

    }

    // Tests that offset_length does not panic when length is 0 but offset is out-of-bounds

    #[test]

    fn test_offset_length_oob() {

        let scope = ReadScope::new(&[1, 2, 3]);

        assert!(scope.offset_length(99, 0).is_ok());

    }

    #[test]

    fn double_ended_read_array_iter() {

        let numbers = [1i32, 2, 3, 4, 5, 6];

        let mut w = WriteBuffer::new();

        w.write_iter::<I32Be, _>(numbers.iter().copied()).unwrap();

        let data = w.into_inner();

        let array = ReadScope::new(&data).ctxt().read_array::<I32Be>(6).unwrap();

        let mut iter = array.iter();

        assert_eq!(Some(1), iter.next());

        assert_eq!(Some(6), iter.next_back());

        assert_eq!(Some(5), iter.next_back());

        assert_eq!(Some(2), iter.next());

        assert_eq!(Some(3), iter.next());

        assert_eq!(Some(4), iter.next());

        assert_eq!(None, iter.next());

        assert_eq!(None, iter.next_back());

    }

}