const MAX_FRAME_DECOMPR_SIZE: u32 = 16;
const MAGIC_SKIPPABLE_START: usize = 0x184D2A50;

const MAX_FRAME_DECOMPR_SIZE: usize = 0x80000000;
const MAGIC_SKIPPABLE_START: u32 = 0x184D2A50;

const SEEKABLE_MAGIC_NUMBER: usize = 0x8F92EAB1;

const SEEKABLE_MAGIC_NUMBER: u32 = 0x8F92EAB1;

    max_frame_size: u32,

    max_frame_size: usize,

    Null,

    Other(&'static str),

    Null,
    FIndexTooLarge(usize, usize),
    Generic,
    InvalidConversion,
    FParamUnsupported(usize, usize),
    PrefixUnknown(u32),
    Corruption(&'static str),
    DSizeTooSmall(usize, usize),

            Error::Null => write!(fmt, "Null"),
            Error::Io(ref e) => e.fmt(fmt),
            Error::CouldNotOpenFile(ref f) => write!(fmt, "Could not open {}", f),

            Error::CouldNotOpenFile(ref f) => write!(fmt, "Could not open file {}.", f),

                write!(fmt, "ZSTD({:?})", error)

                write!(fmt, "ZSTD({:?}).", error)

            Error::Other(ref s) => write!(fmt, "{}", s),

            Error::Io(ref e) => e.fmt(fmt),
            Error::Null => write!(fmt, "Null."),
            Error::FIndexTooLarge(a, b) => write!(
                fmt,
                "Frame index too large. Expected at most {}, found {}.",
                a, b
            ),
            Error::Generic => write!(fmt, "Generic error from ZSTD."),
            Error::InvalidConversion => write!(fmt, "Invalid slice to convert from bytes to u32."),
            Error::FParamUnsupported(a, b) => write!(
                fmt,
                "Frame parameter not supported. Expected at most {}, found {}.",
                a, b
            ),
            Error::PrefixUnknown(p) => write!(fmt, "Prefix unknown {}", p),
            Error::Corruption(ref s) => write!(fmt, "Corruption detected {}.", s),
            Error::DSizeTooSmall(a, b) => write!(
                fmt,
                "Destination size too small. Expected at least {}, found {}.",
                b, a
            ),

    Ok(u32::from_ne_bytes(buff.try_into().map_err(|_| {
        Error::Other("Invalid slice to convert from bytes to u32")
    })?))

    Ok(u32::from_ne_bytes(
        buff.try_into().map_err(|_| Error::InvalidConversion)?,
    ))

    pub fn new(level: usize, frame_size: u32) -> Result<Self, Error> {

    pub fn new(level: usize, frame_size: usize) -> Result<Self, Error> {

            Err(Error::Other("FrameParameterUnsupported"))

            Err(Error::FParamUnsupported(frame_size, MAX_FRAME_DECOMPR_SIZE))

            let result = unsafe { ZSTD_initCStream(cstream, level as c_int) };
            if unsafe { ZSTD_isError(result) } != 0 {
                return Err(Error::ZSTD(result));
            }

            unsafe {
                let result = ZSTD_initCStream(cstream, level as c_int);
                if ZSTD_isError(result) != 0 {
                    return Err(Error::ZSTD(result));
                }
            };

        let len = cmp::min(input.len() as u32, self.max_frame_size - self.frame_d_size);

        let len = cmp::min(
            input.len(),
            self.max_frame_size - self.frame_d_size as usize,
        );

            size: input.len() as size_t,

            size: len,

        if self.max_frame_size == self.frame_d_size {
            let ret = self.end_stream(&mut output)?;

        if self.max_frame_size == self.frame_d_size as usize {
            let ret = self.end_frame(&mut output)?;

    fn end_frame(&mut self, mut output: ZSTD_outBuffer) -> Result<usize, Error> {

    fn end_frame(&mut self, output: &mut ZSTD_outBuffer) -> Result<usize, Error> {

        let ret = unsafe { ZSTD_endStream(self.cstream.p, &mut output) };

        let ret = unsafe { ZSTD_endStream(self.cstream.p, output) };

    pub fn end_stream(&mut self, output: &mut ZSTD_outBuffer) -> Result<usize, Error> {

    pub fn end_stream(&mut self, output: &mut [u8]) -> Result<usize, Error> {
        let mut output_ = ZSTD_outBuffer {
            dst: output.as_mut_ptr() as *mut c_void,
            size: output.len() as size_t,
            pos: 0,
        };

            let end_frame = self.end_frame(*output)?;

            let end_frame = self.end_frame(&mut output_)?;

            } else if end_frame != 0 {

            }
            if end_frame != 0 {

        self.framelog.write_seek_table(output)

        let result = self.framelog.write_seek_table(&mut output_)?;
        if unsafe { ZSTD_isError(result) } != 0 {
            return Err(Error::ZSTD(result));
        }
        Ok(output_.pos as usize)

        unsafe { ZSTD_CStreamInSize() as usize }

        unsafe { ZSTD_CStreamInSize() }

        unsafe { ZSTD_CStreamOutSize() as usize }

        unsafe { ZSTD_CStreamOutSize() }

        let result = unsafe { ZSTD_endStream(self.p, &mut output) };
        if unsafe { ZSTD_isError(result) } != 0 {
            return Err(Error::ZSTD(result));

        unsafe {
            let result = ZSTD_endStream(self.p, &mut output);
            if ZSTD_isError(result) != 0 {
                return Err(Error::ZSTD(result));
            }

        let _result = unsafe { ZSTD_decompressStream(self.p, &mut output, &mut input) };

        unsafe {
            let _result = ZSTD_decompressStream(self.p, &mut output, &mut input);
            if ZSTD_isError(_result) != 0 {
                return Err(Error::ZSTD(_result));
            }
        }

    pub fn init(source: R) -> Result<Self, Error> {
        let mut seekable = Self::make_seekable(source, ptr::null_mut());
        seekable.init_advanced()?;
        Ok(seekable)
    }

        handle.read_exact(&mut self.in_buff)?;

        handle.read(&mut self.in_buff)?;

        if slice_to_num(&self.in_buff[5..9])? as usize != SEEKABLE_MAGIC_NUMBER {
            return Err(Error::Other("PrefixUnknown"));

        let prefix = slice_to_num(&self.in_buff[5..9])?;
        if prefix != SEEKABLE_MAGIC_NUMBER {
            return Err(Error::PrefixUnknown(prefix));

        if ((checksum_flag >> 2) & 0x1f) == 0 {
            return Err(Error::Other("CorruptionDetected"));

        if ((checksum_flag >> 2) & 0x1f) != 0 {
            return Err(Error::Corruption("when looking the checksum flag"));

        handle.read_exact(&mut self.in_buff)?;

        handle.read(&mut self.in_buff)?;

        if slice_to_num(&self.in_buff[..4])? as usize != (MAGIC_SKIPPABLE_START | 0xE) {
            return Err(Error::Other("PrefixUnknown"));

        let mut prefix = slice_to_num(&self.in_buff[..4])?;
        if prefix != (MAGIC_SKIPPABLE_START | 0xE) {
            return Err(Error::PrefixUnknown(prefix));

        if slice_to_num(&self.in_buff[4..8])? as usize + SKIPPABLE_HEADER_SIZE != frame_size {
            return Err(Error::Other("PrefixUnknown"));

        prefix = slice_to_num(&self.in_buff[4..8])?;
        if prefix as usize + SKIPPABLE_HEADER_SIZE != frame_size {
            return Err(Error::PrefixUnknown(prefix));

                let offset = SEEKABLE_BUFF_SIZE;

                let offset = SEEKABLE_BUFF_SIZE - pos;

                // FIXME: if pointer arithmetic replace, this needs to change
                handle.read_exact(unsafe {
                    slice::from_raw_parts_mut(buffer_ptr.add(offset), to_read)
                })?;

                // FIXME: if pointer arithmetic were to be replaced, this needs to change
                handle
                    .read(unsafe { slice::from_raw_parts_mut(buffer_ptr.add(offset), to_read) })?;

            entries[idx].c_offset = c_offset;
            entries[idx].d_offset = d_offset;
            c_offset += slice_to_num(&self.in_buff[pos..pos + 4])? as usize;

            entries.push(SeekEntry {
                c_offset,
                d_offset,
                checksum: 0,
            });
            
            let a = slice_to_num(&self.in_buff[pos..pos + 4])? as usize;
            c_offset += a;

        entries[num_frames].c_offset = c_offset;
        entries[num_frames].d_offset = d_offset;

        entries.push(SeekEntry {
            c_offset,
            d_offset,
            checksum: 0,
        });

        let dstream_init = unsafe { ZSTD_initDStream(self.dstream) };
        if unsafe { ZSTD_isError(dstream_init) } != 0 {
            Err(Error::ZSTD(dstream_init))
        } else {
            Ok(())

        unsafe {
            let dstream_init = ZSTD_initDStream(self.dstream);
            if ZSTD_isError(dstream_init) != 0 {
                return Err(Error::ZSTD(dstream_init));
            } else {
                Ok(())
            }

            return Err(Error::Other("DestinationSizeTooSmall"));

            Err(Error::DSizeTooSmall(dest.len(), dec_size))
        } else {
            self.decompress(
                dest,
                dec_size,
                self.seek_table.entries[index].d_offset as u64,
            )

        self.decompress(
            dest,
            dec_size,
            self.seek_table.entries[index].d_offset as u64,
        )

        let dst = out.as_mut_ptr();

                        dst: dst as *mut c_void,

                        dst: out.as_mut_ptr() as *mut c_void,

                let mut to_read =
                    unsafe { ZSTD_decompressStream(self.dstream, &mut out_tmp, &mut self.inn) };
                if unsafe { ZSTD_isError(to_read) } != 0 {
                    return Err(Error::ZSTD(to_read));
                }

                let mut to_read;
                unsafe {
                    to_read = ZSTD_decompressStream(self.dstream, &mut out_tmp, &mut self.inn);
                    if ZSTD_isError(to_read) != 0 {
                        return Err(Error::ZSTD(to_read));
                    }
                };

                        return Err(Error::Other("CorruptionDetected"));

                        return Err(Error::Corruption("during decompression"));

                    handle
                        .read_exact(&mut self.in_buff)
                        .map_err(|_| Error::Other("Not able to read buffer"))?;

                    handle.read(&mut self.in_buff)?;

            if self.decompressed_offset != offset + len as u64 {

            if self.decompressed_offset == offset + len as u64 {

        let mut seekable = Seekable::make_seekable(source, ptr::null_mut());
        seekable.init_advanced()?;
        Ok(seekable)
    }
}
impl<R: io::Read + io::Seek> Seekable<R> {
    /// Initialise a decompressor with a file. This method opens the file, and dropping the resulting `Seekable` closes the file.
    pub fn init(source: R) -> Result<Self, Error> {

    // TODO: implement this properly
    // pub fn into_inner(self) -> Box<R> {
    //     *self.src
    // }

        self.seek_table.entries.len()

        self.seek_table.entries.len() - 1

        if frame_index >= self.get_num_frames() {
            Err(Error::Other("FrameIndexTooLarge"))

        let max_frames = self.get_num_frames();
        if frame_index >= max_frames {
            Err(Error::FIndexTooLarge(frame_index, max_frames))

        if frame_index >= self.get_num_frames() {
            Err(Error::Other("FrameIndexTooLarge"))

        let max_frames = self.get_num_frames();
        if frame_index >= max_frames {
            Err(Error::FIndexTooLarge(frame_index, max_frames))

        if frame_index >= self.get_num_frames() {
            Err(Error::Other("FrameIndexTooLarge"))

        let max_frames = self.get_num_frames();
        if frame_index >= max_frames {
            Err(Error::FIndexTooLarge(frame_index, max_frames))

        if frame_index > self.get_num_frames() {
            Err(Error::Other("FrameIndexTooLarge"))

        let max_frames = self.get_num_frames();
        if frame_index >= max_frames {
            Err(Error::FIndexTooLarge(frame_index, max_frames))

            Ok(self.seek_table.entries[frame_index + 1].d_offset
                - self.seek_table.entries[frame_index].d_offset)

            let r = self.seek_table.entries[frame_index + 1].d_offset
            - self.seek_table.entries[frame_index].d_offset;
            Ok(r)

        ZSTD_compress(

        let ret = ZSTD_compress(

        )
    };

        );

    if unsafe { ZSTD_isError(ret) } != 0 {
        return Err(Error::ZSTD(ret));
    }

        if ZSTD_isError(ret) != 0 {
            return Err(Error::ZSTD(ret));
        }

    println!("{:?}", dst.as_slice());

        ret
    };

        if self.entries.len() == SEEKABLE_MAXFRAMES {
            return Err(Error::Other("FrameIndexTooLarge"));

        let size = self.entries.len();
        if size == SEEKABLE_MAXFRAMES {
            return Err(Error::FIndexTooLarge(size, SEEKABLE_MAXFRAMES as usize));

    pub fn stwrite32(&self, output: &mut ZSTD_outBuffer, value: usize, offset: usize) -> usize {
        if (self.seek_table_pos as usize) < offset + 4 {
            let tmp = value.to_ne_bytes();

    pub fn stwrite32(&mut self, output: &mut ZSTD_outBuffer, value: u32, offset: u32) -> usize {
        if self.seek_table_pos < offset + 4 {

                offset + 4 - self.seek_table_pos as usize,

                (offset + 4 - self.seek_table_pos) as usize,

                ptr::copy_nonoverlapping(
                    tmp.as_ptr().add(self.seek_table_pos as usize - offset) as *const usize,
                    output.dst.add(output.pos) as *mut usize,
                    len_write,
                )
            };

                let base = output.dst.add(output.pos) as *mut u8;
                ptr::copy(value.to_ne_bytes().as_ptr(),base,len_write);
            }

            self.seek_table_pos += len_write as u32;

        ret = self.stwrite32(output, table_len - SKIPPABLE_HEADER_SIZE, 4);

        ret = self.stwrite32(output, (table_len - SKIPPABLE_HEADER_SIZE) as u32, 4);

            let start = SKIPPABLE_HEADER_SIZE + size_p_frame * i;

            let start = (SKIPPABLE_HEADER_SIZE + size_p_frame * i) as u32;

            ret = self.stwrite32(output, self.entries[i].c_size as usize, start);

            ret = self.stwrite32(output, self.entries[i].c_size, start);

            ret = self.stwrite32(output, self.entries[i].d_size as usize, start + 4);

            ret = self.stwrite32(output, self.entries[i].d_size, start + 4);

                ret = self.stwrite32(output, self.entries[i].checksum as usize, start + 8);

                ret = self.stwrite32(output, self.entries[i].checksum as u32, start + 8);

            self.entries.len(),
            table_len - SEEK_TABLE_FOOTER_SIZE,

            self.entries.len() as u32,
            (table_len - SEEK_TABLE_FOOTER_SIZE) as u32,

        if (self.seek_table_pos as usize) < table_len {

        if (self.seek_table_pos as usize) < (table_len - 4) {

            array
                .get_mut(output.pos)
                .map(|el| *el = sfd)
                .ok_or(Error::Other("index out of bounds"))?;

            array[output.pos] = sfd;

            self.seek_table_pos += 1;

        ret = self.stwrite32(output, SEEKABLE_MAGIC_NUMBER, table_len - 4);

        ret = self.stwrite32(output, SEEKABLE_MAGIC_NUMBER, (table_len - 4) as u32);

        if self.seek_table_pos as usize != table_len {
            Err(Error::Other("Generic error from ZSTD"))

        if (self.seek_table_pos as usize) != table_len {
            Err(Error::Generic)

        output.write_all(frame.as_slice())?;
        log.log_frame(frame.src_size, frame.dst_size, frame.checksum)?;

        let t = frame.as_slice();
        output.write_all(t)?;
        log.log_frame(frame.dst_size, frame.src_size, frame.checksum)?;

    let mut s = { Seekable::init_buf(&mut output).unwrap() };

    let mut s = Seekable::init_buf(&mut output).unwrap();

        s.decompress_frame(&mut decomp[n..], frame).unwrap();

        if let Err(_) = s.decompress_frame(&mut decomp[n..], frame) {
            println!("Error in frame {}", frame);
        }

#[test]
fn test() {
    let mut cstream = SeekableCStream::new(10, 256).unwrap();
    let input = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut diam ante, sollicitudin a dolor et, volutpat elementum nulla. Etiam nec efficitur nibh, quis rutrum risus. Maecenas quis lorem malesuada, aliquet mi vel, viverra nunc. Donec et nulla sed velit sagittis varius. Suspendisse vestibulum, neque lobortis ornare vestibulum, orci turpis vulputate nisi, ut sodales neque purus eget magna. Nunc condimentum, diam eu consequat venenatis, est nisl semper lorem, et lobortis velit justo sed nulla. Nunc sit amet tempor nunc, vel posuere ipsum. Cras erat tortor, pulvinar ac pretium eu, auctor ac nibh. Duis iaculis porta magna, eu lobortis elit. Duis vitae massa eros. Nulla non magna accumsan, egestas quam sit amet, laoreet lectus.";
    let mut input_pos = 0;
    let mut output = vec![0; input.len()];
    let mut output_pos = 0;
    while input_pos < input.len() {
        let (a, b) = cstream
            .compress(&mut output[output_pos..], &input[input_pos..])
            .unwrap();
        output_pos += a;
        input_pos += b;
        
    }

// #[test]
// fn test() {
//     let mut cstream = SeekableCStream::new(10, 256).unwrap();
//     let input = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut diam ante, sollicitudin a dolor et, volutpat elementum nulla. Etiam nec efficitur nibh, quis rutrum risus. Maecenas quis lorem malesuada, aliquet mi vel, viverra nunc. Donec et nulla sed velit sagittis varius. Suspendisse vestibulum, neque lobortis ornare vestibulum, orci turpis vulputate nisi, ut sodales neque purus eget magna. Nunc condimentum, diam eu consequat venenatis, est nisl semper lorem, et lobortis velit justo sed nulla. Nunc sit amet tempor nunc, vel posuere ipsum. Cras erat tortor, pulvinar ac pretium eu, auctor ac nibh. Duis iaculis porta magna, eu lobortis elit. Duis vitae massa eros. Nulla non magna accumsan, egestas quam sit amet, laoreet lectus.";
//     let mut input_pos = 0;
//     let mut output = vec![0; input.len()];
//     let mut output_pos = 0;
//     while input_pos < input.len() {
//         let (a, b) = cstream
//             .compress(&mut output[output_pos..], &input[input_pos..])
//             .unwrap();
//         output_pos += a;
//         input_pos += b;
//     }
//     while let Ok(n) = cstream.end_stream(&mut output[output_pos..]) {
//         if n == 0 {
//             break;
//         }
//         output_pos += n;
//     }
//     output.truncate(output_pos);
//     {
//         use std::io::Write;
//         let mut file = std::fs::File::create("test").unwrap();
//         file.write_all(&output).unwrap();
//     }
//     println!("input len = {:?}, pos = {:?}", input.len(), output_pos);

    let mut output_stream = ZSTD_outBuffer {
        dst: output[output_pos..].as_mut_ptr() as *mut c_void,
        size: output.len() - output_pos as size_t,
        pos: 0,
    };
    while let Ok(n) = cstream.end_stream(&mut output_stream) {
        if n == 0 {
            break;
        }
        output_pos += n;
    }
    output.truncate(output_pos);
    {
        use io::Write;
        let mut file = fs::File::create("test").unwrap();
        file.write_all(&output).unwrap();
    }
    println!("input len = {:?}, pos = {:?}", input.len(), output_pos);
    let mut decomp = Vec::new();
    let mut s = { Seekable::init_buf(&mut output).unwrap() };
    for frame in 0..s.get_num_frames() {
        let size = s.get_frame_decompressed_size(frame).unwrap();
        println!("{:?} {:?}", size, s.get_frame_decompressed_offset(frame));
        let n = decomp.len();
        decomp.extend(std::iter::repeat(0).take(size));
        s.decompress_frame(&mut decomp[n..], frame).unwrap();
    }
    println!("{:?}", std::str::from_utf8(&decomp).unwrap());
    assert_eq!(&input[..], &decomp[..])
}

//     let mut decomp = Vec::new();
//     let mut s = { Seekable::init_buf(&mut output).unwrap() };
//     for frame in 0..s.get_num_frames() {
//         let size = s.get_frame_decompressed_size(frame).unwrap();
//         println!("{:?} {:?}", size, s.get_frame_decompressed_offset(frame).unwrap());
//         let n = decomp.len();
//         decomp.extend(std::iter::repeat(0).take(size));
//         s.decompress_frame(&mut decomp[n..], frame).unwrap();
//     }
//     println!("{:?}", std::str::from_utf8(&decomp).unwrap());
//     assert_eq!(&input[..], &decomp[..])
// }