use crate::hpack::{Decoder, Encoder, Header};

use http::header::{HeaderName, HeaderValue};

use bytes::BytesMut;
use quickcheck::{Arbitrary, Gen, QuickCheck, TestResult};
use rand::distributions::Slice;
use rand::rngs::StdRng;
use rand::{thread_rng, Rng, SeedableRng};

use std::io::Cursor;

const MAX_CHUNK: usize = 2 * 1024;

#[test]
fn hpack_fuzz() {
    let _ = env_logger::try_init();
    fn prop(fuzz: FuzzHpack) -> TestResult {
        fuzz.run();
        TestResult::from_bool(true)
    }

    QuickCheck::new()
        .tests(100)
        .quickcheck(prop as fn(FuzzHpack) -> TestResult)
}

/*
// If wanting to test with a specific feed, uncomment and fill in the seed.
#[test]
fn hpack_fuzz_seeded() {
    let _ = env_logger::try_init();
    let seed = [/* fill me in*/];
    FuzzHpack::new(seed).run();
}
*/

#[derive(Debug, Clone)]
struct FuzzHpack {
    // The set of headers to encode / decode
    frames: Vec<HeaderFrame>,
}

#[derive(Debug, Clone)]
struct HeaderFrame {
    resizes: Vec<usize>,
    headers: Vec<Header<Option<HeaderName>>>,
}

impl FuzzHpack {
    fn new(seed: [u8; 32]) -> FuzzHpack {
        // Seed the RNG
        let mut rng = StdRng::from_seed(seed);

        // Generates a bunch of source headers
        let mut source: Vec<Header<Option<HeaderName>>> = vec![];

        for _ in 0..2000 {
            source.push(gen_header(&mut rng));
        }

        // Actual test run headers
        let num: usize = rng.gen_range(40..500);

        let mut frames: Vec<HeaderFrame> = vec![];
        let mut added = 0;

        let skew: i32 = rng.gen_range(1..5);

        // Rough number of headers to add
        while added < num {
            let mut frame = HeaderFrame {
                resizes: vec![],
                headers: vec![],
            };

            match rng.gen_range(0..20) {
                0 => {
                    // Two resizes
                    let high = rng.gen_range(128..MAX_CHUNK * 2);
                    let low = rng.gen_range(0..high);

                    frame.resizes.extend([low, high]);
                }
                1..=3 => {
                    frame.resizes.push(rng.gen_range(128..MAX_CHUNK * 2));
                }
                _ => {}
            }

            let mut is_name_required = true;

            for _ in 0..rng.gen_range(1..(num - added) + 1) {
                let x: f64 = rng.gen_range(0.0..1.0);
                let x = x.powi(skew);

                let i = (x * source.len() as f64) as usize;

                let header = &source[i];
                match header {
                    Header::Field { name: None, .. } => {
                        if is_name_required {
                            continue;
                        }
                    }
                    Header::Field { .. } => {
                        is_name_required = false;
                    }
                    _ => {
                        // pseudos can't be followed by a header with no name
                        is_name_required = true;
                    }
                }

                frame.headers.push(header.clone());

                added += 1;
            }

            frames.push(frame);
        }

        FuzzHpack { frames }
    }

    fn run(self) {
        let frames = self.frames;
        let mut expect = vec![];

        let mut encoder = Encoder::default();
        let mut decoder = Decoder::default();

        for frame in frames {
            // build "expected" frames, such that decoding headers always
            // includes a name
            let mut prev_name = None;
            for header in &frame.headers {
                match header.clone().reify() {
                    Ok(h) => {
                        prev_name = match h {
                            Header::Field { ref name, .. } => Some(name.clone()),
                            _ => None,
                        };
                        expect.push(h);
                    }
                    Err(value) => {
                        expect.push(Header::Field {
                            name: prev_name.as_ref().cloned().expect("previous header name"),
                            value,
                        });
                    }
                }
            }

            let mut buf = BytesMut::new();

            if let Some(max) = frame.resizes.iter().max() {
                decoder.queue_size_update(*max);
            }

            // Apply resizes
            for resize in &frame.resizes {
                encoder.update_max_size(*resize);
            }

            encoder.encode(frame.headers, &mut buf);

            // Decode the chunk!
            decoder
                .decode(&mut Cursor::new(&mut buf), |h| {
                    let e = expect.remove(0);
                    assert_eq!(h, e);
                })
                .expect("full decode");
        }

        assert_eq!(0, expect.len());
    }
}

impl Arbitrary for FuzzHpack {
    fn arbitrary(_: &mut Gen) -> Self {
        FuzzHpack::new(thread_rng().gen())
    }
}

fn gen_header(g: &mut StdRng) -> Header<Option<HeaderName>> {
    use http::{Method, StatusCode};

    if g.gen_ratio(1, 10) {
        match g.gen_range(0u32..5) {
            0 => {
                let value = gen_string(g, 4, 20);
                Header::Authority(to_shared(value))
            }
            1 => {
                let method = match g.gen_range(0u32..6) {
                    0 => Method::GET,
                    1 => Method::POST,
                    2 => Method::PUT,
                    3 => Method::PATCH,
                    4 => Method::DELETE,
                    5 => {
                        let n: usize = g.gen_range(3..7);
                        let bytes: Vec<u8> = (0..n)
                            .map(|_| *g.sample(Slice::new(b"ABCDEFGHIJKLMNOPQRSTUVWXYZ").unwrap()))
                            .collect();

                        Method::from_bytes(&bytes).unwrap()
                    }
                    _ => unreachable!(),
                };

                Header::Method(method)
            }
            2 => {
                let value = match g.gen_range(0u32..2) {
                    0 => "http",
                    1 => "https",
                    _ => unreachable!(),
                };

                Header::Scheme(to_shared(value.to_string()))
            }
            3 => {
                let value = match g.gen_range(0u32..100) {
                    0 => "/".to_string(),
                    1 => "/index.html".to_string(),
                    _ => gen_string(g, 2, 20),
                };

                Header::Path(to_shared(value))
            }
            4 => {
                let status = (g.gen::<u16>() % 500) + 100;

                Header::Status(StatusCode::from_u16(status).unwrap())
            }
            _ => unreachable!(),
        }
    } else {
        let name = if g.gen_ratio(1, 10) {
            None
        } else {
            Some(gen_header_name(g))
        };
        let mut value = gen_header_value(g);

        if g.gen_ratio(1, 30) {
            value.set_sensitive(true);
        }

        Header::Field { name, value }
    }
}

fn gen_header_name(g: &mut StdRng) -> HeaderName {
    use http::header;

    if g.gen_ratio(1, 2) {
        g.sample(
            Slice::new(&[
                header::ACCEPT,
                header::ACCEPT_CHARSET,
                header::ACCEPT_ENCODING,
                header::ACCEPT_LANGUAGE,
                header::ACCEPT_RANGES,
                header::ACCESS_CONTROL_ALLOW_CREDENTIALS,
                header::ACCESS_CONTROL_ALLOW_HEADERS,
                header::ACCESS_CONTROL_ALLOW_METHODS,
                header::ACCESS_CONTROL_ALLOW_ORIGIN,
                header::ACCESS_CONTROL_EXPOSE_HEADERS,
                header::ACCESS_CONTROL_MAX_AGE,
                header::ACCESS_CONTROL_REQUEST_HEADERS,
                header::ACCESS_CONTROL_REQUEST_METHOD,
                header::AGE,
                header::ALLOW,
                header::ALT_SVC,
                header::AUTHORIZATION,
                header::CACHE_CONTROL,
                header::CONNECTION,
                header::CONTENT_DISPOSITION,
                header::CONTENT_ENCODING,
                header::CONTENT_LANGUAGE,
                header::CONTENT_LENGTH,
                header::CONTENT_LOCATION,
                header::CONTENT_RANGE,
                header::CONTENT_SECURITY_POLICY,
                header::CONTENT_SECURITY_POLICY_REPORT_ONLY,
                header::CONTENT_TYPE,
                header::COOKIE,
                header::DNT,
                header::DATE,
                header::ETAG,
                header::EXPECT,
                header::EXPIRES,
                header::FORWARDED,
                header::FROM,
                header::HOST,
                header::IF_MATCH,
                header::IF_MODIFIED_SINCE,
                header::IF_NONE_MATCH,
                header::IF_RANGE,
                header::IF_UNMODIFIED_SINCE,
                header::LAST_MODIFIED,
                header::LINK,
                header::LOCATION,
                header::MAX_FORWARDS,
                header::ORIGIN,
                header::PRAGMA,
                header::PROXY_AUTHENTICATE,
                header::PROXY_AUTHORIZATION,
                header::PUBLIC_KEY_PINS,
                header::PUBLIC_KEY_PINS_REPORT_ONLY,
                header::RANGE,
                header::REFERER,
                header::REFERRER_POLICY,
                header::REFRESH,
                header::RETRY_AFTER,
                header::SERVER,
                header::SET_COOKIE,
                header::STRICT_TRANSPORT_SECURITY,
                header::TE,
                header::TRAILER,
                header::TRANSFER_ENCODING,
                header::USER_AGENT,
                header::UPGRADE,
                header::UPGRADE_INSECURE_REQUESTS,
                header::VARY,
                header::VIA,
                header::WARNING,
                header::WWW_AUTHENTICATE,
                header::X_CONTENT_TYPE_OPTIONS,
                header::X_DNS_PREFETCH_CONTROL,
                header::X_FRAME_OPTIONS,
                header::X_XSS_PROTECTION,
            ])
            .unwrap(),
        )
        .clone()
    } else {
        let value = gen_string(g, 1, 25);
        HeaderName::from_bytes(value.as_bytes()).unwrap()
    }
}

fn gen_header_value(g: &mut StdRng) -> HeaderValue {
    let value = gen_string(g, 0, 70);
    HeaderValue::from_bytes(value.as_bytes()).unwrap()
}

fn gen_string(g: &mut StdRng, min: usize, max: usize) -> String {
    let bytes: Vec<_> = (min..max)
        .map(|_| {
            // Chars to pick from
            *g.sample(Slice::new(b"ABCDEFGHIJKLMNOPQRSTUVabcdefghilpqrstuvwxyz----").unwrap())
        })
        .collect();

    String::from_utf8(bytes).unwrap()
}

fn to_shared(src: String) -> crate::hpack::BytesStr {
    crate::hpack::BytesStr::from(src.as_str())
}