work

[pspp] / rust / src / raw.rs

use crate::endian::{Endian, Parse, ToBytes};
use crate::{CategoryLabels, Compression, Error};

use flate2::read::ZlibDecoder;
use num::Integer;
use std::borrow::Cow;
use std::fmt::{Debug, Formatter, Result as FmtResult};
use std::str::from_utf8;
use std::{
    collections::VecDeque,
    io::{Error as IoError, Read, Seek, SeekFrom},
    iter::FusedIterator,
};

use self::state::State;

#[derive(Clone, Debug)]
pub enum Record {
    Header(Header),
    Variable(Variable),
    ValueLabel(ValueLabel),
    VarIndexes(VarIndexes),
    Document(Document),
    IntegerInfo(IntegerInfo),
    FloatInfo(FloatInfo),
    VariableSets(UnencodedString),
    VarDisplay(VarDisplayRecord),
    MultipleResponse(MultipleResponseRecord),
    LongStringValueLabels(LongStringValueLabelRecord),
    Encoding(EncodingRecord),
    NumberOfCases(NumberOfCasesRecord),
    ProductInfo(UnencodedString),
    LongNames(UnencodedString),
    LongStrings(UnencodedString),
    FileAttributes(UnencodedString),
    VariableAttributes(UnencodedString),
    TextExtension(TextExtension),
    OtherExtension(Extension),
    EndOfHeaders(u32),
    ZHeader(ZHeader),
    ZTrailer(ZTrailer),
    Case(Vec<Value>),
}

impl Record {
    fn read<R: Read + Seek>(reader: &mut R, endian: Endian) -> Result<Record, Error> {
        let rec_type: u32 = endian.parse(read_bytes(reader)?);
        match rec_type {
            2 => Ok(Record::Variable(Variable::read(reader, endian)?)),
            3 => Ok(Record::ValueLabel(ValueLabel::read(reader, endian)?)),
            4 => Ok(Record::VarIndexes(VarIndexes::read(reader, endian)?)),
            6 => Ok(Record::Document(Document::read(reader, endian)?)),
            7 => Ok(Extension::read(reader, endian)?),
            999 => Ok(Record::EndOfHeaders(endian.parse(read_bytes(reader)?))),
            _ => Err(Error::BadRecordType {
                offset: reader.stream_position()?,
                rec_type,
            }),
        }
    }
}

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

fn fallback_encode<'a>(s: &'a [u8]) -> Cow<'a, str> {
    if let Ok(s) = from_utf8(s) {
        s.into()
    } else {
        let s: String = s.iter().map(|c| char::from(*c)).collect();
        s.into()
    }
}

impl<'a> Debug for FallbackEncoding<'a> {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        if let Ok(s) = from_utf8(self.0) {
            let s = s.trim_end();
            write!(f, "\"{s}\"")
        } else {
            let s: String = self
                .0
                .iter()
                .map(|c| char::from(*c).escape_default())
                .flatten()
                .collect();
            let s = s.trim_end();
            write!(f, "\"{s}\"")
        }
    }
}

#[derive(Clone)]
pub struct Header {
    /// Magic number.
    pub magic: Magic,

    /// Eye-catcher string, product name, in the file's encoding.  Padded
    /// on the right with spaces.
    pub eye_catcher: [u8; 60],

    /// Layout code, normally either 2 or 3.
    pub layout_code: u32,

    /// Number of variable positions, or `None` if the value in the file is
    /// questionably trustworthy.
    pub nominal_case_size: Option<u32>,

    /// Compression type, if any,
    pub compression: Option<Compression>,

    /// 0-based variable index of the weight variable, or `None` if the file is
    /// unweighted.
    pub weight_index: Option<u32>,

    /// Claimed number of cases, if known.
    pub n_cases: Option<u32>,

    /// Compression bias, usually 100.0.
    pub bias: f64,

    /// `dd mmm yy` in the file's encoding.
    pub creation_date: [u8; 9],

    /// `HH:MM:SS` in the file's encoding.
    pub creation_time: [u8; 8],

    /// File label, in the file's encoding.  Padded on the right with spaces.
    pub file_label: [u8; 64],

    /// Endianness of the data in the file header.
    pub endian: Endian,
}

impl Header {
    fn debug_field<T: Debug>(&self, f: &mut Formatter, name: &str, value: T) -> FmtResult {
        writeln!(f, "{name:>17}: {:?}", value)
    }
}

impl Debug for Header {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        writeln!(f, "File header record:")?;
        self.debug_field(f, "Magic", self.magic)?;
        self.debug_field(f, "Product name", FallbackEncoding(&self.eye_catcher))?;
        self.debug_field(f, "Layout code", self.layout_code)?;
        self.debug_field(f, "Nominal case size", self.nominal_case_size)?;
        self.debug_field(f, "Compression", self.compression)?;
        self.debug_field(f, "Weight index", self.weight_index)?;
        self.debug_field(f, "Number of cases", self.n_cases)?;
        self.debug_field(f, "Compression bias", self.bias)?;
        self.debug_field(f, "Creation date", FallbackEncoding(&self.creation_date))?;
        self.debug_field(f, "Creation time", FallbackEncoding(&self.creation_time))?;
        self.debug_field(f, "File label", FallbackEncoding(&self.file_label))?;
        self.debug_field(f, "Endianness", self.endian)
    }
}

impl Header {
    fn read<R: Read>(r: &mut R) -> Result<Header, Error> {
        let magic: [u8; 4] = read_bytes(r)?;
        let magic: Magic = magic.try_into().map_err(|_| Error::NotASystemFile)?;

        let eye_catcher: [u8; 60] = read_bytes(r)?;
        let layout_code: [u8; 4] = read_bytes(r)?;
        let endian = Endian::identify_u32(2, layout_code)
            .or_else(|| Endian::identify_u32(2, layout_code))
            .ok_or_else(|| Error::NotASystemFile)?;
        let layout_code = endian.parse(layout_code);

        let nominal_case_size: u32 = endian.parse(read_bytes(r)?);
        let nominal_case_size =
            (nominal_case_size <= i32::MAX as u32 / 16).then_some(nominal_case_size);

        let compression_code: u32 = endian.parse(read_bytes(r)?);
        let compression = match (magic, compression_code) {
            (Magic::ZSAV, 2) => Some(Compression::ZLib),
            (Magic::ZSAV, code) => return Err(Error::InvalidZsavCompression(code)),
            (_, 0) => None,
            (_, 1) => Some(Compression::Simple),
            (_, code) => return Err(Error::InvalidSavCompression(code)),
        };

        let weight_index: u32 = endian.parse(read_bytes(r)?);
        let weight_index = (weight_index > 0).then(|| weight_index - 1);

        let n_cases: u32 = endian.parse(read_bytes(r)?);
        let n_cases = (n_cases < i32::MAX as u32 / 2).then_some(n_cases);

        let bias: f64 = endian.parse(read_bytes(r)?);

        let creation_date: [u8; 9] = read_bytes(r)?;
        let creation_time: [u8; 8] = read_bytes(r)?;
        let file_label: [u8; 64] = read_bytes(r)?;
        let _: [u8; 3] = read_bytes(r)?;

        Ok(Header {
            magic,
            layout_code,
            nominal_case_size,
            compression,
            weight_index,
            n_cases,
            bias,
            creation_date,
            creation_time,
            eye_catcher,
            file_label,
            endian,
        })
    }
}

#[derive(Copy, Clone, PartialEq, Eq, Hash)]
pub struct Magic([u8; 4]);

impl Magic {
    /// Magic number for a regular system file.
    pub const SAV: Magic = Magic(*b"$FL2");

    /// Magic number for a system file that contains zlib-compressed data.
    pub const ZSAV: Magic = Magic(*b"$FL3");

    /// Magic number for an EBDIC-encoded system file.  This is `$FL2` encoded
    /// in EBCDIC.
    pub const EBCDIC: Magic = Magic([0x5b, 0xc6, 0xd3, 0xf2]);
}

impl Debug for Magic {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        let s = match self {
            &Magic::SAV => "$FL2",
            &Magic::ZSAV => "$FL3",
            &Magic::EBCDIC => "($FL2 in EBCDIC)",
            _ => return write!(f, "{:?}", self.0),
        };
        write!(f, "{s}")
    }
}

impl TryFrom<[u8; 4]> for Magic {
    type Error = Error;

    fn try_from(value: [u8; 4]) -> Result<Self, Self::Error> {
        let magic = Magic(value);
        match magic {
            Magic::SAV | Magic::ZSAV | Magic::EBCDIC => Ok(magic),
            _ => Err(Error::BadMagic(value)),
        }
    }
}

#[derive(Copy, Clone, PartialEq, Eq, Hash)]
pub enum VarType {
    Number,
    String,
}

impl VarType {
    fn from_width(width: i32) -> VarType {
        match width {
            0 => VarType::Number,
            _ => VarType::String,
        }
    }
}

mod state {
    use super::{
        Compression, Error, Header, Record, Value, VarType, Variable, ZHeader, ZTrailer,
        ZlibDecodeMultiple,
    };
    use crate::endian::Endian;
    use std::{
        collections::VecDeque,
        io::{Read, Seek},
    };

    pub trait State {
        #[allow(clippy::type_complexity)]
        fn read(self: Box<Self>) -> Result<Option<(Record, Box<dyn State>)>, Error>;
    }

    struct Start<R: Read + Seek> {
        reader: R,
    }

    pub fn new<R: Read + Seek + 'static>(reader: R) -> Box<dyn State> {
        Box::new(Start { reader })
    }

    struct CommonState<R: Read + Seek> {
        reader: R,
        endian: Endian,
        bias: f64,
        compression: Option<Compression>,
        var_types: Vec<VarType>,
    }

    impl<R: Read + Seek + 'static> State for Start<R> {
        fn read(mut self: Box<Self>) -> Result<Option<(Record, Box<dyn State>)>, Error> {
            let header = Header::read(&mut self.reader)?;
            let next_state = Headers(CommonState {
                reader: self.reader,
                endian: header.endian,
                bias: header.bias,
                compression: header.compression,
                var_types: Vec::new(),
            });
            Ok(Some((Record::Header(header), Box::new(next_state))))
        }
    }

    struct Headers<R: Read + Seek>(CommonState<R>);

    impl<R: Read + Seek + 'static> State for Headers<R> {
        fn read(mut self: Box<Self>) -> Result<Option<(Record, Box<dyn State>)>, Error> {
            let record = Record::read(&mut self.0.reader, self.0.endian)?;
            match record {
                Record::Variable(Variable { width, .. }) => {
                    self.0.var_types.push(VarType::from_width(width));
                }
                Record::EndOfHeaders(_) => {
                    let next_state: Box<dyn State> = match self.0.compression {
                        None => Box::new(Data(self.0)),
                        Some(Compression::Simple) => Box::new(CompressedData::new(self.0)),
                        Some(Compression::ZLib) => Box::new(ZlibHeader(self.0)),
                    };
                    return Ok(Some((record, next_state)));
                }
                _ => (),
            };
            Ok(Some((record, self)))
        }
    }

    struct ZlibHeader<R: Read + Seek>(CommonState<R>);

    impl<R: Read + Seek + 'static> State for ZlibHeader<R> {
        fn read(mut self: Box<Self>) -> Result<Option<(Record, Box<dyn State>)>, Error> {
            let zheader = ZHeader::read(&mut self.0.reader, self.0.endian)?;
            Ok(Some((Record::ZHeader(zheader), self)))
        }
    }

    struct ZlibTrailer<R: Read + Seek>(CommonState<R>, ZHeader);

    impl<R: Read + Seek + 'static> State for ZlibTrailer<R> {
        fn read(mut self: Box<Self>) -> Result<Option<(Record, Box<dyn State>)>, Error> {
            let retval = ZTrailer::read(
                &mut self.0.reader,
                self.0.endian,
                self.1.ztrailer_offset,
                self.1.ztrailer_len,
            )?;
            let next_state = Box::new(CompressedData::new(CommonState {
                reader: ZlibDecodeMultiple::new(self.0.reader),
                endian: self.0.endian,
                bias: self.0.bias,
                compression: self.0.compression,
                var_types: self.0.var_types,
            }));
            match retval {
                None => next_state.read(),
                Some(ztrailer) => Ok(Some((Record::ZTrailer(ztrailer), next_state))),
            }
        }
    }

    struct Data<R: Read + Seek>(CommonState<R>);

    impl<R: Read + Seek + 'static> State for Data<R> {
        fn read(mut self: Box<Self>) -> Result<Option<(Record, Box<dyn State>)>, Error> {
            match Value::read_case(&mut self.0.reader, &self.0.var_types, self.0.endian)? {
                None => Ok(None),
                Some(values) => Ok(Some((Record::Case(values), self))),
            }
        }
    }

    struct CompressedData<R: Read + Seek> {
        common: CommonState<R>,
        codes: VecDeque<u8>,
    }

    impl<R: Read + Seek + 'static> CompressedData<R> {
        fn new(common: CommonState<R>) -> CompressedData<R> {
            CompressedData {
                common,
                codes: VecDeque::new(),
            }
        }
    }

    impl<R: Read + Seek + 'static> State for CompressedData<R> {
        fn read(mut self: Box<Self>) -> Result<Option<(Record, Box<dyn State>)>, Error> {
            match Value::read_compressed_case(
                &mut self.common.reader,
                &self.common.var_types,
                &mut self.codes,
                self.common.endian,
                self.common.bias,
            )? {
                None => Ok(None),
                Some(values) => Ok(Some((Record::Case(values), self))),
            }
        }
    }
}

#[derive(Copy, Clone)]
pub enum Value {
    Number(Option<f64>),
    String([u8; 8]),
}

impl Debug for Value {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        match self {
            Value::Number(Some(number)) => write!(f, "{number:?}"),
            Value::Number(None) => write!(f, "SYSMIS"),
            Value::String(bytes) => write!(f, "{:?}", FallbackEncoding(bytes)),
        }
    }
}

impl Value {
    fn read<R: Read>(r: &mut R, var_type: VarType, endian: Endian) -> Result<Value, IoError> {
        Ok(Self::from_raw(var_type, read_bytes(r)?, endian))
    }

    pub fn from_raw(var_type: VarType, raw: [u8; 8], endian: Endian) -> Value {
        match var_type {
            VarType::String => Value::String(raw),
            VarType::Number => {
                let number: f64 = endian.parse(raw);
                Value::Number((number != -f64::MAX).then_some(number))
            }
        }
    }

    fn read_case<R: Read + Seek>(
        reader: &mut R,
        var_types: &[VarType],
        endian: Endian,
    ) -> Result<Option<Vec<Value>>, Error> {
        let case_start = reader.stream_position()?;
        let mut values = Vec::with_capacity(var_types.len());
        for (i, &var_type) in var_types.iter().enumerate() {
            let Some(raw) = try_read_bytes(reader)? else {
                if i == 0 {
                    return Ok(None);
                } else {
                    let offset = reader.stream_position()?;
                    return Err(Error::EofInCase {
                        offset,
                        case_ofs: offset - case_start,
                        case_len: var_types.len() * 8,
                    });
                }
            };
            values.push(Value::from_raw(var_type, raw, endian));
        }
        Ok(Some(values))
    }

    fn read_compressed_case<R: Read + Seek>(
        reader: &mut R,
        var_types: &[VarType],
        codes: &mut VecDeque<u8>,
        endian: Endian,
        bias: f64,
    ) -> Result<Option<Vec<Value>>, Error> {
        let case_start = reader.stream_position()?;
        let mut values = Vec::with_capacity(var_types.len());
        for (i, &var_type) in var_types.iter().enumerate() {
            let value = loop {
                let Some(code) = codes.pop_front() else {
                    let Some(new_codes): Option<[u8; 8]> = try_read_bytes(reader)? else {
                        if i == 0 {
                            return Ok(None);
                        } else {
                            let offset = reader.stream_position()?;
                            return Err(Error::EofInCompressedCase {
                                offset,
                                case_ofs: offset - case_start,
                            });
                        }
                    };
                    codes.extend(new_codes.into_iter());
                    continue;
                };
                match code {
                    0 => (),
                    1..=251 => match var_type {
                        VarType::Number => break Value::Number(Some(code as f64 - bias)),
                        VarType::String => {
                            break Value::String(endian.to_bytes(code as f64 - bias))
                        }
                    },
                    252 => {
                        if i == 0 {
                            return Ok(None);
                        } else {
                            let offset = reader.stream_position()?;
                            return Err(Error::PartialCompressedCase {
                                offset,
                                case_ofs: offset - case_start,
                            });
                        }
                    }
                    253 => break Value::from_raw(var_type, read_bytes(reader)?, endian),
                    254 => match var_type {
                        VarType::String => break Value::String(*b"        "), // XXX EBCDIC
                        VarType::Number => {
                            return Err(Error::CompressedStringExpected {
                                offset: case_start,
                                case_ofs: reader.stream_position()? - case_start,
                            })
                        }
                    },
                    255 => match var_type {
                        VarType::Number => break Value::Number(None),
                        VarType::String => {
                            return Err(Error::CompressedNumberExpected {
                                offset: case_start,
                                case_ofs: reader.stream_position()? - case_start,
                            })
                        }
                    },
                }
            };
            values.push(value);
        }
        Ok(Some(values))
    }
}

struct ZlibDecodeMultiple<R>
where
    R: Read + Seek,
{
    reader: Option<ZlibDecoder<R>>,
}

impl<R> ZlibDecodeMultiple<R>
where
    R: Read + Seek,
{
    fn new(reader: R) -> ZlibDecodeMultiple<R> {
        ZlibDecodeMultiple {
            reader: Some(ZlibDecoder::new(reader)),
        }
    }
}

impl<R> Read for ZlibDecodeMultiple<R>
where
    R: Read + Seek,
{
    fn read(&mut self, buf: &mut [u8]) -> Result<usize, IoError> {
        loop {
            match self.reader.as_mut().unwrap().read(buf)? {
                0 => {
                    let inner = self.reader.take().unwrap().into_inner();
                    self.reader = Some(ZlibDecoder::new(inner));
                }
                n => return Ok(n),
            };
        }
    }
}

impl<R> Seek for ZlibDecodeMultiple<R>
where
    R: Read + Seek,
{
    fn seek(&mut self, pos: SeekFrom) -> Result<u64, IoError> {
        self.reader.as_mut().unwrap().get_mut().seek(pos)
    }
}

pub struct Reader {
    state: Option<Box<dyn State>>,
}

impl Reader {
    pub fn new<R: Read + Seek + 'static>(reader: R) -> Result<Reader, Error> {
        Ok(Reader {
            state: Some(state::new(reader)),
        })
    }
    pub fn collect_headers(&mut self) -> Result<Vec<Record>, Error> {
        let mut headers = Vec::new();
        for record in self {
            match record? {
                Record::EndOfHeaders(_) => break,
                r => headers.push(r),
            };
        }
        Ok(headers)
    }
}

impl Iterator for Reader {
    type Item = Result<Record, Error>;

    fn next(&mut self) -> Option<Self::Item> {
        match self.state.take()?.read() {
            Ok(Some((record, next_state))) => {
                self.state = Some(next_state);
                Some(Ok(record))
            }
            Ok(None) => None,
            Err(error) => Some(Err(error)),
        }
    }
}

impl FusedIterator for Reader {}

#[derive(Copy, Clone, PartialEq, Eq, Hash)]
pub struct Format(pub u32);

impl Debug for Format {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        let type_ = format_name(self.0 >> 16);
        let w = (self.0 >> 8) & 0xff;
        let d = self.0 & 0xff;
        write!(f, "{:06x} ({type_}{w}.{d})", self.0)
    }
}

fn format_name(type_: u32) -> Cow<'static, str> {
    match type_ {
        1 => "A",
        2 => "AHEX",
        3 => "COMMA",
        4 => "DOLLAR",
        5 => "F",
        6 => "IB",
        7 => "PIBHEX",
        8 => "P",
        9 => "PIB",
        10 => "PK",
        11 => "RB",
        12 => "RBHEX",
        15 => "Z",
        16 => "N",
        17 => "E",
        20 => "DATE",
        21 => "TIME",
        22 => "DATETIME",
        23 => "ADATE",
        24 => "JDATE",
        25 => "DTIME",
        26 => "WKDAY",
        27 => "MONTH",
        28 => "MOYR",
        29 => "QYR",
        30 => "WKYR",
        31 => "PCT",
        32 => "DOT",
        33 => "CCA",
        34 => "CCB",
        35 => "CCC",
        36 => "CCD",
        37 => "CCE",
        38 => "EDATE",
        39 => "SDATE",
        40 => "MTIME",
        41 => "YMDHMS",
        _ => return format!("<unknown format {type_}>").into()
    }.into()
}

#[derive(Clone)]
pub struct MissingValues {
    /// Individual missing values, up to 3 of them.
    pub values: Vec<Value>,

    /// Optional range of missing values.
    pub range: Option<(Value, Value)>,
}

impl Debug for MissingValues {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        for (i, value) in self.values.iter().enumerate() {
            if i > 0 {
                write!(f, ", ")?;
            }
            write!(f, "{value:?}")?;
        }

        if let Some((low, high)) = self.range {
            if !self.values.is_empty() {
                write!(f, ", ")?;
            }
            write!(f, "{low:?} THRU {high:?}")?;
        }

        if self.is_empty() {
            write!(f, "none")?;
        }

        Ok(())
    }
}

impl MissingValues {
    fn is_empty(&self) -> bool {
        self.values.is_empty() && self.range.is_none()
    }

    fn read<R: Read + Seek>(
        r: &mut R,
        offset: u64,
        width: i32,
        code: i32,
        endian: Endian,
    ) -> Result<MissingValues, Error> {
        let (n_values, has_range) = match (width, code) {
            (_, 0..=3) => (code, false),
            (0, -2) => (0, true),
            (0, -3) => (1, true),
            (0, _) => return Err(Error::BadNumericMissingValueCode { offset, code }),
            (_, _) => return Err(Error::BadStringMissingValueCode { offset, code }),
        };

        let var_type = VarType::from_width(width);

        let mut values = Vec::new();
        for _ in 0..n_values {
            values.push(Value::read(r, var_type, endian)?);
        }
        let range = if has_range {
            let low = Value::read(r, var_type, endian)?;
            let high = Value::read(r, var_type, endian)?;
            Some((low, high))
        } else {
            None
        };
        Ok(MissingValues { values, range })
    }
}

#[derive(Clone)]
pub struct Variable {
    /// Offset from the start of the file to the start of the record.
    pub offset: u64,

    /// Variable width, in the range -1..=255.
    pub width: i32,

    /// Variable name, padded on the right with spaces.
    pub name: [u8; 8],

    /// Print format.
    pub print_format: Format,

    /// Write format.
    pub write_format: Format,

    /// Missing values.
    pub missing_values: MissingValues,

    /// Optional variable label.
    pub label: Option<UnencodedString>,
}

impl Debug for Variable {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        writeln!(
            f,
            "Width: {} ({})",
            self.width,
            if self.width > 0 {
                "string"
            } else if self.width == 0 {
                "numeric"
            } else {
                "long string continuation record"
            }
        )?;
        writeln!(f, "Print format: {:?}", self.print_format)?;
        writeln!(f, "Write format: {:?}", self.write_format)?;
        writeln!(f, "Name: {:?}", FallbackEncoding(&self.name))?;
        writeln!(f, "Variable label: {:?}", self.label)?;
        writeln!(f, "Missing values: {:?}", self.missing_values)
    }
}

impl Variable {
    fn read<R: Read + Seek>(r: &mut R, endian: Endian) -> Result<Variable, Error> {
        let offset = r.stream_position()?;
        let width: i32 = endian.parse(read_bytes(r)?);
        let has_variable_label: u32 = endian.parse(read_bytes(r)?);
        let missing_value_code: i32 = endian.parse(read_bytes(r)?);
        let print_format = Format(endian.parse(read_bytes(r)?));
        let write_format = Format(endian.parse(read_bytes(r)?));
        let name: [u8; 8] = read_bytes(r)?;

        let label = match has_variable_label {
            0 => None,
            1 => {
                let len: u32 = endian.parse(read_bytes(r)?);
                let read_len = len.min(65535) as usize;
                let label = UnencodedString(read_vec(r, read_len)?);

                let padding_bytes = Integer::next_multiple_of(&len, &4) - len;
                let _ = read_vec(r, padding_bytes as usize)?;

                Some(label)
            }
            _ => {
                return Err(Error::BadVariableLabelCode {
                    offset,
                    code: has_variable_label,
                })
            }
        };

        let missing_values = MissingValues::read(r, offset, width, missing_value_code, endian)?;

        Ok(Variable {
            offset,
            width,
            name,
            print_format,
            write_format,
            missing_values,
            label,
        })
    }
}

#[derive(Copy, Clone)]
pub struct UntypedValue(pub [u8; 8]);

impl Debug for UntypedValue {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        let little: f64 = Endian::Little.parse(self.0);
        let little = format!("{:?}", little);
        let big: f64 = Endian::Big.parse(self.0);
        let big = format!("{:?}", big);
        let number = if little.len() <= big.len() {
            little
        } else {
            big
        };
        write!(f, "{number}")?;

        let string = fallback_encode(&self.0);
        let string = string
            .split(|c: char| c == '\0' || c.is_control())
            .next()
            .unwrap();
        write!(f, "/\"{string}\"")?;
        Ok(())
    }
}

#[derive(Clone)]
pub struct UnencodedString(Vec<u8>);

impl From<Vec<u8>> for UnencodedString {
    fn from(source: Vec<u8>) -> Self {
        Self(source)
    }
}

impl From<&[u8]> for UnencodedString {
    fn from(source: &[u8]) -> Self {
        Self(source.into())
    }
}

impl Debug for UnencodedString {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        write!(f, "{:?}", FallbackEncoding(self.0.as_slice()))
    }
}

#[derive(Clone)]
pub struct ValueLabel {
    /// Offset from the start of the file to the start of the record.
    pub offset: u64,

    /// The labels.
    pub labels: Vec<(UntypedValue, UnencodedString)>,
}

impl Debug for ValueLabel {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        for (value, label) in self.labels.iter() {
            writeln!(f, "{value:?}: {label:?}")?;
        }
        Ok(())
    }
}

impl ValueLabel {
    /// Maximum number of value labels in a record.
    pub const MAX: u32 = u32::MAX / 8;

    fn read<R: Read + Seek>(r: &mut R, endian: Endian) -> Result<ValueLabel, Error> {
        let offset = r.stream_position()?;
        let n: u32 = endian.parse(read_bytes(r)?);
        if n > ValueLabel::MAX {
            return Err(Error::BadNumberOfValueLabels {
                offset,
                n,
                max: ValueLabel::MAX,
            });
        }

        let mut labels = Vec::new();
        for _ in 0..n {
            let value = UntypedValue(read_bytes(r)?);
            let label_len: u8 = endian.parse(read_bytes(r)?);
            let label_len = label_len as usize;
            let padded_len = Integer::next_multiple_of(&(label_len + 1), &8);

            let mut label = read_vec(r, padded_len - 1)?;
            label.truncate(label_len);
            labels.push((value, UnencodedString(label)));
        }
        Ok(ValueLabel { offset, labels })
    }
}

#[derive(Clone)]
pub struct VarIndexes {
    /// Offset from the start of the file to the start of the record.
    pub offset: u64,

    /// The 0-based indexes of the variable indexes.
    pub var_indexes: Vec<u32>,
}

impl Debug for VarIndexes {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        write!(f, "apply to variables")?;
        for var_index in self.var_indexes.iter() {
            write!(f, " #{var_index}")?;
        }
        Ok(())
    }
}

impl VarIndexes {
    /// Maximum number of variable indexes in a record.
    pub const MAX: u32 = u32::MAX / 8;

    fn read<R: Read + Seek>(r: &mut R, endian: Endian) -> Result<VarIndexes, Error> {
        let offset = r.stream_position()?;
        let n: u32 = endian.parse(read_bytes(r)?);
        if n > VarIndexes::MAX {
            return Err(Error::BadNumberOfVarIndexes {
                offset,
                n,
                max: VarIndexes::MAX,
            });
        }
        let mut var_indexes = Vec::with_capacity(n as usize);
        for _ in 0..n {
            var_indexes.push(endian.parse(read_bytes(r)?));
        }

        Ok(VarIndexes {
            offset,
            var_indexes,
        })
    }
}

#[derive(Clone, Debug)]
pub struct Document {
    /// Offset from the start of the file to the start of the record.
    pub pos: u64,

    /// The document, as an array of 80-byte lines.
    pub lines: Vec<[u8; Document::LINE_LEN as usize]>,
}

impl Document {
    /// Length of a line in a document.  Document lines are fixed-length and
    /// padded on the right with spaces.
    pub const LINE_LEN: u32 = 80;

    /// Maximum number of lines we will accept in a document.  This is simply
    /// the maximum number that will fit in a 32-bit space.
    pub const MAX_LINES: u32 = i32::MAX as u32 / Self::LINE_LEN;

    fn read<R: Read + Seek>(r: &mut R, endian: Endian) -> Result<Document, Error> {
        let offset = r.stream_position()?;
        let n: u32 = endian.parse(read_bytes(r)?);
        match n {
            0..=Self::MAX_LINES => Ok(Document {
                pos: r.stream_position()?,
                lines: (0..n)
                    .map(|_| read_bytes(r))
                    .collect::<Result<Vec<_>, _>>()?,
            }),
            _ => Err(Error::BadDocumentLength {
                offset,
                n,
                max: Self::MAX_LINES,
            }),
        }
    }
}

trait TextRecord
where
    Self: Sized,
{
    const NAME: &'static str;
    fn parse(input: &str, warn: impl Fn(Error)) -> Result<Self, Error>;
}

trait ExtensionRecord
where
    Self: Sized,
{
    const SUBTYPE: u32;
    const SIZE: Option<u32>;
    const COUNT: Option<u32>;
    const NAME: &'static str;
    fn parse(ext: &Extension, endian: Endian, warn: impl Fn(Error)) -> Result<Self, Error>;
}

#[derive(Clone, Debug)]
pub struct IntegerInfo {
    pub version: (i32, i32, i32),
    pub machine_code: i32,
    pub floating_point_rep: i32,
    pub compression_code: i32,
    pub endianness: i32,
    pub character_code: i32,
}

impl ExtensionRecord for IntegerInfo {
    const SUBTYPE: u32 = 3;
    const SIZE: Option<u32> = Some(4);
    const COUNT: Option<u32> = Some(8);
    const NAME: &'static str = "integer record";

    fn parse(ext: &Extension, endian: Endian, _warn: impl Fn(Error)) -> Result<Self, Error> {
        ext.check_size::<Self>()?;

        let mut input = &ext.data[..];
        let data: Vec<i32> = (0..8)
            .map(|_| endian.parse(read_bytes(&mut input).unwrap()))
            .collect();
        Ok(IntegerInfo {
            version: (data[0], data[1], data[2]),
            machine_code: data[3],
            floating_point_rep: data[4],
            compression_code: data[5],
            endianness: data[6],
            character_code: data[7],
        })
    }
}

#[derive(Clone, Debug)]
pub struct FloatInfo {
    pub sysmis: f64,
    pub highest: f64,
    pub lowest: f64,
}

impl ExtensionRecord for FloatInfo {
    const SUBTYPE: u32 = 4;
    const SIZE: Option<u32> = Some(8);
    const COUNT: Option<u32> = Some(3);
    const NAME: &'static str = "floating point record";

    fn parse(ext: &Extension, endian: Endian, _warn: impl Fn(Error)) -> Result<Self, Error> {
        ext.check_size::<Self>()?;

        let mut input = &ext.data[..];
        let data: Vec<f64> = (0..3)
            .map(|_| endian.parse(read_bytes(&mut input).unwrap()))
            .collect();
        Ok(FloatInfo {
            sysmis: data[0],
            highest: data[1],
            lowest: data[2],
        })
    }
}

#[derive(Clone, Debug)]
pub enum MultipleResponseType {
    MultipleDichotomy {
        value: UnencodedString,
        labels: CategoryLabels,
    },
    MultipleCategory,
}
#[derive(Clone, Debug)]
pub struct MultipleResponseSet {
    pub name: UnencodedString,
    pub label: UnencodedString,
    pub mr_type: MultipleResponseType,
    pub vars: Vec<UnencodedString>,
}

impl MultipleResponseSet {
    fn parse(input: &[u8]) -> Result<(MultipleResponseSet, &[u8]), Error> {
        let Some(equals) = input.iter().position(|&b| b == b'=') else {
            return Err(Error::TBD);
        };
        let (name, input) = input.split_at(equals);
        let (mr_type, input) = match input.get(0) {
            Some(b'C') => (MultipleResponseType::MultipleCategory, &input[1..]),
            Some(b'D') => {
                let (value, input) = parse_counted_string(&input[1..])?;
                (
                    MultipleResponseType::MultipleDichotomy {
                        value: value.into(),
                        labels: CategoryLabels::VarLabels,
                    },
                    input,
                )
            }
            Some(b'E') => {
                let Some(b' ') = input.get(1) else {
                    return Err(Error::TBD);
                };
                let input = &input[2..];
                let (labels, input) = if let Some(rest) = input.strip_prefix(b" 1 ") {
                    (CategoryLabels::CountedValues, rest)
                } else if let Some(rest) = input.strip_prefix(b" 11 ") {
                    (CategoryLabels::VarLabels, rest)
                } else {
                    return Err(Error::TBD);
                };
                let (value, input) = parse_counted_string(input)?;
                (
                    MultipleResponseType::MultipleDichotomy {
                        value: value.into(),
                        labels,
                    },
                    input,
                )
            }
            _ => return Err(Error::TBD),
        };
        let Some(b' ') = input.get(0) else {
            return Err(Error::TBD);
        };
        let (label, mut input) = parse_counted_string(&input[1..])?;
        let mut vars = Vec::new();
        while input.get(0) == Some(&b' ') {
            input = &input[1..];
            let Some(length) = input.iter().position(|b| b" \n".contains(b)) else {
                return Err(Error::TBD);
            };
            if length > 0 {
                vars.push(input[..length].into());
            }
            input = &input[length..];
        }
        if input.get(0) != Some(&b'\n') {
            return Err(Error::TBD);
        }
        while input.get(0) == Some(&b'\n') {
            input = &input[1..];
        }
        Ok((
            MultipleResponseSet {
                name: name.into(),
                label: label.into(),
                mr_type,
                vars,
            },
            input,
        ))
    }
}

#[derive(Clone, Debug)]
pub struct MultipleResponseRecord(Vec<MultipleResponseSet>);

impl ExtensionRecord for MultipleResponseRecord {
    const SUBTYPE: u32 = 7;
    const SIZE: Option<u32> = Some(1);
    const COUNT: Option<u32> = None;
    const NAME: &'static str = "multiple response set record";

    fn parse(ext: &Extension, _endian: Endian, _warn: impl Fn(Error)) -> Result<Self, Error> {
        ext.check_size::<Self>()?;

        let mut input = &ext.data[..];
        let mut sets = Vec::new();
        while !input.is_empty() {
            let (set, rest) = MultipleResponseSet::parse(input)?;
            sets.push(set);
            input = rest;
        }
        Ok(MultipleResponseRecord(sets))
    }
}

fn parse_counted_string(input: &[u8]) -> Result<(UnencodedString, &[u8]), Error> {
    let Some(space) = input.iter().position(|&b| b == b' ') else {
        return Err(Error::TBD);
    };
    let Ok(length) = from_utf8(&input[..space]) else {
        return Err(Error::TBD);
    };
    let Ok(length): Result<usize, _> = length.parse() else {
        return Err(Error::TBD);
    };

    let input = &input[space + 1..];
    if input.len() < length {
        return Err(Error::TBD);
    };

    let (string, rest) = input.split_at(length);
    Ok((string.into(), rest))
}

pub struct ProductInfo(String);

impl TextRecord for ProductInfo {
    const NAME: &'static str = "extra product info";
    fn parse(input: &str, _warn: impl Fn(Error)) -> Result<Self, Error> {
        Ok(ProductInfo(input.into()))
    }
}

#[derive(Clone, Debug)]
pub struct VarDisplayRecord(pub Vec<u32>);

impl ExtensionRecord for VarDisplayRecord {
    const SUBTYPE: u32 = 11;
    const SIZE: Option<u32> = Some(4);
    const COUNT: Option<u32> = None;
    const NAME: &'static str = "variable display record";

    fn parse(ext: &Extension, endian: Endian, _warn: impl Fn(Error)) -> Result<Self, Error> {
        ext.check_size::<Self>()?;

        let mut input = &ext.data[..];
        let display = (0..ext.count)
            .map(|_| endian.parse(read_bytes(&mut input).unwrap()))
            .collect();
        Ok(VarDisplayRecord(display))
    }
}

pub struct VariableSet {
    pub name: String,
    pub vars: Vec<String>,
}

impl VariableSet {
    fn parse(input: &str) -> Result<Self, Error> {
        let (name, input) = input.split_once('=').ok_or(Error::TBD)?;
        let vars = input.split_ascii_whitespace().map(String::from).collect();
        Ok(VariableSet {
            name: name.into(),
            vars,
        })
    }
}

pub struct VariableSetRecord(Vec<VariableSet>);

impl TextRecord for VariableSetRecord {
    const NAME: &'static str = "variable set";
    fn parse(input: &str, warn: impl Fn(Error)) -> Result<Self, Error> {
        let mut sets = Vec::new();
        for line in input.lines() {
            match VariableSet::parse(line) {
                Ok(set) => sets.push(set),
                Err(error) => warn(error),
            }
        }
        Ok(VariableSetRecord(sets))
    }
}

pub struct LongVariableName {
    pub short_name: String,
    pub long_name: String,
}

pub struct LongVariableNameRecord(Vec<LongVariableName>);

impl TextRecord for LongVariableNameRecord {
    const NAME: &'static str = "long variable names";
    fn parse(input: &str, warn: impl Fn(Error)) -> Result<Self, Error> {
        let mut names = Vec::new();
        for pair in input.split('\t').filter(|s| !s.is_empty()) {
            if let Some((short_name, long_name)) = pair.split_once('=') {
                let name = LongVariableName {
                    short_name: short_name.into(),
                    long_name: long_name.into(),
                };
                names.push(name);
            } else {
                warn(Error::TBD)
            }
        }
        Ok(LongVariableNameRecord(names))
    }
}

pub struct VeryLongString {
    pub short_name: String,
    pub length: usize,
}

impl VeryLongString {
    fn parse(input: &str) -> Result<VeryLongString, Error> {
        let Some((short_name, length)) = input.split_once('=') else {
            return Err(Error::TBD);
        };
        let length: usize = length.parse().map_err(|_| Error::TBD)?;
        Ok(VeryLongString {
            short_name: short_name.into(),
            length,
        })
    }
}

pub struct VeryLongStringRecord(Vec<VeryLongString>);

impl TextRecord for VeryLongStringRecord {
    const NAME: &'static str = "very long strings";
    fn parse(input: &str, warn: impl Fn(Error)) -> Result<Self, Error> {
        let mut very_long_strings = Vec::new();
        for tuple in input
            .split('\0')
            .map(|s| s.trim_end_matches('\t'))
            .filter(|s| !s.is_empty())
        {
            match VeryLongString::parse(tuple) {
                Ok(vls) => very_long_strings.push(vls),
                Err(error) => warn(error),
            }
        }
        Ok(VeryLongStringRecord(very_long_strings))
    }
}

#[derive(Clone, Debug)]
pub struct LongStringValueLabels {
    pub var_name: UnencodedString,
    pub width: u32,

    /// `(value, label)` pairs, where each value is `width` bytes.
    pub labels: Vec<(UnencodedString, UnencodedString)>,
}

#[derive(Clone, Debug)]
pub struct LongStringValueLabelRecord(Vec<LongStringValueLabels>);

impl ExtensionRecord for LongStringValueLabelRecord {
    const SUBTYPE: u32 = 21;
    const SIZE: Option<u32> = Some(1);
    const COUNT: Option<u32> = None;
    const NAME: &'static str = "long string value labels record";

    fn parse(ext: &Extension, endian: Endian, _warn: impl Fn(Error)) -> Result<Self, Error> {
        ext.check_size::<Self>()?;

        let mut input = &ext.data[..];
        let mut label_set = Vec::new();
        while !input.is_empty() {
            let var_name = read_string(&mut input, endian)?;
            let width: u32 = endian.parse(read_bytes(&mut input)?);
            let n_labels: u32 = endian.parse(read_bytes(&mut input)?);
            let mut labels = Vec::new();
            for _ in 0..n_labels {
                let value = read_string(&mut input, endian)?;
                let label = read_string(&mut input, endian)?;
                labels.push((value, label));
            }
            label_set.push(LongStringValueLabels {
                var_name,
                width,
                labels,
            })
        }
        Ok(LongStringValueLabelRecord(label_set))
    }
}

pub struct LongStringMissingValues {
    /// Variable name.
    pub var_name: UnencodedString,

    /// Missing values.
    pub missing_values: MissingValues,
}

pub struct LongStringMissingValueSet(Vec<LongStringMissingValues>);

impl ExtensionRecord for LongStringMissingValueSet {
    const SUBTYPE: u32 = 22;
    const SIZE: Option<u32> = Some(1);
    const COUNT: Option<u32> = None;
    const NAME: &'static str = "long string missing values record";

    fn parse(ext: &Extension, endian: Endian, _warn: impl Fn(Error)) -> Result<Self, Error> {
        ext.check_size::<Self>()?;

        let mut input = &ext.data[..];
        let mut missing_value_set = Vec::new();
        while !input.is_empty() {
            let var_name = read_string(&mut input, endian)?;
            let n_missing_values: u8 = endian.parse(read_bytes(&mut input)?);
            let value_len: u32 = endian.parse(read_bytes(&mut input)?);
            if value_len != 8 {
                let offset = (ext.data.len() - input.len() - 8) as u64 + ext.offset;
                return Err(Error::BadLongMissingValueLength {
                    record_offset: ext.offset,
                    offset,
                    value_len,
                });
            }
            let mut values = Vec::new();
            for i in 0..n_missing_values {
                let value: [u8; 8] = read_bytes(&mut input)?;
                let numeric_value: u64 = endian.parse(value);
                let value = if i > 0 && numeric_value == 8 {
                    // Tolerate files written by old, buggy versions of PSPP
                    // where we believed that the value_length was repeated
                    // before each missing value.
                    read_bytes(&mut input)?
                } else {
                    value
                };
                values.push(Value::String(value));
            }
            let missing_values = MissingValues {
                values,
                range: None,
            };
            missing_value_set.push(LongStringMissingValues {
                var_name,
                missing_values,
            });
        }
        Ok(LongStringMissingValueSet(missing_value_set))
    }
}

#[derive(Clone, Debug)]
pub struct EncodingRecord(pub String);

impl ExtensionRecord for EncodingRecord {
    const SUBTYPE: u32 = 20;
    const SIZE: Option<u32> = Some(1);
    const COUNT: Option<u32> = None;
    const NAME: &'static str = "encoding record";

    fn parse(ext: &Extension, _endian: Endian, _warn: impl Fn(Error)) -> Result<Self, Error> {
        ext.check_size::<Self>()?;

        Ok(EncodingRecord(
            String::from_utf8(ext.data.clone())
                .map_err(|_| Error::BadEncodingName { offset: ext.offset })?,
        ))
    }
}

pub struct Attribute {
    pub name: String,
    pub values: Vec<String>,
}

impl Attribute {
    fn parse<'a>(input: &'a str, warn: &impl Fn(Error)) -> Result<(Attribute, &'a str), Error> {
        let Some((name, mut input)) = input.split_once('(') else {
            return Err(Error::TBD);
        };
        let mut values = Vec::new();
        loop {
            let Some((value, rest)) = input.split_once('\n') else {
                return Err(Error::TBD);
            };
            if let Some(stripped) = value
                .strip_prefix('\'')
                .and_then(|value| value.strip_suffix('\''))
            {
                values.push(stripped.into());
            } else {
                warn(Error::TBD);
                values.push(value.into());
            }
            if let Some(rest) = rest.strip_prefix(')') {
                return Ok((
                    Attribute {
                        name: name.into(),
                        values,
                    },
                    rest,
                ));
            }
            input = rest;
        }
    }
}

pub struct AttributeSet(pub Vec<Attribute>);

impl AttributeSet {
    fn parse<'a>(
        mut input: &'a str,
        sentinel: Option<char>,
        warn: &impl Fn(Error),
    ) -> Result<(AttributeSet, &'a str), Error> {
        let mut attributes = Vec::new();
        let rest = loop {
            match input.chars().next() {
                None => break input,
                c if c == sentinel => break &input[1..],
                _ => {
                    let (attribute, rest) = Attribute::parse(input, &warn)?;
                    attributes.push(attribute);
                    input = rest;
                }
            }
        };
        Ok((AttributeSet(attributes), rest))
    }
}

pub struct FileAttributeRecord(AttributeSet);

impl TextRecord for FileAttributeRecord {
    const NAME: &'static str = "data file attributes";
    fn parse(input: &str, warn: impl Fn(Error)) -> Result<Self, Error> {
        let (set, rest) = AttributeSet::parse(input, None, &warn)?;
        if !rest.is_empty() {
            warn(Error::TBD);
        }
        Ok(FileAttributeRecord(set))
    }
}

pub struct VarAttributeSet {
    pub long_var_name: String,
    pub attributes: AttributeSet,
}

impl VarAttributeSet {
    fn parse<'a>(
        input: &'a str,
        warn: &impl Fn(Error),
    ) -> Result<(VarAttributeSet, &'a str), Error> {
        let Some((long_var_name, rest)) = input.split_once(':') else {
            return Err(Error::TBD);
        };
        let (attributes, rest) = AttributeSet::parse(rest, Some('/'), warn)?;
        Ok((
            VarAttributeSet {
                long_var_name: long_var_name.into(),
                attributes,
            },
            rest,
        ))
    }
}

pub struct VariableAttributeRecord(Vec<VarAttributeSet>);

impl TextRecord for VariableAttributeRecord {
    const NAME: &'static str = "variable attributes";
    fn parse(mut input: &str, warn: impl Fn(Error)) -> Result<Self, Error> {
        let mut var_attribute_sets = Vec::new();
        while !input.is_empty() {
            match VarAttributeSet::parse(input, &warn) {
                Ok((var_attribute, rest)) => {
                    var_attribute_sets.push(var_attribute);
                    input = rest;
                }
                Err(error) => {
                    warn(error);
                    break;
                }
            }
        }
        Ok(VariableAttributeRecord(var_attribute_sets))
    }
}

#[derive(Clone, Debug)]
pub struct NumberOfCasesRecord {
    /// Always observed as 1.
    pub one: u64,

    /// Number of cases.
    pub n_cases: u64,
}

impl ExtensionRecord for NumberOfCasesRecord {
    const SUBTYPE: u32 = 16;
    const SIZE: Option<u32> = Some(8);
    const COUNT: Option<u32> = Some(2);
    const NAME: &'static str = "extended number of cases record";

    fn parse(ext: &Extension, endian: Endian, _warn: impl Fn(Error)) -> Result<Self, Error> {
        ext.check_size::<Self>()?;

        let mut input = &ext.data[..];
        let one = endian.parse(read_bytes(&mut input)?);
        let n_cases = endian.parse(read_bytes(&mut input)?);

        Ok(NumberOfCasesRecord { one, n_cases })
    }
}

#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum TextExtensionSubtype {
    VariableSets = 5,
    ProductInfo = 10,
    LongNames = 13,
    LongStrings = 14,
    FileAttributes = 17,
    VariableAttributes = 18,
}

#[derive(Clone, Debug)]
pub struct TextExtension {
    pub subtype: TextExtensionSubtype,
    pub string: UnencodedString,
}

#[derive(Clone, Debug)]
pub struct Extension {
    /// Offset from the start of the file to the start of the record.
    pub offset: u64,

    /// Record subtype.
    pub subtype: u32,

    /// Size of each data element.
    pub size: u32,

    /// Number of data elements.
    pub count: u32,

    /// `size * count` bytes of data.
    pub data: Vec<u8>,
}

/*
fn extension_record_size_requirements(extension: ExtensionType) -> (u32, u32) {
    match extension {
        /* Implemented record types. */
        ExtensionType::Integer => (4, 8),
        ExtensionType::Float => (8, 3),
        ExtensionType::VarSets => (1, 0),
        ExtensionType::Mrsets => (1, 0),
        ExtensionType::ProductInfo => (1, 0),
        ExtensionType::Display => (4, 0),
        ExtensionType::LongNames => (1, 0),
        ExtensionType::LongStrings => (1, 0),
        ExtensionType::Ncases => (8, 2),
        ExtensionType::FileAttrs => (1, 0),
        ExtensionType::VarAttrs => (1, 0),
        ExtensionType::Mrsets2 => (1, 0),
        ExtensionType::Encoding => (1, 0),
        ExtensionType::LongLabels => (1, 0),
        ExtensionType::LongMissing => (1, 0),

        /* Ignored record types. */
        ExtensionType::Date => (0, 0),
        ExtensionType::DataEntry => (0, 0),
        ExtensionType::Dataview => (0, 0),
    }
}
 */

impl Extension {
    fn check_size<E: ExtensionRecord>(&self) -> Result<(), Error> {
        if let Some(expected_size) = E::SIZE {
            if self.size != expected_size {
                return Err(Error::BadRecordSize {
                    offset: self.offset,
                    record: E::NAME.into(),
                    size: self.size,
                    expected_size,
                });
            }
        }
        if let Some(expected_count) = E::COUNT {
            if self.count != expected_count {
                return Err(Error::BadRecordCount {
                    offset: self.offset,
                    record: E::NAME.into(),
                    count: self.count,
                    expected_count,
                });
            }
        }
        Ok(())
    }

    fn read<R: Read + Seek>(r: &mut R, endian: Endian) -> Result<Record, Error> {
        let subtype = endian.parse(read_bytes(r)?);
        let offset = r.stream_position()?;
        let size: u32 = endian.parse(read_bytes(r)?);
        let count = endian.parse(read_bytes(r)?);
        let Some(product) = size.checked_mul(count) else {
            return Err(Error::ExtensionRecordTooLarge {
                offset,
                subtype,
                size,
                count,
            });
        };
        let offset = r.stream_position()?;
        let data = read_vec(r, product as usize)?;
        let extension = Extension {
            offset,
            subtype,
            size,
            count,
            data,
        };
        match subtype {
            IntegerInfo::SUBTYPE => Ok(Record::IntegerInfo(IntegerInfo::parse(
                &extension,
                endian,
                |_| (),
            )?)),
            FloatInfo::SUBTYPE => Ok(Record::FloatInfo(FloatInfo::parse(
                &extension,
                endian,
                |_| (),
            )?)),
            VarDisplayRecord::SUBTYPE => Ok(Record::VarDisplay(VarDisplayRecord::parse(
                &extension,
                endian,
                |_| (),
            )?)),
            MultipleResponseRecord::SUBTYPE | 19 => Ok(Record::MultipleResponse(
                MultipleResponseRecord::parse(&extension, endian, |_| ())?,
            )),
            LongStringValueLabelRecord::SUBTYPE => Ok(Record::LongStringValueLabels(
                LongStringValueLabelRecord::parse(&extension, endian, |_| ())?,
            )),
            EncodingRecord::SUBTYPE => Ok(Record::Encoding(EncodingRecord::parse(
                &extension,
                endian,
                |_| (),
            )?)),
            NumberOfCasesRecord::SUBTYPE => Ok(Record::NumberOfCases(NumberOfCasesRecord::parse(
                &extension,
                endian,
                |_| (),
            )?)),
            x if x == TextExtensionSubtype::VariableSets as u32 => {
                Ok(Record::VariableSets(UnencodedString(extension.data)))
            }
            x if x == TextExtensionSubtype::ProductInfo as u32 => {
                Ok(Record::ProductInfo(UnencodedString(extension.data)))
            }
            x if x == TextExtensionSubtype::LongNames as u32 => {
                Ok(Record::LongNames(UnencodedString(extension.data)))
            }
            x if x == TextExtensionSubtype::LongStrings as u32 => {
                Ok(Record::LongStrings(UnencodedString(extension.data)))
            }
            x if x == TextExtensionSubtype::FileAttributes as u32 => {
                Ok(Record::FileAttributes(UnencodedString(extension.data)))
            }
            x if x == TextExtensionSubtype::VariableAttributes as u32 => {
                Ok(Record::VariableAttributes(UnencodedString(extension.data)))
            }
            _ => Ok(Record::OtherExtension(extension)),
        }
    }
}

#[derive(Clone, Debug)]
pub struct ZHeader {
    /// File offset to the start of the record.
    pub offset: u64,

    /// File offset to the ZLIB data header.
    pub zheader_offset: u64,

    /// File offset to the ZLIB trailer.
    pub ztrailer_offset: u64,

    /// Length of the ZLIB trailer in bytes.
    pub ztrailer_len: u64,
}

impl ZHeader {
    fn read<R: Read + Seek>(r: &mut R, endian: Endian) -> Result<ZHeader, Error> {
        let offset = r.stream_position()?;
        let zheader_offset: u64 = endian.parse(read_bytes(r)?);
        let ztrailer_offset: u64 = endian.parse(read_bytes(r)?);
        let ztrailer_len: u64 = endian.parse(read_bytes(r)?);

        Ok(ZHeader {
            offset,
            zheader_offset,
            ztrailer_offset,
            ztrailer_len,
        })
    }
}

#[derive(Clone, Debug)]
pub struct ZTrailer {
    /// File offset to the start of the record.
    pub offset: u64,

    /// Compression bias as a negative integer, e.g. -100.
    pub int_bias: i64,

    /// Always observed as zero.
    pub zero: u64,

    /// Uncompressed size of each block, except possibly the last.  Only
    /// `0x3ff000` has been observed so far.
    pub block_size: u32,

    /// Block descriptors, always `(ztrailer_len - 24) / 24)` of them.
    pub blocks: Vec<ZBlock>,
}

#[derive(Clone, Debug)]
pub struct ZBlock {
    /// Offset of block of data if simple compression were used.
    pub uncompressed_ofs: u64,

    /// Actual offset within the file of the compressed data block.
    pub compressed_ofs: u64,

    /// The number of bytes in this data block after decompression.  This is
    /// `block_size` in every data block but the last, which may be smaller.
    pub uncompressed_size: u32,

    /// The number of bytes in this data block, as stored compressed in this
    /// file.
    pub compressed_size: u32,
}

impl ZBlock {
    fn read<R: Read + Seek>(r: &mut R, endian: Endian) -> Result<ZBlock, Error> {
        Ok(ZBlock {
            uncompressed_ofs: endian.parse(read_bytes(r)?),
            compressed_ofs: endian.parse(read_bytes(r)?),
            uncompressed_size: endian.parse(read_bytes(r)?),
            compressed_size: endian.parse(read_bytes(r)?),
        })
    }
}

impl ZTrailer {
    fn read<R: Read + Seek>(
        reader: &mut R,
        endian: Endian,
        ztrailer_ofs: u64,
        ztrailer_len: u64,
    ) -> Result<Option<ZTrailer>, Error> {
        let start_offset = reader.stream_position()?;
        if reader.seek(SeekFrom::Start(ztrailer_ofs)).is_err() {
            return Ok(None);
        }
        let int_bias = endian.parse(read_bytes(reader)?);
        let zero = endian.parse(read_bytes(reader)?);
        let block_size = endian.parse(read_bytes(reader)?);
        let n_blocks: u32 = endian.parse(read_bytes(reader)?);
        let expected_n_blocks = (ztrailer_len - 24) / 24;
        if n_blocks as u64 != expected_n_blocks {
            return Err(Error::BadZlibTrailerNBlocks {
                offset: ztrailer_ofs,
                n_blocks,
                expected_n_blocks,
                ztrailer_len,
            });
        }
        let blocks = (0..n_blocks)
            .map(|_| ZBlock::read(reader, endian))
            .collect::<Result<Vec<_>, _>>()?;
        reader.seek(SeekFrom::Start(start_offset))?;
        Ok(Some(ZTrailer {
            offset: ztrailer_ofs,
            int_bias,
            zero,
            block_size,
            blocks,
        }))
    }
}

fn try_read_bytes<const N: usize, R: Read>(r: &mut R) -> Result<Option<[u8; N]>, IoError> {
    let mut buf = [0; N];
    let n = r.read(&mut buf)?;
    if n > 0 {
        if n < N {
            r.read_exact(&mut buf[n..])?;
        }
        Ok(Some(buf))
    } else {
        Ok(None)
    }
}

fn read_bytes<const N: usize, R: Read>(r: &mut R) -> Result<[u8; N], IoError> {
    let mut buf = [0; N];
    r.read_exact(&mut buf)?;
    Ok(buf)
}

fn read_vec<R: Read>(r: &mut R, n: usize) -> Result<Vec<u8>, IoError> {
    let mut vec = vec![0; n];
    r.read_exact(&mut vec)?;
    Ok(vec)
}

fn read_string<R: Read>(r: &mut R, endian: Endian) -> Result<UnencodedString, IoError> {
    let length: u32 = endian.parse(read_bytes(r)?);
    Ok(read_vec(r, length as usize)?.into())
}