zip.rs

//! テストの入力を ZIP にして書く
//!
//! folio は読むだけなので、ZIP の書き出しはテストのためにここにだけ置く。
//! 長さの決まっていないエントリも書き始められ、8MB を超えたものは ZIP64 のヘッダになる。

use super::deflate::{Deflate, deflate};
use folio::Error;
use folio::crc::{Crc, checksum};
use folio::zip::{DEFLATED, STORED};
use std::fs::File;
use std::io::{BufWriter, Seek, SeekFrom, Write};
use std::path::Path;


/// これを超えたら 32 ビットに収まらない
const LIMIT: u64 = 0xffffffff;

/// 長さが決まる前に書き出す判断をする境目
const HOLD_LIMIT: usize = 8 * 1024 * 1024;

/// エントリの時刻。テストで作るファイルが毎回同じになるよう、決めておく
const TIME: u16 = 0;

/// エントリの日付。2026-01-01
const DATE: u16 = ((2026 - 1980) << 9) | (1 << 5) | 1;


/// 書き出しの控え
struct Written {
    name: String,
    method: u16,
    crc: u32,
    compressed: u64,
    uncompressed: u64,
    offset: u64,
}


/// 書きかけのエントリ
struct Open {
    name: String,
    offset: u64,
    /// ヘッダを書き終えたか。まだなら長さが決まっていない
    started: bool,
    /// ヘッダを書くまで手元にためる圧縮済みバイト
    hold: Vec<u8>,
    crc: Crc,
    compressed: u64,
    uncompressed: u64,
    state: Deflate,
}


/// 書くために開いた ZIP
pub struct Writer {
    file: BufWriter<File>,
    position: u64,
    written: Vec<Written>,
    open: Option<Open>,
}


impl Writer {
    /// 新しいファイルを作る
    pub fn create(path: &Path) -> Result<Writer, Error> {
        let file = File::create(path)?;

        Ok(Writer {
            file: BufWriter::new(file),
            position: 0,
            written: Vec::new(),
            open: None,
        })
    }

    /// 縮めて 1 つ書く
    pub fn add(&mut self, name: &str, data: &[u8]) -> Result<(), Error> {
        let packed = deflate(data);

        // 縮めても短くならないものは、そのまま入れる
        if packed.len() >= data.len() {
            return self.add_stored(name, data);
        }

        self.put(name, DEFLATED, checksum(data), &packed, data.len() as u64)
    }

    /// 縮めずに 1 つ書く
    pub fn add_stored(&mut self, name: &str, data: &[u8]) -> Result<(), Error> {
        self.put(name, STORED, checksum(data), data, data.len() as u64)
    }

    /// 長さの決まっていないエントリを書き始める
    pub fn start(&mut self, name: &str) -> Result<(), Error> {
        if self.open.is_some() {
            return Err(Error::at("前のエントリを閉じていません", name));
        }

        self.open = Some(Open {
            name: name.to_string(),
            offset: self.position,
            started: false,
            hold: Vec::new(),
            crc: Crc::new(),
            compressed: 0,
            uncompressed: 0,
            state: Deflate::new(),
        });

        Ok(())
    }

    /// 書き始めたエントリに続きを渡す
    pub fn write(&mut self, data: &[u8]) -> Result<(), Error> {
        let Some(open) = self.open.as_mut() else {
            return Err(Error::new("書き始めていないエントリに書こうとしています"));
        };

        open.crc.update(data);
        open.uncompressed += data.len() as u64;
        open.state.write(data);
        let piece = open.state.take();
        open.hold.extend_from_slice(&piece);

        if !open.started && open.hold.len() >= HOLD_LIMIT {
            let header = local_header(&open.name, DEFLATED, 0, 0, 0, true);
            open.started = true;
            let hold = std::mem::take(&mut open.hold);
            open.compressed += hold.len() as u64;
            self.emit(&header)?;
            self.emit(&hold)?;
            return Ok(());
        }

        if open.started {
            let hold = std::mem::take(&mut open.hold);
            open.compressed += hold.len() as u64;
            self.emit(&hold)?;
        }

        Ok(())
    }

    /// 書き始めたエントリを閉じる
    pub fn close(&mut self) -> Result<(), Error> {
        let Some(mut open) = self.open.take() else {
            return Err(Error::new("書き始めていないエントリを閉じようとしています"));
        };

        open.state.finish();
        let piece = open.state.take();
        open.hold.extend_from_slice(&piece);
        let crc = open.crc.finish();

        if !open.started {
            // 8MB に収まったので、ふつうのヘッダを長さ入りで書く
            let compressed = open.hold.len() as u64;
            let header = local_header(&open.name, DEFLATED, crc, compressed, open.uncompressed, false);
            let hold = std::mem::take(&mut open.hold);
            self.emit(&header)?;
            self.emit(&hold)?;

            self.written.push(Written {
                name: open.name,
                method: DEFLATED,
                crc,
                compressed,
                uncompressed: open.uncompressed,
                offset: open.offset,
            });

            return Ok(());
        }

        let hold = std::mem::take(&mut open.hold);
        open.compressed += hold.len() as u64;
        self.emit(&hold)?;

        // ZIP64 のヘッダを書いてあるので、決まった長さをそこへ埋める
        let name_length = open.name.len() as u64;
        self.patch(open.offset + 14, &crc.to_le_bytes())?;
        self.patch(open.offset + 30 + name_length + 4, &open.uncompressed.to_le_bytes())?;
        self.patch(open.offset + 30 + name_length + 12, &open.compressed.to_le_bytes())?;

        self.written.push(Written {
            name: open.name,
            method: DEFLATED,
            crc,
            compressed: open.compressed,
            uncompressed: open.uncompressed,
            offset: open.offset,
        });

        Ok(())
    }

    /// 中央目録を書いて閉じる
    pub fn finish(mut self) -> Result<(), Error> {
        if self.open.is_some() {
            return Err(Error::new("閉じていないエントリがあります"));
        }

        let start = self.position;
        let mut region = Vec::new();

        for one in &self.written {
            central_header(&mut region, one);
        }

        self.emit(&region)?;
        let length = region.len() as u64;
        let count = self.written.len() as u64;
        let mut tail = Vec::new();

        if count >= 0xffff || length >= LIMIT || start >= LIMIT {
            let record = self.position;
            tail.extend_from_slice(&0x06064b50u32.to_le_bytes());
            tail.extend_from_slice(&44u64.to_le_bytes());
            tail.extend_from_slice(&45u16.to_le_bytes());
            tail.extend_from_slice(&45u16.to_le_bytes());
            tail.extend_from_slice(&0u32.to_le_bytes());
            tail.extend_from_slice(&0u32.to_le_bytes());
            tail.extend_from_slice(&count.to_le_bytes());
            tail.extend_from_slice(&count.to_le_bytes());
            tail.extend_from_slice(&length.to_le_bytes());
            tail.extend_from_slice(&start.to_le_bytes());

            tail.extend_from_slice(&0x07064b50u32.to_le_bytes());
            tail.extend_from_slice(&0u32.to_le_bytes());
            tail.extend_from_slice(&record.to_le_bytes());
            tail.extend_from_slice(&1u32.to_le_bytes());
        }

        tail.extend_from_slice(&0x06054b50u32.to_le_bytes());
        tail.extend_from_slice(&0u16.to_le_bytes());
        tail.extend_from_slice(&0u16.to_le_bytes());
        tail.extend_from_slice(&(count.min(0xffff) as u16).to_le_bytes());
        tail.extend_from_slice(&(count.min(0xffff) as u16).to_le_bytes());
        tail.extend_from_slice(&(length.min(LIMIT) as u32).to_le_bytes());
        tail.extend_from_slice(&(start.min(LIMIT) as u32).to_le_bytes());
        tail.extend_from_slice(&0u16.to_le_bytes());

        self.emit(&tail)?;
        self.file.flush()?;
        Ok(())
    }

    /// 長さの決まっているエントリを 1 つ書く
    fn put(&mut self, name: &str, method: u16, crc: u32, data: &[u8], uncompressed: u64) -> Result<(), Error> {
        if self.open.is_some() {
            return Err(Error::at("前のエントリを閉じていません", name));
        }

        let offset = self.position;
        let compressed = data.len() as u64;
        let big = compressed >= LIMIT || uncompressed >= LIMIT;
        let header = local_header(name, method, crc, compressed, uncompressed, big);
        self.emit(&header)?;
        self.emit(data)?;

        self.written.push(Written {
            name: name.to_string(),
            method,
            crc,
            compressed,
            uncompressed,
            offset,
        });

        Ok(())
    }

    /// バイト列を書いて、位置を進める
    fn emit(&mut self, data: &[u8]) -> Result<(), Error> {
        self.file.write_all(data)?;
        self.position += data.len() as u64;
        Ok(())
    }

    /// すでに書いたところへ書き戻す
    fn patch(&mut self, offset: u64, data: &[u8]) -> Result<(), Error> {
        self.file.flush()?;
        let file = self.file.get_mut();
        file.seek(SeekFrom::Start(offset))?;
        file.write_all(data)?;
        file.seek(SeekFrom::End(0))?;
        Ok(())
    }
}


/// ローカルヘッダを組み立てる
fn local_header(name: &str, method: u16, crc: u32, compressed: u64, uncompressed: u64, big: bool) -> Vec<u8> {
    let mut header = Vec::with_capacity(30 + name.len() + 20);
    header.extend_from_slice(&0x04034b50u32.to_le_bytes());
    header.extend_from_slice(&(if big {45u16} else {20u16}).to_le_bytes());
    header.extend_from_slice(&flags(name).to_le_bytes());
    header.extend_from_slice(&method.to_le_bytes());
    header.extend_from_slice(&TIME.to_le_bytes());
    header.extend_from_slice(&DATE.to_le_bytes());
    header.extend_from_slice(&crc.to_le_bytes());

    if big {
        header.extend_from_slice(&(LIMIT as u32).to_le_bytes());
        header.extend_from_slice(&(LIMIT as u32).to_le_bytes());
        header.extend_from_slice(&(name.len() as u16).to_le_bytes());
        header.extend_from_slice(&20u16.to_le_bytes());
        header.extend_from_slice(name.as_bytes());
        header.extend_from_slice(&1u16.to_le_bytes());
        header.extend_from_slice(&16u16.to_le_bytes());
        header.extend_from_slice(&uncompressed.to_le_bytes());
        header.extend_from_slice(&compressed.to_le_bytes());
        return header;
    }

    header.extend_from_slice(&(compressed as u32).to_le_bytes());
    header.extend_from_slice(&(uncompressed as u32).to_le_bytes());
    header.extend_from_slice(&(name.len() as u16).to_le_bytes());
    header.extend_from_slice(&0u16.to_le_bytes());
    header.extend_from_slice(name.as_bytes());
    header
}


/// 中央目録の 1 エントリを足す
fn central_header(region: &mut Vec<u8>, one: &Written) {
    let big = one.compressed >= LIMIT || one.uncompressed >= LIMIT || one.offset >= LIMIT;
    let mut extra = Vec::new();

    if big {
        extra.extend_from_slice(&1u16.to_le_bytes());
        extra.extend_from_slice(&24u16.to_le_bytes());
        extra.extend_from_slice(&one.uncompressed.to_le_bytes());
        extra.extend_from_slice(&one.compressed.to_le_bytes());
        extra.extend_from_slice(&one.offset.to_le_bytes());
    }

    region.extend_from_slice(&0x02014b50u32.to_le_bytes());
    region.extend_from_slice(&(if big {45u16} else {20u16}).to_le_bytes());
    region.extend_from_slice(&(if big {45u16} else {20u16}).to_le_bytes());
    region.extend_from_slice(&flags(&one.name).to_le_bytes());
    region.extend_from_slice(&one.method.to_le_bytes());
    region.extend_from_slice(&TIME.to_le_bytes());
    region.extend_from_slice(&DATE.to_le_bytes());
    region.extend_from_slice(&one.crc.to_le_bytes());
    region.extend_from_slice(&(one.compressed.min(LIMIT) as u32).to_le_bytes());
    region.extend_from_slice(&(one.uncompressed.min(LIMIT) as u32).to_le_bytes());
    region.extend_from_slice(&(one.name.len() as u16).to_le_bytes());
    region.extend_from_slice(&(extra.len() as u16).to_le_bytes());
    region.extend_from_slice(&0u16.to_le_bytes());
    region.extend_from_slice(&0u16.to_le_bytes());
    region.extend_from_slice(&0u16.to_le_bytes());
    region.extend_from_slice(&0u32.to_le_bytes());
    region.extend_from_slice(&(one.offset.min(LIMIT) as u32).to_le_bytes());
    region.extend_from_slice(one.name.as_bytes());
    region.extend_from_slice(&extra);
}


/// 名前が ASCII でなければ、UTF-8 の印を立てる
fn flags(name: &str) -> u16 {
    if name.is_ascii() {
        0
    } else {
        0x0800
    }
}