[pspp] / rust / src / raw.rs

use crate::{
    cooked::VarWidth,
    endian::{Endian, Parse, ToBytes},
    identifier::{Error as IdError, Identifier},
};

use encoding_rs::{mem::decode_latin1, DecoderResult, Encoding};
use flate2::read::ZlibDecoder;
use num::Integer;
use std::{
    borrow::Cow,
    cell::RefCell,
    cmp::Ordering,
    collections::{VecDeque, HashMap},
    fmt::{Debug, Display, Formatter, Result as FmtResult},
    io::{Error as IoError, Read, Seek, SeekFrom},
    iter::repeat,
    mem::take,
    ops::Range,
    rc::Rc,
    str::from_utf8,
};
use thiserror::Error as ThisError;

#[derive(ThisError, Debug)]
pub enum Error {
    #[error("Not an SPSS system file")]
    NotASystemFile,

    #[error("Invalid magic number {0:?}")]
    BadMagic([u8; 4]),

    #[error("I/O error ({0})")]
    Io(#[from] IoError),

    #[error("Invalid SAV compression code {0}")]
    InvalidSavCompression(u32),

    #[error("Invalid ZSAV compression code {0}")]
    InvalidZsavCompression(u32),

    #[error("Variable record at offset {offset:#x} specifies width {width} not in valid range [-1,255).")]
    BadVariableWidth { offset: u64, width: i32 },

    #[error("Document record at offset {offset:#x} has document line count ({n}) greater than the maximum number {max}.")]
    BadDocumentLength { offset: u64, n: usize, max: usize },

    #[error("At offset {offset:#x}, unrecognized record type {rec_type}.")]
    BadRecordType { offset: u64, rec_type: u32 },

    #[error("In variable record starting at offset {start_offset:#x}, variable label code {code} at offset {code_offset:#x} is not 0 or 1.")]
    BadVariableLabelCode {
        start_offset: u64,
        code_offset: u64,
        code: u32,
    },

    #[error(
        "At offset {offset:#x}, numeric missing value code ({code}) is not -3, -2, 0, 1, 2, or 3."
    )]
    BadNumericMissingValueCode { offset: u64, code: i32 },

    #[error("At offset {offset:#x}, string missing value code ({code}) is not 0, 1, 2, or 3.")]
    BadStringMissingValueCode { offset: u64, code: i32 },

    #[error("At offset {offset:#x}, number of value labels ({n}) is greater than the maximum number {max}.")]
    BadNumberOfValueLabels { offset: u64, n: u32, max: u32 },

    #[error("At offset {offset:#x}, following value label record, found record type {rec_type} instead of expected type 4 for variable index record")]
    ExpectedVarIndexRecord { offset: u64, rec_type: u32 },

    #[error("At offset {offset:#x}, number of variables indexes for value labels ({n}) is greater than the maximum number ({max}).")]
    TooManyVarIndexes { offset: u64, n: u32, max: u32 },

    #[error("At offset {offset:#x}, at least one valid variable index for value labels is required but none were specified.")]
    NoVarIndexes { offset: u64 },

    #[error("At offset {offset:#x}, the first variable index is for a {var_type} variable but the following variable indexes are for {} variables: {wrong_types:?}", var_type.opposite())]
    MixedVarTypes {
        offset: u64,
        var_type: VarType,
        wrong_types: Vec<u32>,
    },

    #[error("At offset {offset:#x}, one or more variable indexes for value labels were not in the valid range [1,{max}]: {invalid:?}")]
    InvalidVarIndexes {
        offset: u64,
        max: usize,
        invalid: Vec<u32>,
    },

    #[error("At offset {offset:#x}, record type 7 subtype {subtype} is too large with element size {size} and {count} elements.")]
    ExtensionRecordTooLarge {
        offset: u64,
        subtype: u32,
        size: u32,
        count: u32,
    },

    #[error("Unexpected end of file at offset {offset:#x}, {case_ofs} bytes into a {case_len}-byte case.")]
    EofInCase {
        offset: u64,
        case_ofs: u64,
        case_len: usize,
    },

    #[error(
        "Unexpected end of file at offset {offset:#x}, {case_ofs} bytes into a compressed case."
    )]
    EofInCompressedCase { offset: u64, case_ofs: u64 },

    #[error("Data ends at offset {offset:#x}, {case_ofs} bytes into a compressed case.")]
    PartialCompressedCase { offset: u64, case_ofs: u64 },

    #[error("At {case_ofs} bytes into compressed case starting at offset {offset:#x}, a string was found where a number was expected.")]
    CompressedNumberExpected { offset: u64, case_ofs: u64 },

    #[error("At {case_ofs} bytes into compressed case starting at offset {offset:#x}, a number was found where a string was expected.")]
    CompressedStringExpected { offset: u64, case_ofs: u64 },

    #[error("Block count {n_blocks} in ZLIB trailer at offset {offset:#x} differs from expected block count {expected_n_blocks} calculated from trailer length {ztrailer_len}.")]
    BadZlibTrailerNBlocks {
        offset: u64,
        n_blocks: u32,
        expected_n_blocks: u64,
        ztrailer_len: u64,
    },

    #[error("At offset {offset:#x}, {record} has bad size {size} bytes instead of the expected {expected_size}.")]
    BadRecordSize {
        offset: u64,
        record: String,
        size: u32,
        expected_size: u32,
    },

    #[error("At offset {offset:#x}, {record} has bad count {count} instead of the expected {expected_count}.")]
    BadRecordCount {
        offset: u64,
        record: String,
        count: u32,
        expected_count: u32,
    },

    #[error("In long string missing values record starting at offset {record_offset:#x}, value length at offset {offset:#x} is {value_len} instead of the expected 8.")]
    BadLongMissingValueLength {
        record_offset: u64,
        offset: u64,
        value_len: u32,
    },

    #[error("The encoding record at offset {offset:#x} contains an encoding name that is not valid UTF-8.")]
    BadEncodingName { offset: u64 },

    // XXX This is risky because `text` might be arbitarily long.
    #[error("Text string contains invalid bytes for {encoding} encoding: {text}")]
    MalformedString { encoding: String, text: String },

    #[error("Invalid variable measurement level value {0}")]
    InvalidMeasurement(u32),

    #[error("Invalid variable display alignment value {0}")]
    InvalidAlignment(u32),

    #[error("Invalid attribute name.  {0}")]
    InvalidAttributeName(IdError),

    #[error("Invalid variable name in attribute record.  {0}")]
    InvalidAttributeVariableName(IdError),

    #[error("Invalid short name in long variable name record.  {0}")]
    InvalidShortName(IdError),

    #[error("Invalid name in long variable name record.  {0}")]
    InvalidLongName(IdError),

    #[error("Invalid variable name in very long string record.  {0}")]
    InvalidLongStringName(IdError),

    #[error("Invalid variable name in variable set record.  {0}")]
    InvalidVariableSetName(IdError),

    #[error("Invalid multiple response set name.  {0}")]
    InvalidMrSetName(IdError),

    #[error("Invalid multiple response set variable name.  {0}")]
    InvalidMrSetVariableName(IdError),

    #[error("Invalid variable name in long string missing values record.  {0}")]
    InvalidLongStringMissingValueVariableName(IdError),

    #[error("Details TBD")]
    TBD,
}

#[derive(Clone, Debug)]
pub enum Record {
    Header(HeaderRecord<RawString>),
    Variable(VariableRecord<RawString, RawStr<8>>),
    ValueLabel(ValueLabelRecord<RawStr<8>, RawString>),
    Document(DocumentRecord<RawDocumentLine>),
    IntegerInfo(IntegerInfoRecord),
    FloatInfo(FloatInfoRecord),
    VariableSets(VariableSetRecord),
    VarDisplay(VarDisplayRecord),
    MultipleResponse(MultipleResponseRecord<RawString, RawString>),
    LongStringValueLabels(LongStringValueLabelRecord<RawString>),
    LongStringMissingValues(LongStringMissingValueRecord<RawString, RawStr<8>>),
    Encoding(EncodingRecord),
    NumberOfCases(NumberOfCasesRecord),
    ProductInfo(ProductInfoRecord),
    LongNames(LongNamesRecord),
    VeryLongStrings(VeryLongStringsRecord),
    FileAttributes(FileAttributeRecord),
    VariableAttributes(VariableAttributeRecord),
    Text(TextRecord),
    OtherExtension(Extension),
    EndOfHeaders(u32),
    ZHeader(ZHeader),
    ZTrailer(ZTrailer),
    Cases(Rc<RefCell<Cases>>),
}

impl Record {
    fn read<R>(
        reader: &mut R,
        endian: Endian,
        var_types: &[VarType],
        warn: &Box<dyn Fn(Error)>,
    ) -> Result<Option<Record>, Error>
    where
        R: Read + Seek,
    {
        let rec_type: u32 = endian.parse(read_bytes(reader)?);
        match rec_type {
            2 => Ok(Some(VariableRecord::read(reader, endian)?)),
            3 => Ok(ValueLabelRecord::read(reader, endian, var_types, warn)?),
            6 => Ok(Some(DocumentRecord::read(reader, endian)?)),
            7 => Extension::read(reader, endian, var_types.len(), warn),
            999 => Ok(Some(Record::EndOfHeaders(
                endian.parse(read_bytes(reader)?),
            ))),
            _ => Err(Error::BadRecordType {
                offset: reader.stream_position()?,
                rec_type,
            }),
        }
    }

    
}

// If `s` is valid UTF-8, returns it decoded as UTF-8, otherwise returns it
// decoded as Latin-1 (actually bytes interpreted as Unicode code points).
fn default_decode(s: &[u8]) -> Cow<str> {
    from_utf8(s).map_or_else(|_| decode_latin1(s), Cow::from)
}

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum Compression {
    Simple,
    ZLib,
}

trait Header {
    fn offsets(&self) -> Range<u64>;
}

#[derive(Clone)]
pub struct HeaderRecord<S>
where
    S: Debug,
{
    /// Offset in file.
    pub offsets: Range<u64>,

    /// Magic number.
    pub magic: Magic,

    /// Eye-catcher string, product name, in the file's encoding.  Padded
    /// on the right with spaces.
    pub eye_catcher: S,

    /// 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>,

    /// 1-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: S,

    /// `HH:MM:SS` in the file's encoding.
    pub creation_time: S,

    /// File label, in the file's encoding.  Padded on the right with spaces.
    pub file_label: S,

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

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

impl<S> Debug for HeaderRecord<S>
where
    S: Debug,
{
    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", &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", &self.creation_date)?;
        self.debug_field(f, "Creation time", &self.creation_time)?;
        self.debug_field(f, "File label", &self.file_label)?;
        self.debug_field(f, "Endianness", self.endian)
    }
}

impl HeaderRecord<RawString> {
    fn read<R: Read + Seek>(r: &mut R) -> Result<Self, Error> {
        let start = r.stream_position()?;

        let magic: [u8; 4] = read_bytes(r)?;
        let magic: Magic = magic.try_into().map_err(|_| Error::NotASystemFile)?;

        let eye_catcher = RawString(read_vec(r, 60)?);
        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_some(weight_index);

        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 = RawString(read_vec(r, 9)?);
        let creation_time = RawString(read_vec(r, 8)?);
        let file_label = RawString(read_vec(r, 64)?);
        let _: [u8; 3] = read_bytes(r)?;

        Ok(HeaderRecord {
            offsets: start..r.stream_position()?,
            magic,
            layout_code,
            nominal_case_size,
            compression,
            weight_index,
            n_cases,
            bias,
            creation_date,
            creation_time,
            eye_catcher,
            file_label,
            endian,
        })
    }

    pub fn decode<'a>(&'a self, decoder: &Decoder) -> HeaderRecord<Cow<'a, str>> {
        let eye_catcher = decoder.decode(&self.eye_catcher);
        let file_label = decoder.decode(&self.file_label);
        let creation_date = decoder.decode(&self.creation_date);
        let creation_time = decoder.decode(&self.creation_time);
        HeaderRecord {
            eye_catcher,
            weight_index: self.weight_index,
            n_cases: self.n_cases,
            file_label,
            offsets: self.offsets.clone(),
            magic: self.magic,
            layout_code: self.layout_code,
            nominal_case_size: self.nominal_case_size,
            compression: self.compression,
            bias: self.bias,
            creation_date,
            creation_time,
            endian: self.endian,
        }
    }
}

pub struct Decoder {
    pub encoding: &'static Encoding,
    pub warn: Box<dyn Fn(Error)>,
}

impl Decoder {
    fn warn(&self, error: Error) {
        (self.warn)(error)
    }
    fn decode_slice<'a>(&self, input: &'a [u8]) -> Cow<'a, str> {
        let (output, malformed) = self.encoding.decode_without_bom_handling(input);
        if malformed {
            self.warn(Error::MalformedString {
                encoding: self.encoding.name().into(),
                text: output.clone().into(),
            });
        }
        output
    }

    fn decode<'a>(&self, input: &'a RawString) -> Cow<'a, str> {
        self.decode_slice(input.0.as_slice())
    }

    /// Returns `input` decoded from `self.encoding` into UTF-8 such that
    /// re-encoding the result back into `self.encoding` will have exactly the
    /// same length in bytes.
    ///
    /// XXX warn about errors?
    fn decode_exact_length<'a>(&self, input: &'a [u8]) -> Cow<'a, str> {
        if let (s, false) = self.encoding.decode_without_bom_handling(input) {
            // This is the common case.  Usually there will be no errors.
            s
        } else {
            // Unusual case.  Don't bother to optimize it much.
            let mut decoder = self.encoding.new_decoder_without_bom_handling();
            let mut output = String::with_capacity(
                decoder
                    .max_utf8_buffer_length_without_replacement(input.len())
                    .unwrap(),
            );
            let mut rest = input;
            while !rest.is_empty() {
                match decoder.decode_to_string_without_replacement(rest, &mut output, true) {
                    (DecoderResult::InputEmpty, _) => break,
                    (DecoderResult::OutputFull, _) => unreachable!(),
                    (DecoderResult::Malformed(a, b), consumed) => {
                        let skipped = a as usize + b as usize;
                        output.extend(repeat('?').take(skipped));
                        rest = &rest[consumed..];
                    }
                }
            }
            assert_eq!(self.encoding.encode(&output).0.len(), input.len());
            output.into()
        }
    }

    pub fn decode_identifier(&self, input: &RawString) -> Result<Identifier, IdError> {
        self.new_identifier(&self.decode(input))
    }

    pub fn new_identifier(&self, name: &str) -> Result<Identifier, IdError> {
        Identifier::new(name, self.encoding)
    }
}

impl<S> Header for HeaderRecord<S>
where
    S: Debug,
{
    fn offsets(&self) -> Range<u64> {
        self.offsets.clone()
    }
}

#[derive(Copy, Clone, PartialEq, Eq, Hash)]
pub enum Magic {
    /// Regular system file.
    Sav,

    /// System file with Zlib-compressed data.
    Zsav,

    /// EBCDIC-encoded system file.
    Ebcdic,
}

impl Magic {
    /// Magic number for a regular system file.
    pub const SAV: [u8; 4] = *b"$FL2";

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

    /// Magic number for an EBCDIC-encoded system file.  This is `$FL2` encoded
    /// in EBCDIC.
    pub const EBCDIC: [u8; 4] = [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)",
        };
        write!(f, "{s}")
    }
}

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

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

#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum VarType {
    Numeric,
    String,
}

impl VarType {
    pub fn from_width(width: VarWidth) -> VarType {
        match width {
            VarWidth::Numeric => Self::Numeric,
            VarWidth::String(_) => Self::String,
        }
    }

    pub fn opposite(self) -> VarType {
        match self {
            Self::Numeric => Self::String,
            Self::String => Self::Numeric,
        }
    }
}

impl Display for VarType {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        match self {
            VarType::Numeric => write!(f, "numeric"),
            VarType::String => write!(f, "string"),
        }
    }
}

#[derive(Copy, Clone)]
pub enum Value<S>
where
    S: Debug,
{
    Number(Option<f64>),
    String(S),
}

type RawValue = Value<RawStr<8>>;

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

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

    pub fn from_raw(raw: &UntypedValue, var_type: VarType, endian: Endian) -> Self {
        match var_type {
            VarType::String => Value::String(RawStr(raw.0)),
            VarType::Numeric => {
                let number: f64 = endian.parse(raw.0);
                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<Self>>, 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(&UntypedValue(raw), var_type, 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<Self>>, 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::Numeric => break Self::Number(Some(code as f64 - bias)),
                        VarType::String => {
                            break Self::String(RawStr(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 Self::from_raw(&UntypedValue(read_bytes(reader)?), var_type, endian)
                    }
                    254 => match var_type {
                        VarType::String => break Self::String(RawStr(*b"        ")), // XXX EBCDIC
                        VarType::Numeric => {
                            return Err(Error::CompressedStringExpected {
                                offset: case_start,
                                case_ofs: reader.stream_position()? - case_start,
                            })
                        }
                    },
                    255 => match var_type {
                        VarType::Numeric => break Self::Number(None),
                        VarType::String => {
                            return Err(Error::CompressedNumberExpected {
                                offset: case_start,
                                case_ofs: reader.stream_position()? - case_start,
                            })
                        }
                    },
                }
            };
            values.push(value);
        }
        Ok(Some(values))
    }

    fn decode(&self, decoder: &Decoder) -> Value<String> {
        match self {
            Self::Number(x) => Value::Number(*x),
            Self::String(s) => Value::String(decoder.decode_exact_length(&s.0).into()),
        }
    }
}

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)
    }
}

enum ReaderState {
    Start,
    Headers,
    ZlibHeader,
    ZlibTrailer {
        ztrailer_offset: u64,
        ztrailer_len: u64,
    },
    Cases,
    End,
}

pub struct Reader<R>
where
    R: Read + Seek + 'static,
{
    reader: Option<R>,
    warn: Box<dyn Fn(Error)>,

    header: HeaderRecord<RawString>,
    var_types: Vec<VarType>,

    state: ReaderState,
}

impl<R> Reader<R>
where
    R: Read + Seek + 'static,
{
    pub fn new<F>(mut reader: R, warn: F) -> Result<Self, Error>
    where
        F: Fn(Error) + 'static,
    {
        let header = HeaderRecord::read(&mut reader)?;
        Ok(Self {
            reader: Some(reader),
            warn: Box::new(warn),
            header,
            var_types: Vec::new(),
            state: ReaderState::Start,
        })
    }
    fn cases(&mut self) -> Cases {
        self.state = ReaderState::End;
        Cases::new(
            self.reader.take().unwrap(),
            take(&mut self.var_types),
            &self.header,
        )
    }
}

impl<R> Iterator for Reader<R>
where
    R: Read + Seek + 'static,
{
    type Item = Result<Record, Error>;

    fn next(&mut self) -> Option<Self::Item> {
        match self.state {
            ReaderState::Start => {
                self.state = ReaderState::Headers;
                Some(Ok(Record::Header(self.header.clone())))
            }
            ReaderState::Headers => {
                let record = loop {
                    match Record::read(
                        self.reader.as_mut().unwrap(),
                        self.header.endian,
                        self.var_types.as_slice(),
                        &self.warn,
                    ) {
                        Ok(Some(record)) => break record,
                        Ok(None) => (),
                        Err(error) => return Some(Err(error)),
                    }
                };
                match record {
                    Record::Variable(VariableRecord { width, .. }) => {
                        self.var_types.push(if width == 0 {
                            VarType::Numeric
                        } else {
                            VarType::String
                        });
                    }
                    Record::EndOfHeaders(_) => {
                        self.state = if let Some(Compression::ZLib) = self.header.compression {
                            ReaderState::ZlibHeader
                        } else {
                            ReaderState::Cases
                        };
                    }
                    _ => (),
                };
                Some(Ok(record))
            }
            ReaderState::ZlibHeader => {
                let zheader = match ZHeader::read(self.reader.as_mut().unwrap(), self.header.endian)
                {
                    Ok(zheader) => zheader,
                    Err(error) => return Some(Err(error)),
                };
                self.state = ReaderState::ZlibTrailer {
                    ztrailer_offset: zheader.ztrailer_offset,
                    ztrailer_len: zheader.ztrailer_len,
                };
                Some(Ok(Record::ZHeader(zheader)))
            }
            ReaderState::ZlibTrailer {
                ztrailer_offset,
                ztrailer_len,
            } => {
                match ZTrailer::read(
                    self.reader.as_mut().unwrap(),
                    self.header.endian,
                    ztrailer_offset,
                    ztrailer_len,
                ) {
                    Ok(None) => Some(Ok(Record::Cases(Rc::new(RefCell::new(self.cases()))))),
                    Ok(Some(ztrailer)) => Some(Ok(Record::ZTrailer(ztrailer))),
                    Err(error) => Some(Err(error)),
                }
            }
            ReaderState::Cases => Some(Ok(Record::Cases(Rc::new(RefCell::new(self.cases()))))),
            ReaderState::End => None,
        }
    }
}

trait ReadSeek: Read + Seek {}
impl<T> ReadSeek for T where T: Read + Seek {}

pub struct Cases {
    reader: Box<dyn ReadSeek>,
    var_types: Vec<VarType>,
    compression: Option<Compression>,
    bias: f64,
    endian: Endian,
    codes: VecDeque<u8>,
    eof: bool,
}

impl Debug for Cases {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        write!(f, "Cases")
    }
}

impl Cases {
    fn new<R>(reader: R, var_types: Vec<VarType>, header: &HeaderRecord<RawString>) -> Self
    where
        R: Read + Seek + 'static,
    {
        Self {
            reader: if header.compression == Some(Compression::ZLib) {
                Box::new(ZlibDecodeMultiple::new(reader))
            } else {
                Box::new(reader)
            },
            var_types,
            compression: header.compression,
            bias: header.bias,
            endian: header.endian,
            codes: VecDeque::with_capacity(8),
            eof: false,
        }
    }
}

impl Iterator for Cases {
    type Item = Result<Vec<RawValue>, Error>;

    fn next(&mut self) -> Option<Self::Item> {
        if self.eof {
            return None;
        }

        let retval = if self.compression.is_some() {
            Value::read_compressed_case(
                &mut self.reader,
                &self.var_types,
                &mut self.codes,
                self.endian,
                self.bias,
            )
            .transpose()
        } else {
            Value::read_case(&mut self.reader, &self.var_types, self.endian).transpose()
        };
        self.eof = matches!(retval, None | Some(Err(_)));
        retval
    }
}

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

impl Debug for Spec {
    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<S = String>
where
    S: Debug,
{
    /// Individual missing values, up to 3 of them.
    pub values: Vec<Value<S>>,

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

impl<S> Debug for MissingValues<S>
where
    S: Debug,
{
    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<S> MissingValues<S>
where
    S: Debug,
{
    fn is_empty(&self) -> bool {
        self.values.is_empty() && self.range.is_none()
    }
}

impl<S> Default for MissingValues<S>
where
    S: Debug,
{
    fn default() -> Self {
        Self {
            values: Vec::new(),
            range: None,
        }
    }
}

impl MissingValues<RawStr<8>> {
    fn read<R: Read + Seek>(
        r: &mut R,
        offset: u64,
        width: i32,
        code: i32,
        endian: Endian,
    ) -> Result<Self, 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 = if width == 0 {
            VarType::Numeric
        } else {
            VarType::String
        };

        let mut values = Vec::new();
        for _ in 0..n_values {
            values.push(RawValue::read(r, var_type, endian)?);
        }
        let range = if has_range {
            let low = RawValue::read(r, var_type, endian)?;
            let high = RawValue::read(r, var_type, endian)?;
            Some((low, high))
        } else {
            None
        };
        Ok(Self { values, range })
    }
    fn decode<'a>(&'a self, decoder: &Decoder) -> MissingValues<String> {
        MissingValues {
            values: self
                .values
                .iter()
                .map(|value| value.decode(decoder))
                .collect(),
            range: self
                .range
                .as_ref()
                .map(|(low, high)| (low.decode(decoder), high.decode(decoder))),
        }
    }
}

#[derive(Clone)]
pub struct VariableRecord<S, V>
where
    S: Debug,
    V: Debug,
{
    /// Range of offsets in file.
    pub offsets: Range<u64>,

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

    /// Variable name, padded on the right with spaces.
    pub name: S,

    /// Print format.
    pub print_format: Spec,

    /// Write format.
    pub write_format: Spec,

    /// Missing values.
    pub missing_values: MissingValues<V>,

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

impl<S, V> Debug for VariableRecord<S, V>
where
    S: Debug,
    V: Debug,
{
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        writeln!(
            f,
            "Width: {} ({})",
            self.width,
            match self.width.cmp(&0) {
                Ordering::Greater => "string",
                Ordering::Equal => "numeric",
                Ordering::Less => "long string continuation record",
            }
        )?;
        writeln!(f, "Print format: {:?}", self.print_format)?;
        writeln!(f, "Write format: {:?}", self.write_format)?;
        writeln!(f, "Name: {:?}", &self.name)?;
        writeln!(f, "Variable label: {:?}", self.label)?;
        writeln!(f, "Missing values: {:?}", self.missing_values)
    }
}

impl VariableRecord<RawString, RawStr<8>> {
    fn read<R: Read + Seek>(r: &mut R, endian: Endian) -> Result<Record, Error> {
        let start_offset = r.stream_position()?;
        let width: i32 = endian.parse(read_bytes(r)?);
        let code_offset = r.stream_position()?;
        let has_variable_label: u32 = endian.parse(read_bytes(r)?);
        let missing_value_code: i32 = endian.parse(read_bytes(r)?);
        let print_format = Spec(endian.parse(read_bytes(r)?));
        let write_format = Spec(endian.parse(read_bytes(r)?));
        let name = RawString(read_vec(r, 8)?);

        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 = RawString(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 {
                    start_offset,
                    code_offset,
                    code: has_variable_label,
                })
            }
        };

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

        let end_offset = r.stream_position()?;

        Ok(Record::Variable(VariableRecord {
            offsets: start_offset..end_offset,
            width,
            name,
            print_format,
            write_format,
            missing_values,
            label,
        }))
    }

    pub fn decode<'a>(&'a self, decoder: &Decoder) -> VariableRecord<Cow<'a, str>, String> {
        VariableRecord {
            offsets: self.offsets.clone(),
            width: self.width,
            name: decoder.decode(&self.name),
            print_format: self.print_format,
            write_format: self.write_format,
            missing_values: self.missing_values.decode(decoder),
            label: self.label.as_ref().map(|label| decoder.decode(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 = default_decode(&self.0);
        let string = string
            .split(|c: char| c == '\0' || c.is_control())
            .next()
            .unwrap();
        write!(f, "{string:?}")?;
        Ok(())
    }
}

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

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

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

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

#[derive(Copy, Clone)]
pub struct RawStr<const N: usize>(pub [u8; N]);

impl<const N: usize> From<[u8; N]> for RawStr<N> {
    fn from(source: [u8; N]) -> Self {
        Self(source)
    }
}

impl<const N: usize> Debug for RawStr<N> {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        write!(f, "{:?}", default_decode(&self.0))
    }
}

#[derive(Clone, Debug)]
pub struct ValueLabel<V, S>
where
    V: Debug,
    S: Debug,
{
    pub value: Value<V>,
    pub label: S,
}

#[derive(Clone)]
pub struct ValueLabelRecord<V, S>
where
    V: Debug,
    S: Debug,
{
    /// Range of offsets in file.
    pub offsets: Range<u64>,

    /// The labels.
    pub labels: Vec<ValueLabel<V, S>>,

    /// The 1-based indexes of the variable indexes.
    pub dict_indexes: Vec<u32>,

    /// The types of the variables.
    pub var_type: VarType,
}

impl<V, S> Debug for ValueLabelRecord<V, S>
where
    V: Debug,
    S: Debug,
{
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        writeln!(f, "labels: ")?;
        for label in self.labels.iter() {
            writeln!(f, "{label:?}")?;
        }
        write!(f, "apply to {} variables", self.var_type)?;
        for dict_index in self.dict_indexes.iter() {
            write!(f, " #{dict_index}")?;
        }
        Ok(())
    }
}

impl<V, S> Header for ValueLabelRecord<V, S>
where
    V: Debug,
    S: Debug,
{
    fn offsets(&self) -> Range<u64> {
        self.offsets.clone()
    }
}

impl<V, S> ValueLabelRecord<V, S>
where
    V: Debug,
    S: Debug,
{
    /// Maximum number of value labels in a record.
    pub const MAX_LABELS: u32 = u32::MAX / 8;

    /// Maximum number of variable indexes in a record.
    pub const MAX_INDEXES: u32 = u32::MAX / 8;
}

impl ValueLabelRecord<RawStr<8>, RawString> {
    fn read<R: Read + Seek>(
        r: &mut R,
        endian: Endian,
        var_types: &[VarType],
        warn: &Box<dyn Fn(Error)>,
    ) -> Result<Option<Record>, Error> {
        let label_offset = r.stream_position()?;
        let n: u32 = endian.parse(read_bytes(r)?);
        if n > Self::MAX_LABELS {
            return Err(Error::BadNumberOfValueLabels {
                offset: label_offset,
                n,
                max: Self::MAX_LABELS,
            });
        }

        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, RawString(label)));
        }

        let index_offset = r.stream_position()?;
        let rec_type: u32 = endian.parse(read_bytes(r)?);
        if rec_type != 4 {
            return Err(Error::ExpectedVarIndexRecord {
                offset: index_offset,
                rec_type,
            });
        }

        let n: u32 = endian.parse(read_bytes(r)?);
        if n > Self::MAX_INDEXES {
            return Err(Error::TooManyVarIndexes {
                offset: index_offset,
                n,
                max: Self::MAX_INDEXES,
            });
        }

        let index_offset = r.stream_position()?;
        let mut dict_indexes = Vec::with_capacity(n as usize);
        let mut invalid_indexes = Vec::new();
        for _ in 0..n {
            let index: u32 = endian.parse(read_bytes(r)?);
            if index == 0 || index as usize > var_types.len() {
                dict_indexes.push(index);
            } else {
                invalid_indexes.push(index);
            }
        }
        if !invalid_indexes.is_empty() {
            warn(Error::InvalidVarIndexes {
                offset: index_offset,
                max: var_types.len(),
                invalid: invalid_indexes,
            });
        }

        let Some(&first_index) = dict_indexes.first() else {
            warn(Error::NoVarIndexes {
                offset: index_offset,
            });
            return Ok(None);
        };
        let var_type = var_types[first_index as usize - 1];
        let mut wrong_type_indexes = Vec::new();
        dict_indexes.retain(|&index| {
            if var_types[index as usize - 1] != var_type {
                wrong_type_indexes.push(index);
                false
            } else {
                true
            }
        });
        if !wrong_type_indexes.is_empty() {
            warn(Error::MixedVarTypes {
                offset: index_offset,
                var_type,
                wrong_types: wrong_type_indexes,
            });
        }

        let labels = labels
            .into_iter()
            .map(|(value, label)| ValueLabel {
                value: Value::from_raw(&value, var_type, endian),
                label,
            })
            .collect();

        let end_offset = r.stream_position()?;
        Ok(Some(Record::ValueLabel(ValueLabelRecord {
            offsets: label_offset..end_offset,
            labels,
            dict_indexes,
            var_type,
        })))
    }
}

#[derive(Clone, Debug)]
pub struct DocumentRecord<S>
where
    S: Debug,
{
    pub offsets: Range<u64>,

    /// The document, as an array of 80-byte lines.
    pub lines: Vec<S>,
}

pub type RawDocumentLine = RawStr<DOC_LINE_LEN>;

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

impl DocumentRecord<RawDocumentLine> {
    /// 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: usize = i32::MAX as usize / DOC_LINE_LEN;

    fn read<R: Read + Seek>(r: &mut R, endian: Endian) -> Result<Record, Error> {
        let start_offset = r.stream_position()?;
        let n: u32 = endian.parse(read_bytes(r)?);
        let n = n as usize;
        if n > Self::MAX_LINES {
            Err(Error::BadDocumentLength {
                offset: start_offset,
                n,
                max: Self::MAX_LINES,
            })
        } else {
            let mut lines = Vec::with_capacity(n);
            for _ in 0..n {
                lines.push(RawStr(read_bytes(r)?));
            }
            let end_offset = r.stream_position()?;
            Ok(Record::Document(DocumentRecord {
                offsets: start_offset..end_offset,
                lines,
            }))
        }
    }

    pub fn decode<'a>(&'a self, decoder: &Decoder) -> DocumentRecord<Cow<'a, str>> {
        DocumentRecord {
            offsets: self.offsets.clone(),
            lines: self
                .lines
                .iter()
                .map(|s| decoder.decode_slice(&s.0))
                .collect(),
        }
    }
}

impl<S> Header for DocumentRecord<S>
where
    S: Debug,
{
    fn offsets(&self) -> Range<u64> {
        self.offsets.clone()
    }
}

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

#[derive(Clone, Debug)]
pub struct IntegerInfoRecord {
    pub offsets: Range<u64>,
    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 IntegerInfoRecord {
    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) -> Result<Record, 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(Record::IntegerInfo(IntegerInfoRecord {
            offsets: ext.offsets.clone(),
            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 FloatInfoRecord {
    pub sysmis: f64,
    pub highest: f64,
    pub lowest: f64,
}

impl ExtensionRecord for FloatInfoRecord {
    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) -> Result<Record, 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(Record::FloatInfo(FloatInfoRecord {
            sysmis: data[0],
            highest: data[1],
            lowest: data[2],
        }))
    }
}

#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum CategoryLabels {
    VarLabels,
    CountedValues,
}

#[derive(Clone, Debug)]
pub enum MultipleResponseType {
    MultipleDichotomy {
        value: RawString,
        labels: CategoryLabels,
    },
    MultipleCategory,
}

impl MultipleResponseType {
    fn parse(input: &[u8]) -> Result<(MultipleResponseType, &[u8]), Error> {
        let (mr_type, input) = match input.split_first() {
            Some((b'C', input)) => (MultipleResponseType::MultipleCategory, input),
            Some((b'D', input)) => {
                let (value, input) = parse_counted_string(input)?;
                (
                    MultipleResponseType::MultipleDichotomy {
                        value,
                        labels: CategoryLabels::VarLabels,
                    },
                    input,
                )
            }
            Some((b'E', input)) => {
                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, labels },
                    input,
                )
            }
            _ => return Err(Error::TBD),
        };
        Ok((mr_type, input))
    }
}

#[derive(Clone, Debug)]
pub struct MultipleResponseSet<I, S>
where
    I: Debug,
    S: Debug,
{
    pub name: I,
    pub label: S,
    pub mr_type: MultipleResponseType,
    pub short_names: Vec<I>,
}

impl MultipleResponseSet<RawString, RawString> {
    fn parse(input: &[u8]) -> Result<(Self, &[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) = MultipleResponseType::parse(input)?;
        let Some(input) = input.strip_prefix(b" ") else {
            return Err(Error::TBD);
        };
        let (label, mut input) = parse_counted_string(input)?;
        let mut vars = Vec::new();
        while input.first() != Some(&b'\n') {
            match input.split_first() {
                Some((b' ', rest)) => {
                    let Some(length) = rest.iter().position(|b| b" \n".contains(b)) else {
                        return Err(Error::TBD);
                    };
                    let (var, rest) = rest.split_at(length);
                    if !var.is_empty() {
                        vars.push(var.into());
                    }
                    input = rest;
                }
                _ => return Err(Error::TBD),
            }
        }
        while input.first() == Some(&b'\n') {
            input = &input[1..];
        }
        Ok((
            MultipleResponseSet {
                name: name.into(),
                label,
                mr_type,
                short_names: vars,
            },
            input,
        ))
    }

    fn decode<'a>(
        &'a self,
        decoder: &Decoder,
    ) -> Result<MultipleResponseSet<Identifier, Cow<'a, str>>, Error> {
        let mut short_names = Vec::with_capacity(self.short_names.len());
        for short_name in self.short_names.iter() {
            if let Some(short_name) = decoder
                .decode_identifier(short_name)
                .map_err(|err| Error::InvalidMrSetName(err))
                .warn_on_error(&decoder.warn)
            {
                short_names.push(short_name);
            }
        }
        Ok(MultipleResponseSet {
            name: decoder
                .decode_identifier(&self.name)
                .map_err(|err| Error::InvalidMrSetVariableName(err))?,
            label: decoder.decode(&self.label),
            mr_type: self.mr_type.clone(),
            short_names: short_names,
        })
    }
}

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

impl ExtensionRecord for MultipleResponseRecord<RawString, RawString> {
    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) -> Result<Record, 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(Record::MultipleResponse(MultipleResponseRecord(sets)))
    }
}

impl MultipleResponseRecord<RawString, RawString> {
    fn decode<'a>(&'a self, decoder: &Decoder) -> MultipleResponseRecord<Identifier, Cow<'a, str>> {
        let mut sets = Vec::new();
        for set in self.0.iter() {
            if let Some(set) = set.decode(decoder).warn_on_error(&decoder.warn) {
                sets.push(set);
            }
        }
        MultipleResponseRecord(sets)
    }
}

fn parse_counted_string(input: &[u8]) -> Result<(RawString, &[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))
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Measure {
    Nominal,
    Ordinal,
    Scale,
}

impl Measure {
    pub fn default_for_type(var_type: VarType) -> Option<Measure> {
        match var_type {
            VarType::Numeric => None,
            VarType::String => Some(Self::Nominal),
        }
    }

    fn try_decode(source: u32) -> Result<Option<Measure>, Error> {
        match source {
            0 => Ok(None),
            1 => Ok(Some(Measure::Nominal)),
            2 => Ok(Some(Measure::Ordinal)),
            3 => Ok(Some(Measure::Scale)),
            _ => Err(Error::InvalidMeasurement(source)),
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Alignment {
    Left,
    Right,
    Center,
}

impl Alignment {
    fn try_decode(source: u32) -> Result<Option<Alignment>, Error> {
        match source {
            0 => Ok(None),
            1 => Ok(Some(Alignment::Left)),
            2 => Ok(Some(Alignment::Right)),
            3 => Ok(Some(Alignment::Center)),
            _ => Err(Error::InvalidAlignment(source)),
        }
    }

    pub fn default_for_type(var_type: VarType) -> Self {
        match var_type {
            VarType::Numeric => Self::Right,
            VarType::String => Self::Left,
        }
    }
}

#[derive(Clone, Debug)]
pub struct VarDisplay {
    pub measure: Option<Measure>,
    pub width: Option<u32>,
    pub alignment: Option<Alignment>,
}

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

impl VarDisplayRecord {
    const SUBTYPE: u32 = 11;

    fn parse(
        ext: &Extension,
        n_vars: usize,
        endian: Endian,
        warn: &Box<dyn Fn(Error)>,
    ) -> Result<Record, Error> {
        if ext.size != 4 {
            return Err(Error::BadRecordSize {
                offset: ext.offsets.start,
                record: String::from("variable display record"),
                size: ext.size,
                expected_size: 4,
            });
        }

        let has_width = if ext.count as usize == 3 * n_vars {
            true
        } else if ext.count as usize == 2 * n_vars {
            false
        } else {
            return Err(Error::TBD);
        };

        let mut var_displays = Vec::new();
        let mut input = &ext.data[..];
        for _ in 0..n_vars {
            let measure = Measure::try_decode(endian.parse(read_bytes(&mut input).unwrap()))
                .warn_on_error(&warn)
                .flatten();
            let width = has_width.then(|| endian.parse(read_bytes(&mut input).unwrap()));
            let alignment = Alignment::try_decode(endian.parse(read_bytes(&mut input).unwrap()))
                .warn_on_error(&warn)
                .flatten();
            var_displays.push(VarDisplay {
                measure,
                width,
                alignment,
            });
        }
        Ok(Record::VarDisplay(VarDisplayRecord(var_displays)))
    }
}

#[derive(Clone, Debug)]
pub struct LongStringMissingValues<N, V>
where
    N: Debug,
    V: Debug,
{
    /// Variable name.
    pub var_name: N,

    /// Missing values.
    pub missing_values: MissingValues<V>,
}

impl LongStringMissingValues<RawString, RawStr<8>> {
    fn decode<'a>(
        &self,
        decoder: &Decoder,
    ) -> Result<LongStringMissingValues<Identifier, String>, IdError> {
        Ok(LongStringMissingValues {
            var_name: decoder.decode_identifier(&self.var_name)?,
            missing_values: self.missing_values.decode(decoder),
        })
    }
}

#[derive(Clone, Debug)]
pub struct LongStringMissingValueRecord<N, V>(pub Vec<LongStringMissingValues<N, V>>)
where
    N: Debug,
    V: Debug;

impl ExtensionRecord for LongStringMissingValueRecord<RawString, RawStr<8>> {
    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) -> Result<Record, 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.offsets.start;
                return Err(Error::BadLongMissingValueLength {
                    record_offset: ext.offsets.start,
                    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(RawStr(value)));
            }
            let missing_values = MissingValues {
                values,
                range: None,
            };
            missing_value_set.push(LongStringMissingValues {
                var_name,
                missing_values,
            });
        }
        Ok(Record::LongStringMissingValues(
            LongStringMissingValueRecord(missing_value_set),
        ))
    }
}

impl LongStringMissingValueRecord<RawString, RawStr<8>> {
    pub fn decode<'a>(
        &self,
        decoder: &Decoder,
    ) -> LongStringMissingValueRecord<Identifier, String> {
        let mut mvs = Vec::with_capacity(self.0.len());
        for mv in self.0.iter() {
            if let Some(mv) = mv
                .decode(decoder)
                .map_err(|err| Error::InvalidLongStringMissingValueVariableName(err))
                .warn_on_error(&decoder.warn)
            {
                mvs.push(mv);
            }
        }
        LongStringMissingValueRecord(mvs)
    }
}

#[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) -> Result<Record, Error> {
        ext.check_size::<Self>()?;

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

#[derive(Copy, 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) -> Result<Record, 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(Record::NumberOfCases(NumberOfCasesRecord { one, n_cases }))
    }
}

#[derive(Clone, Debug)]
pub struct TextRecord {
    pub offsets: Range<u64>,

    /// Type of record.
    pub rec_type: TextRecordType,

    /// The text content of the record.
    pub text: RawString,
}

#[derive(Clone, Copy, Debug)]
pub enum TextRecordType {
    VariableSets,
    ProductInfo,
    LongNames,
    VeryLongStrings,
    FileAttributes,
    VariableAttributes,
}

impl TextRecord {
    fn new(extension: Extension, rec_type: TextRecordType) -> Self {
        Self {
            offsets: extension.offsets,
            rec_type,
            text: extension.data.into(),
        }
    }
    pub fn decode<'a>(&self, decoder: &Decoder) -> Result<Option<Record>, Error> {
        match self.rec_type {
            TextRecordType::VariableSets => Ok(Some(Record::VariableSets(
                VariableSetRecord::decode(self, decoder),
            ))),
            TextRecordType::ProductInfo => Ok(Some(Record::ProductInfo(
                ProductInfoRecord::decode(self, decoder),
            ))),
            TextRecordType::LongNames => Ok(Some(Record::LongNames(LongNamesRecord::decode(
                self, decoder,
            )))),
            TextRecordType::VeryLongStrings => Ok(Some(Record::VeryLongStrings(
                VeryLongStringsRecord::decode(self, decoder),
            ))),
            TextRecordType::FileAttributes => {
                Ok(FileAttributeRecord::decode(self, decoder).map(|fa| Record::FileAttributes(fa)))
            }
            TextRecordType::VariableAttributes => Ok(Some(Record::VariableAttributes(
                VariableAttributeRecord::decode(self, decoder),
            ))),
        }
    }
}

#[derive(Clone, Debug)]
pub struct VeryLongString {
    pub short_name: Identifier,
    pub length: u16,
}

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

#[derive(Clone, Debug)]
pub struct VeryLongStringsRecord(Vec<VeryLongString>);

impl VeryLongStringsRecord {
    fn decode(source: &TextRecord, decoder: &Decoder) -> Self {
        let input = decoder.decode(&source.text);
        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())
        {
            if let Some(vls) = VeryLongString::parse(decoder, tuple).warn_on_error(&decoder.warn) {
                very_long_strings.push(vls)
            }
        }
        VeryLongStringsRecord(very_long_strings)
    }
}

#[derive(Clone, Debug)]
pub struct Attribute {
    pub name: Identifier,
    pub values: Vec<String>,
}

impl Attribute {
    fn parse<'a>(decoder: &Decoder, input: &'a str) -> Result<(Attribute, &'a str), Error> {
        let Some((name, mut input)) = input.split_once('(') else {
            return Err(Error::TBD);
        };
        let name = decoder
            .new_identifier(name)
            .map_err(Error::InvalidAttributeName)?;
        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 {
                decoder.warn(Error::TBD);
                values.push(value.into());
            }
            if let Some(rest) = rest.strip_prefix(')') {
                let attribute = Attribute { name, values };
                return Ok((attribute, rest));
            };
            input = rest;
        }
    }
}

#[derive(Clone, Debug)]
pub struct AttributeSet(pub HashMap<Identifier, Vec<String>>);

impl AttributeSet {
    fn parse<'a>(
        decoder: &Decoder,
        mut input: &'a str,
        sentinel: Option<char>,
    ) -> Result<(AttributeSet, &'a str), Error> {
        let mut attributes = HashMap::new();
        let rest = loop {
            match input.chars().next() {
                None => break input,
                c if c == sentinel => break &input[1..],
                _ => {
                    let (attribute, rest) = Attribute::parse(decoder, input)?;
                    // XXX report duplicate name
                    attributes.insert(attribute.name, attribute.values);
                    input = rest;
                }
            }
        };
        Ok((AttributeSet(attributes), rest))
    }
}

#[derive(Clone, Debug)]
pub struct FileAttributeRecord(AttributeSet);

impl FileAttributeRecord {
    fn decode(source: &TextRecord, decoder: &Decoder) -> Option<Self> {
        let input = decoder.decode(&source.text);
        match AttributeSet::parse(decoder, &input, None).warn_on_error(&decoder.warn) {
            Some((set, rest)) => {
                if !rest.is_empty() {
                    decoder.warn(Error::TBD);
                }
                Some(FileAttributeRecord(set))
            }
            None => None,
        }
    }
}

#[derive(Clone, Debug)]
pub struct VarAttributeSet {
    pub long_var_name: Identifier,
    pub attributes: AttributeSet,
}

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

#[derive(Clone, Debug)]
pub struct VariableAttributeRecord(Vec<VarAttributeSet>);

impl VariableAttributeRecord {
    fn decode(source: &TextRecord, decoder: &Decoder) -> Self {
        let decoded = decoder.decode(&source.text);
        let mut input = decoded.as_ref();
        let mut var_attribute_sets = Vec::new();
        while !input.is_empty() {
            let Some((var_attribute, rest)) =
                VarAttributeSet::parse(decoder, &input).warn_on_error(&decoder.warn)
            else {
                break;
            };
            var_attribute_sets.push(var_attribute);
            input = rest.into();
        }
        VariableAttributeRecord(var_attribute_sets)
    }
}

#[derive(Clone, Debug)]
pub struct LongName {
    pub short_name: Identifier,
    pub long_name: Identifier,
}

impl LongName {
    fn parse(input: &str, decoder: &Decoder) -> Result<Self, Error> {
        let Some((short_name, long_name)) = input.split_once('=') else {
            return Err(Error::TBD);
        };
        let short_name = decoder
            .new_identifier(short_name)
            .map_err(Error::InvalidShortName)?;
        let long_name = decoder
            .new_identifier(long_name)
            .map_err(Error::InvalidLongName)?;
        Ok(LongName {
            short_name,
            long_name,
        })
    }
}

#[derive(Clone, Debug)]
pub struct LongNamesRecord(Vec<LongName>);

impl LongNamesRecord {
    fn decode(source: &TextRecord, decoder: &Decoder) -> Self {
        let input = decoder.decode(&source.text);
        let mut names = Vec::new();
        for pair in input.split('\t').filter(|s| !s.is_empty()) {
            if let Some(long_name) = LongName::parse(pair, decoder).warn_on_error(&decoder.warn) {
                names.push(long_name);
            }
        }
        LongNamesRecord(names)
    }
}

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

impl ProductInfoRecord {
    const NAME: &'static str = "extra product info";
    fn decode(source: &TextRecord, decoder: &Decoder) -> Self {
        Self(decoder.decode(&source.text).into())
    }
}
#[derive(Clone, Debug)]
pub struct VariableSet {
    pub name: String,
    pub vars: Vec<Identifier>,
}

impl VariableSet {
    fn parse(input: &str, decoder: &Decoder) -> Result<Self, Error> {
        let (name, input) = input.split_once('=').ok_or(Error::TBD)?;
        let mut vars = Vec::new();
        for var in input.split_ascii_whitespace() {
            if let Some(identifier) = decoder
                .new_identifier(var)
                .map_err(Error::InvalidVariableSetName)
                .warn_on_error(&decoder.warn)
            {
                vars.push(identifier);
            }
        }
        Ok(VariableSet {
            name: name.into(),
            vars,
        })
    }
}

#[derive(Clone, Debug)]
pub struct VariableSetRecord {
    pub offsets: Range<u64>,
    pub sets: Vec<VariableSet>,
}

impl VariableSetRecord {
    fn decode(source: &TextRecord, decoder: &Decoder) -> VariableSetRecord {
        let mut sets = Vec::new();
        let input = decoder.decode(&source.text);
        for line in input.lines() {
            if let Some(set) = VariableSet::parse(line, decoder).warn_on_error(&decoder.warn) {
                sets.push(set)
            }
        }
        VariableSetRecord {
            offsets: source.offsets.clone(),
            sets,
        }
    }
}

trait WarnOnError<T> {
    fn warn_on_error<F: Fn(Error)>(self, warn: &F) -> Option<T>;
}
impl<T> WarnOnError<T> for Result<T, Error> {
    fn warn_on_error<F: Fn(Error)>(self, warn: &F) -> Option<T> {
        match self {
            Ok(result) => Some(result),
            Err(error) => {
                warn(error);
                None
            }
        }
    }
}

#[derive(Clone, Debug)]
pub struct Extension {
    pub offsets: Range<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>,
}

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.offsets.start,
                    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.offsets.start,
                    record: E::NAME.into(),
                    count: self.count,
                    expected_count,
                });
            }
        }
        Ok(())
    }

    fn read<R: Read + Seek>(
        r: &mut R,
        endian: Endian,
        n_vars: usize,
        warn: &Box<dyn Fn(Error)>,
    ) -> Result<Option<Record>, Error> {
        let subtype = endian.parse(read_bytes(r)?);
        let header_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: header_offset,
                subtype,
                size,
                count,
            });
        };
        let start_offset = r.stream_position()?;
        let data = read_vec(r, product as usize)?;
        let end_offset = start_offset + product as u64;
        let extension = Extension {
            offsets: start_offset..end_offset,
            subtype,
            size,
            count,
            data,
        };
        let result = match subtype {
            IntegerInfoRecord::SUBTYPE => IntegerInfoRecord::parse(&extension, endian),
            FloatInfoRecord::SUBTYPE => FloatInfoRecord::parse(&extension, endian),
            VarDisplayRecord::SUBTYPE => VarDisplayRecord::parse(&extension, n_vars, endian, warn),
            MultipleResponseRecord::SUBTYPE | 19 => {
                MultipleResponseRecord::parse(&extension, endian)
            }
            LongStringValueLabelRecord::SUBTYPE => {
                LongStringValueLabelRecord::parse(&extension, endian)
            }
            EncodingRecord::SUBTYPE => EncodingRecord::parse(&extension, endian),
            NumberOfCasesRecord::SUBTYPE => NumberOfCasesRecord::parse(&extension, endian),
            5 => Ok(Record::Text(TextRecord::new(
                extension,
                TextRecordType::VariableSets,
            ))),
            10 => Ok(Record::Text(TextRecord::new(
                extension,
                TextRecordType::ProductInfo,
            ))),
            13 => Ok(Record::Text(TextRecord::new(
                extension,
                TextRecordType::LongNames,
            ))),
            14 => Ok(Record::Text(TextRecord::new(
                extension,
                TextRecordType::VeryLongStrings,
            ))),
            17 => Ok(Record::Text(TextRecord::new(
                extension,
                TextRecordType::FileAttributes,
            ))),
            18 => Ok(Record::Text(TextRecord::new(
                extension,
                TextRecordType::VariableAttributes,
            ))),
            _ => Ok(Record::OtherExtension(extension)),
        };
        match result {
            Ok(result) => Ok(Some(result)),
            Err(error) => {
                warn(error);
                Ok(None)
            }
        }
    }
}

#[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<RawString, IoError> {
    let length: u32 = endian.parse(read_bytes(r)?);
    Ok(read_vec(r, length as usize)?.into())
}

#[derive(Clone, Debug)]
pub struct LongStringValueLabels<S>
where
    S: Debug,
{
    pub var_name: S,
    pub width: u32,

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

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

impl ExtensionRecord for LongStringValueLabelRecord<RawString> {
    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) -> Result<Record, 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(Record::LongStringValueLabels(LongStringValueLabelRecord(
            label_set,
        )))
    }
}