zenzop 0.4.2

use enough::Stop;

use crate::{CompressResult, DeflateEncoder, Error, Options, Write};

/// A Gzip encoder powered by the Zopfli algorithm, that compresses data using
/// a [`DeflateEncoder`]. Most users will find using [`compress`](crate::compress)
/// easier and more performant.
///
/// The caveats about short writes in [`DeflateEncoder`]s carry over to `GzipEncoder`s:
/// for best performance and compression, it is best to avoid them. One way to ensure
/// this is to use the [`new_buffered`](GzipEncoder::new_buffered) method.
pub struct GzipEncoder<W: Write, S: Stop = enough::Unstoppable> {
    deflate_encoder: Option<DeflateEncoder<W, S>>,
    crc32_hasher: zenflate::Crc32Hasher,
    input_size: u32,
}

impl<W: Write> GzipEncoder<W> {
    /// Creates a new Gzip encoder that will operate according to the
    /// specified options.
    pub fn new(options: Options, mut sink: W) -> Result<Self, Error> {
        static HEADER: &[u8] = &[
            31,  // ID1
            139, // ID2
            8,   // CM
            0,   // FLG
            0,   // MTIME
            0, 0, 0, 2, // XFL, 2 indicates best compression.
            3, // OS follows Unix conventions.
        ];

        sink.write_all(HEADER)?;

        Ok(Self {
            deflate_encoder: Some(DeflateEncoder::new(options, sink)),
            crc32_hasher: zenflate::Crc32Hasher::new(),
            input_size: 0,
        })
    }

    /// Creates a new Gzip encoder that operates according to the specified
    /// options and is wrapped with a buffer to guarantee that data is
    /// compressed in large chunks, which is necessary for decent performance
    /// and good compression ratio.
    #[cfg(feature = "std")]
    pub fn new_buffered(options: Options, sink: W) -> Result<std::io::BufWriter<Self>, Error> {
        Ok(std::io::BufWriter::with_capacity(
            crate::util::ZOPFLI_MASTER_BLOCK_SIZE,
            Self::new(options, sink)?,
        ))
    }
}

impl<W: Write, S: Stop> GzipEncoder<W, S> {
    /// Creates a new Gzip encoder with cooperative cancellation, wrapped
    /// with a buffer for decent performance.
    #[cfg(feature = "std")]
    pub fn with_stop_buffered(
        options: Options,
        sink: W,
        stop: S,
    ) -> Result<std::io::BufWriter<Self>, Error> {
        Ok(std::io::BufWriter::with_capacity(
            crate::util::ZOPFLI_MASTER_BLOCK_SIZE,
            Self::with_stop(options, sink, stop)?,
        ))
    }

    /// Creates a new Gzip encoder with cooperative cancellation support.
    pub fn with_stop(options: Options, mut sink: W, stop: S) -> Result<Self, Error> {
        static HEADER: &[u8] = &[
            31,  // ID1
            139, // ID2
            8,   // CM
            0,   // FLG
            0,   // MTIME
            0, 0, 0, 2, // XFL, 2 indicates best compression.
            3, // OS follows Unix conventions.
        ];

        sink.write_all(HEADER)?;

        Ok(Self {
            deflate_encoder: Some(DeflateEncoder::with_stop(options, sink, stop)),
            crc32_hasher: zenflate::Crc32Hasher::new(),
            input_size: 0,
        })
    }

    /// Encodes any pending chunks of data and writes them to the sink,
    /// consuming the encoder and returning the wrapped sink. The sink
    /// will have received a complete Gzip stream when this method
    /// returns.
    ///
    /// The encoder is automatically [`finish`](Self::finish)ed when
    /// dropped, but explicitly finishing it with this method allows
    /// handling I/O errors.
    pub fn finish(mut self) -> Result<CompressResult<W>, Error> {
        self.__finish().map(|sink| sink.unwrap())
    }

    fn __finish(&mut self) -> Result<Option<CompressResult<W>>, Error> {
        if self.deflate_encoder.is_none() {
            return Ok(None);
        }

        let mut result = self.deflate_encoder.take().unwrap().finish()?;

        result
            .inner
            .write_all(&self.crc32_hasher.finalize().to_le_bytes())?;
        result.inner.write_all(&self.input_size.to_le_bytes())?;

        Ok(Some(result))
    }

    /// Gets a reference to the underlying writer.
    ///
    /// # Panics
    ///
    /// Panics if called after [`finish()`](Self::finish).
    pub fn get_ref(&self) -> &W {
        self.deflate_encoder.as_ref().unwrap().get_ref()
    }

    /// Gets a mutable reference to the underlying writer.
    ///
    /// Note that mutating the output/input state of the stream may corrupt
    /// this object, so care must be taken when using this method.
    ///
    /// # Panics
    ///
    /// Panics if called after [`finish()`](Self::finish).
    pub fn get_mut(&mut self) -> &mut W {
        self.deflate_encoder.as_mut().unwrap().get_mut()
    }
}

impl<W: Write, S: Stop> core::fmt::Debug for GzipEncoder<W, S> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("GzipEncoder")
            .field("input_size", &self.input_size)
            .finish_non_exhaustive()
    }
}

impl<W: Write, S: Stop> Write for GzipEncoder<W, S> {
    fn write(&mut self, buf: &[u8]) -> Result<usize, Error> {
        self.deflate_encoder
            .as_mut()
            .unwrap()
            .write(buf)
            .inspect(|&bytes_written| {
                self.crc32_hasher.update(&buf[..bytes_written]);
                self.input_size = self.input_size.wrapping_add(bytes_written as u32);
            })
    }

    fn flush(&mut self) -> Result<(), Error> {
        self.deflate_encoder.as_mut().unwrap().flush()
    }
}

impl<W: Write, S: Stop> Drop for GzipEncoder<W, S> {
    fn drop(&mut self) {
        self.__finish().ok();
    }
}

// Boilerplate to make latest Rustdoc happy: https://github.com/rust-lang/rust/issues/117796
#[cfg(all(doc, feature = "std"))]
impl<W: crate::io::Write, S: Stop> std::io::Write for GzipEncoder<W, S> {
    fn write(&mut self, _buf: &[u8]) -> std::io::Result<usize> {
        unimplemented!()
    }

    fn flush(&mut self) -> std::io::Result<()> {
        unimplemented!()
    }
}