extern crate rand;


use super::*;
use self::rand::distributions::{Distribution, Range};
use self::rand::{Rng, FromEntropy};

#[test]
fn line_params_perfect_multiple_of_line_length_lf() {
    let params = line_wrap_parameters(100, 20, lf().len());

    assert_eq!(
        LineWrapParameters {
            line_with_ending_len: 21,
            lines_with_endings: 4,
            last_line_len: 20,
            total_full_wrapped_lines_len: 84,
            total_len: 104,
            total_line_endings_len: 4,
        },
        params
    );
}

#[test]
fn line_params_partial_last_line_crlf() {
    let params = line_wrap_parameters(103, 20, crlf().len());

    assert_eq!(
        LineWrapParameters {
            line_with_ending_len: 22,
            lines_with_endings: 5,
            last_line_len: 3,
            total_full_wrapped_lines_len: 110,
            total_len: 113,
            total_line_endings_len: 10,
        },
        params
    );
}

#[test]
fn line_params_line_len_1_crlf() {
    let params = line_wrap_parameters(100, 1, crlf().len());

    assert_eq!(
        LineWrapParameters {
            line_with_ending_len: 3,
            lines_with_endings: 99,
            last_line_len: 1,
            total_full_wrapped_lines_len: 99 * 3,
            total_len: 99 * 3 + 1,
            total_line_endings_len: 99 * 2,
        },
        params
    );
}

#[test]
fn line_params_line_len_longer_than_input_crlf() {
    let params = line_wrap_parameters(100, 200, crlf().len());

    assert_eq!(
        LineWrapParameters {
            line_with_ending_len: 202,
            lines_with_endings: 0,
            last_line_len: 100,
            total_full_wrapped_lines_len: 0,
            total_len: 100,
            total_line_endings_len: 0,
        },
        params
    );
}

#[test]
fn line_params_line_len_same_as_input_crlf() {
    let params = line_wrap_parameters(100, 100, crlf().len());

    assert_eq!(
        LineWrapParameters {
            line_with_ending_len: 102,
            lines_with_endings: 0,
            last_line_len: 100,
            total_full_wrapped_lines_len: 0,
            total_len: 100,
            total_line_endings_len: 0,
        },
        params
    );
}


#[test]
fn line_wrap_length_1_lf() {
    let mut buf = vec![0x1, 0x2, 0x3, 0x4];

    assert_eq!(3, do_line_wrap(&mut buf, 1, &lf()));

    assert_eq!(vec![0x1, 0xA, 0x2, 0xA, 0x3, 0xA, 0x4], buf);
}

#[test]
fn line_wrap_length_1_crlf() {
    let mut buf = vec![0x1, 0x2, 0x3, 0x4];

    assert_eq!(6, do_line_wrap(&mut buf, 1, &crlf()));

    assert_eq!(vec![0x1, 0xD, 0xA, 0x2, 0xD, 0xA, 0x3, 0xD, 0xA, 0x4], buf);
}

#[test]
fn line_wrap_length_2_lf_full_lines() {
    let mut buf = vec![0x1, 0x2, 0x3, 0x4];

    assert_eq!(1, do_line_wrap(&mut buf, 2, &lf()));

    assert_eq!(vec![0x1, 0x2, 0xA, 0x3, 0x4], buf);
}

#[test]
fn line_wrap_length_2_crlf_full_lines() {
    let mut buf = vec![0x1, 0x2, 0x3, 0x4];

    assert_eq!(2, do_line_wrap(&mut buf, 2, &crlf()));

    assert_eq!(vec![0x1, 0x2, 0xD, 0xA, 0x3, 0x4], buf);
}

#[test]
fn line_wrap_length_2_lf_partial_line() {
    let mut buf = vec![0x1, 0x2, 0x3, 0x4, 0x5];

    assert_eq!(2, do_line_wrap(&mut buf, 2, &lf()));

    assert_eq!(vec![0x1, 0x2, 0xA, 0x3, 0x4, 0xA, 0x5], buf);
}

#[test]
fn line_wrap_length_2_crlf_partial_line() {
    let mut buf = vec![0x1, 0x2, 0x3, 0x4, 0x5];

    assert_eq!(4, do_line_wrap(&mut buf, 2, &crlf()));

    assert_eq!(vec![0x1, 0x2, 0xD, 0xA, 0x3, 0x4, 0xD, 0xA, 0x5], buf);
}

#[test]
fn line_wrap_random_slice() {
    let mut buf: Vec<u8> = Vec::new();
    let buf_range = Range::new(10, 1000);
    let line_range = Range::new(10, 100);
    let mut rng = rand::rngs::SmallRng::from_entropy();
    let mut line_ending_bytes: Vec<u8> = Vec::new();

    for _ in 0..10_000 {
        buf.clear();
        line_ending_bytes.clear();

        let buf_len = buf_range.sample(&mut rng);
        let line_len = line_range.sample(&mut rng);

        for _ in 0..buf_len {
            buf.push(rng.gen());
        }

        line_ending_bytes.clear();
        for _ in 0..rng.gen_range(1, 11) {
            line_ending_bytes.push(rng.gen());
        }
        let line_ending = SliceLineEnding::new(&line_ending_bytes);

        let _ = do_line_wrap(&mut buf, line_len, &line_ending);
    }
}

#[test]
fn line_wrap_random_single_byte() {
    let mut buf: Vec<u8> = Vec::new();
    let buf_range = Range::new(10, 1000);
    let line_range = Range::new(10, 100);
    let mut rng = rand::rngs::SmallRng::from_entropy();

    for _ in 0..10_000 {
        buf.clear();

        let buf_len = buf_range.sample(&mut rng);
        let line_len = line_range.sample(&mut rng);

        for _ in 0..buf_len {
            buf.push(rng.gen());
        }

        let line_ending = ByteLineEnding::new(rng.gen());

        let _ = do_line_wrap(&mut buf, line_len, &line_ending);
    }
}

#[test]
fn line_wrap_random_two_bytes() {
    let mut buf: Vec<u8> = Vec::new();
    let buf_range = Range::new(10, 1000);
    let line_range = Range::new(10, 100);
    let mut rng = rand::rngs::SmallRng::from_entropy();

    for _ in 0..10_000 {
        buf.clear();

        let buf_len = buf_range.sample(&mut rng);
        let line_len = line_range.sample(&mut rng);

        for _ in 0..buf_len {
            buf.push(rng.gen());
        }

        let line_ending = TwoByteLineEnding::new(rng.gen(), rng.gen());

        let _ = do_line_wrap(&mut buf, line_len, &line_ending);
    }
}

fn do_line_wrap<L: LineEnding>(buf: &mut Vec<u8>, line_len: usize, line_ending: &L) -> usize {
    let mut rng = rand::rngs::SmallRng::from_entropy();

    let orig_len = buf.len();
    let orig_buf = buf.to_vec();

    // Add on extra bytes so we'll have sentinel bytes at the end that shouldn't get changed.
    for _ in 0..(1000 + line_ending.len() * orig_len) {
        buf.push(rng.gen());
    }

    let before_line_wrap = buf.to_vec();

    let params = line_wrap_parameters(orig_len, line_len, line_ending.len());

    let bytes_written = line_wrap::<L>(&mut buf[..], orig_len, line_len, line_ending);

    assert_eq!(params.total_line_endings_len, bytes_written);
    assert_eq!(params.lines_with_endings * line_ending.len(), bytes_written);
    assert_eq!(params.total_len, orig_len + bytes_written);

    // make sure line_wrap didn't touch anything beyond what it should
    assert_eq!(before_line_wrap[params.total_len..], buf[params.total_len..]);

    {
        // also make sure that line wrapping will fit into a slice no bigger than what it should
        // need
        let mut buf_strict = before_line_wrap.to_vec();
        buf_strict.truncate(orig_len);
        // fill in some fresh random garbage
        while buf_strict.len() < params.total_len {
            buf_strict.push(rng.gen());
        }
        let bytes_written_precise_fit = line_wrap::<L>(
            &mut buf_strict,
            orig_len,
            line_len,
            line_ending,
        );
        assert_eq!(params.total_len, buf_strict.len());
        assert_eq!(bytes_written, bytes_written_precise_fit);
        assert_eq!(&buf[0..(params.total_len)], &buf_strict[..]);

        // since we have a copy of the wrapped bytes lying around, remove the endings and see
        // if we get the original
        for line_ending_num in 0..params.lines_with_endings {
            let line_ending_offset = (line_ending_num + 1) * line_len;

            for _ in 0..line_ending.len() {
                let _ = buf_strict.remove(line_ending_offset);
            }
        }
        assert_eq!(orig_buf, buf_strict);
    }

    buf.truncate(params.total_len);

    bytes_written
}