import bitfield
import rand

fn test_bf_new_size() {
    instance := bitfield.new(75)
    assert instance.get_size() == 75
}

fn test_bf_set_clear_toggle_get() {
    mut instance := bitfield.new(75)
    instance.set_bit(47)
    assert instance.get_bit(47) == 1
    instance.clear_bit(47)
    assert instance.get_bit(47) == 0
    instance.toggle_bit(47)
    assert instance.get_bit(47) == 1
    instance.set_if(true, 48)
    assert instance.get_bit(48) == 1
    instance.set_if(false, 48)
    assert instance.get_bit(48) == 0
}

fn test_bf_multiple_flags() {
    mut instance := bitfield.new(75)

    // 1,3,5,7,9 set
    instance.set_bits(1, 3, 5, 7, 9)
    assert instance.all(1, 3, 5, 7, 9)
    assert instance.all(1, 3, 20) == false
    assert instance.has(1, 20, 30, 40)
    assert instance.has(20, 30, 40) == false

    // 1,3 set
    instance.clear_bits(5, 7, 9)
    assert instance.all(1, 3, 5, 7, 9) == false
    assert instance.all(1, 3)
    assert instance.has(3, 20, 30, 40)

    // 3,5,7 set
    instance.toggle_bits(1, 5, 7)
    assert instance.all(3, 5, 7)
    assert instance.all(1, 3, 5, 7) == false
    assert instance.has(5, 20, 30, 40)
}

fn test_bf_insert_extract() {
    mut instance := bitfield.new(11)
    instance.set_all()
    instance.insert(2, 9, 3)
    assert instance.extract(2, 1) == 0
    assert instance.extract(2, 8) == 1
    assert instance.extract(10, 1) == 1
    instance.set_all()
    instance.insert_lowest_bits_first(2, 9, 3)
    assert instance.extract_lowest_bits_first(2, 1) == 1
    assert instance.extract_lowest_bits_first(2, 8) == 3
    assert instance.extract_lowest_bits_first(10, 1) == 0
}

fn test_bf_and_not_or_xor() {
    len := 80
    mut input1 := bitfield.new(len)
    mut input2 := bitfield.new(len)
    mut i := 0
    for i < len {
        if rand.intn(2) or { 0 } == 1 {
            input1.set_bit(i)
        }
        if rand.intn(2) or { 0 } == 1 {
            input2.set_bit(i)
        }
        i++
    }
    output1 := bitfield.bf_xor(input1, input2)
    bf_and := bitfield.bf_and(input1, input2)
    bf_or := bitfield.bf_or(input1, input2)
    bf_not := bitfield.bf_not(bf_and)
    output2 := bitfield.bf_and(bf_or, bf_not)
    mut result := 1
    i = 0
    for i < len {
        if output1.get_bit(i) != output2.get_bit(i) {
            result = 0
        }
        i++
    }
    assert result == 1
}

fn test_clone_cmp() {
    len := 80
    mut input := bitfield.new(len)
    for i in 0 .. len {
        if rand.intn(2) or { 0 } == 1 {
            input.set_bit(i)
        }
    }
    output := input.clone()
    assert output.get_size() == len
    assert input == output
}

fn test_slice_join() {
    len := 80
    mut input := bitfield.new(len)
    for i in 0 .. len {
        if rand.intn(2) or { 0 } == 1 {
            input.set_bit(i)
        }
    }
    mut result := 1
    for point := 1; point < (len - 1); point++ {
        // divide a bitfield into two subfields
        chunk1 := input.slice(0, point)
        chunk2 := input.slice(point, input.get_size())
        // concatenate them back into one and compare to the original
        output := bitfield.join(chunk1, chunk2)
        if input != output {
            result = 0
        }
    }
    assert result == 1
}

fn test_pop_count() {
    len := 80
    mut count0 := 0
    mut input := bitfield.new(len)
    for i in 0 .. len {
        if rand.intn(2) or { 0 } == 1 {
            input.set_bit(i)
            count0++
        }
    }
    count1 := input.pop_count()
    assert count0 == count1
}

fn test_pop_count2() {
    b :=
        bitfield.from_str('011000110110110000010001000011010011011111011110101001010011011010001100001001101111111011010011')
    assert b.pop_count() == 50
}

fn test_hamming() {
    len := 80
    mut count := 0
    mut input1 := bitfield.new(len)
    mut input2 := bitfield.new(len)
    for i in 0 .. len {
        match rand.intn(4) {
            0, 1 {
                input1.set_bit(i)
                count++
            }
            2 {
                input2.set_bit(i)
                count++
            }
            3 {
                input1.set_bit(i)
                input2.set_bit(i)
            }
            else {}
        } or { 0 }
    }
    assert count == bitfield.hamming(input1, input2)
}

fn test_bf_from_bytes() {
    input := [u8(0x01), 0xF0, 0x0F, 0xF0, 0xFF]
    output := bitfield.from_bytes(input).str()
    assert output == '00000001' + '11110000' + '00001111' + '11110000' + '11111111'
    newoutput := bitfield.from_str(output).str()
    assert newoutput == output
}

fn test_bf_from_bytes_lowest_bits_first() {
    input := [u8(0x01), 0xF0]
    output := bitfield.from_bytes_lowest_bits_first(input).str()
    assert output == '10000000' + '00001111'
    newoutput := bitfield.from_str(output).str()
    assert newoutput == output
}

fn test_bf_from_str() {
    len := 80
    mut input := ''
    for _ in 0 .. len {
        if rand.intn(2) or { 0 } == 1 {
            input = input + '1'
        } else {
            input = input + '0'
        }
    }
    output := bitfield.from_str(input)
    mut result := 1
    for i in 0 .. len {
        if input[i] != output.get_bit(i) + 48 {
            result = 0
        }
    }
    assert result == 1
}

fn test_bf_bf2str() {
    len := 80
    mut input := bitfield.new(len)
    for i in 0 .. len {
        if rand.intn(2) or { 0 } == 1 {
            input.set_bit(i)
        }
    }
    mut check := ''
    for i in 0 .. len {
        if input.get_bit(i) == 1 {
            check = check + '1'
        } else {
            check = check + '0'
        }
    }
    output := input.str()
    mut result := 1
    for i in 0 .. len {
        if check[i] != output[i] {
            result = 0
        }
    }
    assert result == 1
}

fn test_bf_set_all() {
    len := 80
    mut input := bitfield.new(len)
    input.set_all()
    mut result := 1
    for i in 0 .. len {
        if input.get_bit(i) != 1 {
            result = 0
        }
    }
    assert result == 1
}

fn test_bf_clear_all() {
    len := 80
    mut input := bitfield.new(len)
    for i in 0 .. len {
        if rand.intn(2) or { 0 } == 1 {
            input.set_bit(i)
        }
    }
    input.clear_all()
    mut result := 1
    for i in 0 .. len {
        if input.get_bit(i) != 0 {
            result = 0
        }
    }
    assert result == 1
}

fn test_bf_reverse() {
    len := 80
    mut input := bitfield.new(len)
    for i in 0 .. len {
        if rand.intn(2) or { 0 } == 1 {
            input.set_bit(i)
        }
    }
    check := input.clone()
    output := input.reverse()
    mut result := 1
    for i in 0 .. len {
        if output.get_bit(i) != check.get_bit(len - i - 1) {
            result = 0
        }
    }
    assert result == 1
}

fn test_bf_resize() {
    len := 80
    mut input := bitfield.new(rand.intn(len) or { 0 } + 1)
    for _ in 0 .. 100 {
        input.resize(rand.intn(len) or { 0 } + 1)
        input.set_bit(input.get_size() - 1)
    }
    assert input.get_bit(input.get_size() - 1) == 1
}

fn test_bf_pos() {
    /*
    *
     * set haystack size to 80
     * test different sizes of needle, from 1 to 80
     * test different positions of needle, from 0 to where it fits
     * all haystacks here contain exactly one instance of needle,
     * so search should return non-negative-values
    *
    */
    len := 80
    mut result := 1
    for i := 1; i < len; i++ { // needle size
        for j in 0 .. len - i { // needle position in the haystack
            // create the needle
            mut needle := bitfield.new(i)
            // fill the needle with random values
            for k in 0 .. i {
                if rand.intn(2) or { 0 } == 1 {
                    needle.set_bit(k)
                }
            }
            // make sure the needle contains at least one set bit, selected randomly
            r := rand.intn(i) or { 0 }
            needle.set_bit(r)
            // create the haystack, make sure it contains the needle
            mut haystack := needle.clone()
            // if there is space between the start of the haystack and the sought needle, fill it with zeroes
            if j > 0 {
                start := bitfield.new(j)
                tmp := bitfield.join(start, haystack)
                haystack = tmp
            }
            // if there is space between the sought needle and the end of haystack, fill it with zeroes
            if j + i < len {
                end := bitfield.new(len - j - i)
                tmp2 := bitfield.join(haystack, end)
                haystack = tmp2
            }
            // now let's test
            // the result should be equal to j
            if haystack.pos(needle) != j {
                result = 0
            }
        }
    }
    assert result == 1
}

fn test_bf_rotate() {
    mut result := 1
    len := 80
    for i := 1; i < 80 && result == 1; i++ {
        mut chunk1 := bitfield.new(i)
        chunk2 := bitfield.new(len - i)
        chunk1.set_all()
        input := bitfield.join(chunk1, chunk2)
        output := input.rotate(i)
        if output.get_bit(len - i - 1) != 0 || output.get_bit(len - i) != 1 {
            result = 0
        }
    }
    assert result == 1
}

fn test_bf_printing() {
    len := 80
    mut input := bitfield.new(len)
    for i in 0 .. len {
        if rand.intn(2) or { 0 } == 0 {
            input.set_bit(i)
        }
    }
    // the following should convert the bitfield input into a string automatically
    println(input)
    assert true
}

fn test_bf_shift() {
    str := '0001001101111111'
    bf := bitfield.from_str(str)
    bf_left := bf.shift_left(4)
    assert bf_left.str() == '0011011111110000'
    bf_right := bf.shift_right(4)
    assert bf_right.str() == '0000000100110111'

    bf_large_left := bf.shift_left(100)
    bf_large_right := bf.shift_right(100)
    assert bf_large_left.str() == '0000000000000000'
    assert bf_large_right.str() == '0000000000000000'
}

// Regression test: zero-length slice must not panic (reported via slice(i,i) and pos(new(0))).
fn test_zero_length_slice_and_pos() {
    // slice(i, i) on a non-empty bitfield must return an empty bitfield
    bf := bitfield.from_str('101')
    empty := bf.slice(1, 1)
    assert empty.get_size() == 0
    assert empty.str() == ''

    // pos with a zero-length needle on a non-empty bitfield must not panic
    needle := bitfield.new(0)
    pos := bf.pos(needle)
    // empty needle matches at position 0 by convention
    assert pos == 0

    // pos on a zero-length bitfield with a zero-length needle must not panic
    empty_bf := bitfield.new(0)
    assert empty_bf.pos(needle) == 0
}