module string_reader

import io

struct Buf {
pub:
    bytes []u8
mut:
    i int
}

struct TwoByteReader {
mut:
    data string
    pos  int
}

fn (mut b Buf) read(mut buf []u8) !int {
    if !(b.i < b.bytes.len) {
        return io.Eof{}
    }
    n := copy(mut buf, b.bytes[b.i..])
    b.i += n
    return n
}

fn (mut r TwoByteReader) read(mut buf []u8) !int {
    if r.pos >= r.data.len {
        return io.Eof{}
    }
    min := int_min(int_min(r.data.len - r.pos, 2), buf.len)
    for i in 0 .. min {
        buf[i] = r.data[r.pos]
        r.pos++
    }
    return min
}

fn read_from_reader_interface(mut r io.Reader, mut buf []u8) !int {
    return r.read(mut buf)
}

fn test_read_all() {
    mut reader := StringReader.new()

    if _ := reader.read_all(false) {
        assert false, 'should return io.Eof'
    } else {
        assert err is io.Eof
    }

    contents := 'test string'
    buf := Buf{
        bytes: contents.bytes()
    }

    reader = StringReader.new(reader: buf)
    data := reader.read_all(false)!

    assert data == contents
}

fn test_read_bytes() {
    mut reader := StringReader.new()

    if _ := reader.read_bytes(4) {
        assert false, 'should return io.Eof'
    } else {
        assert err.msg() == 'reader is not set'
    }

    buf := Buf{
        bytes: '12345678'.bytes()
    }

    reader = StringReader.new(reader: buf)
    mut data := reader.read_bytes(4)!
    assert data == buf.bytes[..4]

    data = reader.read_bytes(4)!
    assert data == buf.bytes[4..8]
}

fn test_read_line() {
    mut reader := StringReader.new()

    if _ := reader.read_line() {
        assert false, 'should return io.Eof'
    } else {
        assert err is io.Eof
    }

    buf := Buf{
        bytes: 'first line\r\nsecond line\n'.bytes()
    }

    reader = StringReader.new(reader: buf)

    assert reader.read_line()! == 'first line'
    assert reader.read_line()! == 'second line'
}

fn test_from_string() {
    mut reader := StringReader.new(source: 'test')
    assert reader.read_all(false)! == 'test'

    if _ := reader.read_all(false) {
        assert false, 'should return Eof'
    } else {
        assert err is io.Eof
    }
}

fn test_read_from_source_read() {
    source := 'line 1\nline 2\n'
    mut reader := StringReader.new(source: source)
    mut buf := []u8{len: 100}
    read := reader.read(mut buf)!
    assert read == source.len
    assert buf[..read].bytestr() == source
    if _ := reader.read(mut buf) {
        assert false, 'should return io.Eof'
    } else {
        assert err is io.Eof
    }
}

fn test_read_from_source_read_via_reader_interface() {
    source := 'line 1\nline 2\n'
    mut reader := StringReader.new(source: source)
    mut buf := []u8{len: 100}
    read := read_from_reader_interface(mut reader, mut buf)!
    assert read == source.len
    assert buf[..read].bytestr() == source
    if _ := read_from_reader_interface(mut reader, mut buf) {
        assert false, 'should return io.Eof'
    } else {
        assert err is io.Eof
    }
}

fn test_from_string_read_byte_one_by_one() {
    mut reader := StringReader.new(source: 'test')
    assert reader.read_bytes(1)![0].ascii_str() == 't'
    assert reader.read_bytes(1)![0].ascii_str() == 'e'
    assert reader.read_bytes(1)![0].ascii_str() == 's'
    assert reader.read_bytes(1)![0].ascii_str() == 't'

    if _ := reader.read_all(false) {
        assert false, 'should return Eof'
    } else {
        assert err is io.Eof
    }
}

fn test_from_string_and_reader() {
    buf := Buf{
        bytes: 'buffer'.bytes()
    }

    mut reader := StringReader.new(reader: buf, source: 'string')

    assert reader.read_all(false)! == 'stringbuffer'
}

fn test_flush() {
    mut reader := StringReader.new(source: 'flushed data')

    str := reader.flush()
    assert str == 'flushed data'

    assert reader.offset == 0
    assert reader.builder.len == 0
}

fn test_fill_buffer_true() {
    mut two := TwoByteReader{
        data: '12345'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.fill_buffer(true)! == 5
    assert reader.get_string() == '12345'
}

fn test_fill_buffer_false() {
    mut two := TwoByteReader{
        data: '12345'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.fill_buffer(false)! == 2
    assert reader.get_string() == '12'
}

fn test_fill_buffer_until() {
    mut two := TwoByteReader{
        data: '12345'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.fill_buffer_until(1)! == 1
    assert reader.builder.len == 1
    assert reader.fill_buffer_until(2)! == 2
    assert reader.builder.len == 3
    assert reader.fill_buffer_until(2)! == 2
    assert reader.builder.len == 5
    assert reader.get_string() == '12345'
}

fn test_fill_buffer_until_one() {
    mut two := TwoByteReader{
        data: '12345'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.fill_buffer_until(1)! == 1
    assert reader.builder.len == 1
    assert reader.fill_buffer_until(1)! == 1
    assert reader.builder.len == 2
    assert reader.fill_buffer_until(1)! == 1
    assert reader.builder.len == 3
    assert reader.fill_buffer_until(1)! == 1
    assert reader.builder.len == 4
    assert reader.fill_buffer_until(1)! == 1
    assert reader.builder.len == 5
    assert reader.get_string() == '12345'
}

fn test_fill_buffer_until_many() {
    mut two := TwoByteReader{
        data: '12345'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.fill_buffer_until(1)! == 1
    assert reader.builder.len == 1
    assert reader.fill_buffer_until(12)! == 4
    assert reader.builder.len == 5
    assert reader.fill_buffer_until(123) or { -1 } == -1
    assert reader.builder.len == 5
    assert reader.get_string() == '12345'
}

fn test_read_all_bytes_false() {
    mut two := TwoByteReader{
        data: '12345'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.read_all_bytes(false)! == [u8(49), 50]
    assert reader.read_all_bytes(false)! == [u8(51), 52]
    assert reader.read_all_bytes(false)! == [u8(53)]
}

fn test_read_all_bytes_true() {
    mut two := TwoByteReader{
        data: '12345'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.read_all_bytes(false)! == [u8(49), 50]
    assert reader.read_all_bytes(true)! == [u8(51), 52, 53]
}

fn test_read_all_false() {
    mut two := TwoByteReader{
        data: '12345'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.read_all(false)! == '12'
    assert reader.read_all(false)! == '34'
    assert reader.read_all(false)! == '5'
}

fn test_read_all_true() {
    mut two := TwoByteReader{
        data: '12345'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.read_all(false)! == '12'
    assert reader.read_all(true)! == '345'
}

fn test_read_bytes_1() {
    mut two := TwoByteReader{
        data: '12345'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.read_bytes(1)! == [u8(49)]
    assert reader.read_bytes(2)! == [u8(50), 51]
    assert reader.read_bytes(2)! == [u8(52), 53]
    assert reader.read_bytes(2) or { [u8(255)] } == [u8(255)]
}

fn test_read_bytes_many() {
    mut two := TwoByteReader{
        data: '12345'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.read_bytes(1)! == [u8(49)]
    assert reader.builder.len == 1
    assert reader.offset == 1
    assert reader.read_bytes(123)! == [u8(50), 51, 52, 53]
    assert reader.builder.len == 5
    assert reader.offset == 5
}

fn test_read_string() {
    mut two := TwoByteReader{
        data: '12345'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.read_string(1)! == '1'
    assert reader.read_string(2)! == '23'
    assert reader.read_string(3)! == '45'
}

fn test_read() {
    mut two := TwoByteReader{
        data: '12345'
    }
    mut reader := StringReader.new(reader: two)
    mut o1 := []u8{len: 1}
    mut o5 := []u8{len: 5}
    mut res := reader.read(mut o1)!
    assert res == 1
    assert o1[..res] == [u8(49)]
    res = reader.read(mut o5)!
    assert res == 4
    assert o5[..res] == [u8(50), 51, 52, 53]
}

fn test_read_many() {
    mut two := TwoByteReader{
        data: '12345'
    }
    mut reader := StringReader.new(reader: two)
    mut o4 := []u8{len: 4}
    mut res := reader.read(mut o4)!
    assert res == 4
    assert o4[..res] == [u8(49), 50, 51, 52]
    res = reader.read(mut o4)!
    assert res == 1
    assert o4[..res] == [u8(53)]
    res = reader.read(mut o4) or { -1 }
    assert res == -1
    assert o4 == [u8(53), 50, 51, 52]
}

fn test_read_line_2() {
    mut two := TwoByteReader{
        data: '12345\n67890'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.read_line()! == '12345'
    assert reader.read_line()! == '67890'
}

fn test_read_line_3() {
    mut two := TwoByteReader{
        data: '12345\t67890'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.read_line(delim: `\t`)! == '12345'
    assert reader.read_line()! == '67890'
}

fn test_read_line_4() {
    mut two := TwoByteReader{
        data: '12345\t67890'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.read_line(delim: `\t`)! == '12345'
    assert reader.read_line(delim: `\t`)! == '67890'
}

fn test_read_line_5() {
    mut two := TwoByteReader{
        data: '\n12345\n67890'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.read_line()! == ''
    assert reader.read_line()! == '12345'
    assert reader.read_line()! == '67890'
}

fn test_read_line_6() {
    mut two := TwoByteReader{
        data: '\r\n12345\r\n67890'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.read_line()! == ''
    assert reader.read_line()! == '12345'
    assert reader.read_line()! == '67890'
}

fn test_read_line_7() {
    mut two := TwoByteReader{
        data: '1234567890'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.read_line(delim: `6`)! == '12345'
    assert reader.read_line(delim: `6`)! == '7890'
    assert reader.read_line() or { '777' } == '777'
}

fn test_read_line_8() {
    mut two := TwoByteReader{
        data: '12345\r\n67890'
    }
    mut reader := StringReader.new(reader: two)
    assert reader.read_bytes(6)! == [u8(49), 50, 51, 52, 53, 13]
    reader.read_line()! // \n
    assert reader.read_line()! == '67890'
}