import io
import x.json2 as json

struct ChunkedReader {
	data       []u8
	chunk_size int
mut:
	pos int
}

fn (mut r ChunkedReader) read(mut buf []u8) !int {
	if r.pos >= r.data.len {
		return io.Eof{}
	}
	mut n := r.chunk_size
	remaining := r.data.len - r.pos
	if n > remaining {
		n = remaining
	}
	if n > buf.len {
		n = buf.len
	}
	read := copy(mut buf[..n], r.data[r.pos..r.pos + n])
	r.pos += read
	return read
}

fn test_public_scanner_iterates_tokens() {
	mut scanner := json.new_scanner('{"items":[1,true,null,"x"]}')
	mut got := []string{}
	for {
		token := scanner.next()!
		got << '${token.kind}:${token.literal()}'
		if token.is_eof() {
			break
		}
	}
	assert got == [
		'lcbr:',
		'str:items',
		'colon:',
		'lsbr:',
		'int:1',
		'comma:',
		'bool:true',
		'comma:',
		'null:null',
		'comma:',
		'str:x',
		'rsbr:',
		'rcbr:',
		'eof:',
	]
}

fn test_reader_scanner_iterates_tokens() {
	mut reader := ChunkedReader{
		data:       '[10,true,"chunked",null]'.bytes()
		chunk_size: 2
	}
	mut scanner := json.new_reader_scanner(reader: reader, buffer_size: 3)
	defer {
		scanner.free()
	}
	mut got := []string{}
	for {
		token := scanner.next()!
		got << '${token.kind}:${token.literal()}'
		if token.is_eof() {
			break
		}
	}
	assert got == [
		'lsbr:',
		'int:10',
		'comma:',
		'bool:true',
		'comma:',
		'str:chunked',
		'comma:',
		'null:null',
		'rsbr:',
		'eof:',
	]
}

fn test_reader_scanner_reports_errors() {
	mut reader := ChunkedReader{
		data:       r'["\z"]'.bytes()
		chunk_size: 1
	}
	mut scanner := json.new_reader_scanner(reader: reader, buffer_size: 1)
	defer {
		scanner.free()
	}
	assert scanner.next()!.kind == .lsbr
	scanner.next() or {
		assert err.msg().contains('invalid backslash escape')
		return
	}
	assert false
}