use crate::decode::lzbuffer;

use crate::decode::lzbuffer::LzBuffer;

use crate::decode::lzma;

use crate::decode::rangecoder;

use crate::error;

use byteorder::{BigEndian, ReadBytesExt};

use std::io;

use std::io::Read;

pub fn decode_stream<R, W>(input: &mut R, output: &mut W) -> error::Result<()>

where

    R: io::BufRead,

    W: io::Write,

{

    let accum = lzbuffer::LzAccumBuffer::from_stream(output);

    let mut decoder = lzma::new_accum(accum, 0, 0, 0, None);

    loop {

        let status = input

            .read_u8()

            .map_err(|e| error::Error::LzmaError(format!("LZMA2 expected new status: {}", e)))?;

        lzma_info!("LZMA2 status: {}", status);

        if status == 0 {

            lzma_info!("LZMA2 end of input");

            break;

        } else if status == 1 {

            // uncompressed reset dict

            parse_uncompressed(&mut decoder, input, true)?;

        } else if status == 2 {

            // uncompressed no reset

            parse_uncompressed(&mut decoder, input, false)?;

        } else {

            parse_lzma(&mut decoder, input, status)?;

        }

    }

    decoder.output.finish()?;

    Ok(())

}

fn parse_lzma<R, W>(

    decoder: &mut lzma::DecoderState<W, lzbuffer::LzAccumBuffer<W>>,

    input: &mut R,

    status: u8,

) -> error::Result<()>

where

    R: io::BufRead,

    W: io::Write,

{

    if status & 0x80 == 0 {

        return Err(error::Error::LzmaError(format!(

            "LZMA2 invalid status {}, must be 0, 1, 2 or >= 128",

            status

        )));

    }

    let reset_dict: bool;

    let reset_state: bool;

    let reset_props: bool;

    match (status >> 5) & 0x3 {

        0 => {

            reset_dict = false;

            reset_state = false;

            reset_props = false;

        }

        1 => {

            reset_dict = false;

            reset_state = true;

            reset_props = false;

        }

        2 => {

            reset_dict = false;

            reset_state = true;

            reset_props = true;

        }

        3 => {

            reset_dict = true;

            reset_state = true;

            reset_props = true;

        }

        _ => unreachable!(),

    }

    let unpacked_size = input

        .read_u16::<BigEndian>()

        .map_err(|e| error::Error::LzmaError(format!("LZMA2 expected unpacked size: {}", e)))?;

    let unpacked_size = ((((status & 0x1F) as u64) << 16) | (unpacked_size as u64)) + 1;

    let packed_size = input

        .read_u16::<BigEndian>()

        .map_err(|e| error::Error::LzmaError(format!("LZMA2 expected packed size: {}", e)))?;

    let packed_size = (packed_size as u64) + 1;

    lzma_info!(

        "LZMA2 compressed block {{ unpacked_size: {}, packed_size: {}, reset_dict: {}, reset_state: {}, reset_props: {} }}",

        unpacked_size,

        packed_size,

        reset_dict,

        reset_state,

        reset_props

    );

    if reset_dict {

        decoder.output.reset()?;

    }

    if reset_state {

        let lc: u32;

        let lp: u32;

        let mut pb: u32;

        if reset_props {

            let props = input.read_u8().map_err(|e| {

                error::Error::LzmaError(format!("LZMA2 expected new properties: {}", e))

            })?;

            pb = props as u32;

            if pb >= 225 {

                return Err(error::Error::LzmaError(format!(

                    "LZMA2 invalid properties: {} must be < 225",

                    pb

                )));

            }

            lc = pb % 9;

            pb /= 9;

            lp = pb % 5;

            pb /= 5;

            if lc + lp > 4 {

                return Err(error::Error::LzmaError(format!(

                    "LZMA2 invalid properties: lc + lp ({} + {}) must be <= 4",

                    lc, lp

                )));

            }

            lzma_info!("Properties {{ lc: {}, lp: {}, pb: {} }}", lc, lp, pb);

        } else {

            lc = decoder.lc;

            lp = decoder.lp;

            pb = decoder.pb;

        }

        decoder.reset_state(lc, lp, pb);

    }

    decoder.set_unpacked_size(Some(unpacked_size + decoder.output.len() as u64));

    let mut taken = input.take(packed_size);

    let mut rangecoder = rangecoder::RangeDecoder::new(&mut taken)

        .map_err(|e| error::Error::LzmaError(format!("LZMA input too short: {}", e)))?;

    decoder.process(&mut rangecoder)

}

fn parse_uncompressed<R, W>(

    decoder: &mut lzma::DecoderState<W, lzbuffer::LzAccumBuffer<W>>,

    input: &mut R,

    reset_dict: bool,

) -> error::Result<()>

where

    R: io::BufRead,

    W: io::Write,

{

    let unpacked_size = input

        .read_u16::<BigEndian>()

        .map_err(|e| error::Error::LzmaError(format!("LZMA2 expected unpacked size: {}", e)))?;

    let unpacked_size = (unpacked_size as usize) + 1;

    lzma_info!(

        "LZMA2 uncompressed block {{ unpacked_size: {}, reset_dict: {} }}",

        unpacked_size,

        reset_dict

    );

    if reset_dict {

        decoder.output.reset()?;

    }

    let mut buf = vec![0; unpacked_size];

    input.read_exact(buf.as_mut_slice()).map_err(|e| {

        error::Error::LzmaError(format!(

            "LZMA2 expected {} uncompressed bytes: {}",

            unpacked_size, e

        ))

    })?;

    decoder.output.append_bytes(buf.as_slice());

    Ok(())

}