// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

use std::{cmp::min, mem};

use crate::codec::Decoder;

#[derive(Clone, Debug, Default)]
pub struct IncrementalDecoderUint {
    v: u64,
    remaining: Option<usize>,
}

impl IncrementalDecoderUint {
    #[must_use]
    pub fn min_remaining(&self) -> usize {
        self.remaining.unwrap_or(1)
    }

    /// Consume some data.
    ///
    /// # Panics
    ///
    /// Never, but this is not something the compiler can tell.
    pub fn consume(&mut self, dv: &mut Decoder) -> Option<u64> {
        if let Some(r) = &mut self.remaining {
            let amount = min(*r, dv.remaining());
            if amount < 8 {
                self.v <<= amount * 8;
            }
            self.v |= dv.decode_uint(amount).unwrap();
            *r -= amount;
            if *r == 0 {
                Some(self.v)
            } else {
                None
            }
        } else {
            let (v, remaining) = dv.decode_byte().map_or_else(
                || unreachable!(),
                |b| {
                    (
                        u64::from(b & 0x3f),
                        match b >> 6 {
                            0 => 0,
                            1 => 1,
                            2 => 3,
                            3 => 7,
                            _ => unreachable!(),
                        },
                    )
                },
            );
            self.remaining = Some(remaining);
            self.v = v;
            if remaining == 0 {
                Some(v)
            } else {
                None
            }
        }
    }

    #[must_use]
    pub const fn decoding_in_progress(&self) -> bool {
        self.remaining.is_some()
    }
}

#[derive(Clone, Debug)]
pub struct IncrementalDecoderBuffer {
    v: Vec<u8>,
    remaining: usize,
}

impl IncrementalDecoderBuffer {
    #[must_use]
    pub const fn new(n: usize) -> Self {
        Self {
            v: Vec::new(),
            remaining: n,
        }
    }

    #[must_use]
    pub const fn min_remaining(&self) -> usize {
        self.remaining
    }

    /// Consume some bytes from the decoder.
    ///
    /// # Panics
    ///
    /// Never; but rust doesn't know that.
    pub fn consume(&mut self, dv: &mut Decoder) -> Option<Vec<u8>> {
        let amount = min(self.remaining, dv.remaining());
        let b = dv.decode(amount).unwrap();
        self.v.extend_from_slice(b);
        self.remaining -= amount;
        if self.remaining == 0 {
            Some(mem::take(&mut self.v))
        } else {
            None
        }
    }
}

#[derive(Clone, Debug)]
pub struct IncrementalDecoderIgnore {
    remaining: usize,
}

impl IncrementalDecoderIgnore {
    /// Make a new ignoring decoder.
    ///
    /// # Panics
    ///
    /// If the amount to ignore is zero.
    #[must_use]
    pub fn new(n: usize) -> Self {
        assert_ne!(n, 0);
        Self { remaining: n }
    }

    #[must_use]
    pub const fn min_remaining(&self) -> usize {
        self.remaining
    }

    pub fn consume(&mut self, dv: &mut Decoder) -> bool {
        let amount = min(self.remaining, dv.remaining());
        _ = dv.decode(amount);
        self.remaining -= amount;
        self.remaining == 0
    }
}

#[cfg(test)]
mod tests {
    use super::{
        Decoder, IncrementalDecoderBuffer, IncrementalDecoderIgnore, IncrementalDecoderUint,
    };
    use crate::codec::Encoder;

    #[test]
    fn buffer_incremental() {
        let b = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
        let mut dec = IncrementalDecoderBuffer::new(b.len());
        let mut i = 0;
        while i < b.len() {
            // Feed in b in increasing-sized chunks.
            let incr = if i < b.len() / 2 { i + 1 } else { b.len() - i };
            let mut dv = Decoder::from(&b[i..i + incr]);
            i += incr;
            match dec.consume(&mut dv) {
                None => {
                    assert!(i < b.len());
                }
                Some(res) => {
                    assert_eq!(i, b.len());
                    assert_eq!(res, b);
                }
            }
        }
    }

    struct UintTestCase {
        b: String,
        v: u64,
    }

    impl UintTestCase {
        pub fn run(&self) {
            eprintln!(
                "IncrementalDecoderUint decoder with {:?} ; expect {:?}",
                self.b, self.v
            );

            let decoder = IncrementalDecoderUint::default();
            let mut db = Encoder::from_hex(&self.b);
            // Add padding so that we can verify that the reader doesn't over-consume.
            db.encode_byte(0xff);

            for tail in 1..db.len() {
                let split = db.len() - tail;
                let mut dv = Decoder::from(&db.as_ref()[0..split]);
                eprintln!("  split at {split}: {dv:?}");

                // Clone the basic decoder for each iteration of the loop.
                let mut dec = decoder.clone();
                let mut res = None;
                while dv.remaining() > 0 {
                    res = dec.consume(&mut dv);
                }
                assert!(dec.min_remaining() < tail);

                if tail > 1 {
                    assert_eq!(res, None);
                    assert!(dec.min_remaining() > 0);
                    let mut dv = Decoder::from(&db.as_ref()[split..]);
                    eprintln!("  split remainder {split}: {dv:?}");
                    res = dec.consume(&mut dv);
                    assert_eq!(dv.remaining(), 1);
                }

                assert_eq!(dec.min_remaining(), 0);
                assert_eq!(res.unwrap(), self.v);
            }
        }
    }

    macro_rules! uint_tc {
        [$( $b:expr => $v:expr ),+ $(,)?] => {
            vec![ $( UintTestCase { b: String::from($b), v: $v, } ),+]
        };
    }

    #[test]
    fn varint() {
        for c in uint_tc![
            "00" => 0,
            "01" => 1,
            "3f" => 63,
            "4040" => 64,
            "7fff" => 16383,
            "80004000" => 16384,
            "bfffffff" => (1 << 30) - 1,
            "c000000040000000" => 1 << 30,
            "ffffffffffffffff" => (1 << 62) - 1,
        ] {
            c.run();
        }
    }

    #[test]
    fn zero_len() {
        let enc = Encoder::from_hex("ff");
        let mut dec = Decoder::new(enc.as_ref());
        let mut incr = IncrementalDecoderBuffer::new(0);
        assert_eq!(incr.consume(&mut dec), Some(Vec::new()));
        assert_eq!(dec.remaining(), enc.len());
    }

    #[test]
    fn ignore() {
        let db = Encoder::from_hex("12345678ff");

        let decoder = IncrementalDecoderIgnore::new(4);

        for tail in 1..db.len() {
            let split = db.len() - tail;
            let mut dv = Decoder::from(&db.as_ref()[0..split]);
            eprintln!("  split at {split}: {dv:?}");

            // Clone the basic decoder for each iteration of the loop.
            let mut dec = decoder.clone();
            let mut res = dec.consume(&mut dv);
            assert_eq!(dv.remaining(), 0);
            assert!(dec.min_remaining() < tail);

            if tail > 1 {
                assert!(!res);
                assert!(dec.min_remaining() > 0);
                let mut dv = Decoder::from(&db.as_ref()[split..]);
                eprintln!("  split remainder {split}: {dv:?}");
                res = dec.consume(&mut dv);
                assert_eq!(dv.remaining(), 1);
            }

            assert_eq!(dec.min_remaining(), 0);
            assert!(res);
        }
    }
}