module http

import io
import net
import strings

fn receive_all_data_timeout_cb(_ voidptr, _ &u8, _ int) !int {
	return error_with_code('read timed out', net.err_timed_out_code)
}

fn receive_all_data_eof_cb(_ voidptr, _ &u8, _ int) !int {
	return io.Eof{}
}

struct ReceiveAllDataFixture {
	parts []string
mut:
	index int
}

fn receive_all_data_fixture_cb(con voidptr, buf &u8, bufsize int) !int {
	mut fixture := unsafe { &ReceiveAllDataFixture(con) }
	if fixture.index >= fixture.parts.len {
		return io.Eof{}
	}
	part := fixture.parts[fixture.index].bytes()
	fixture.index++
	assert part.len <= bufsize
	mut out := unsafe { buf.vbytes(bufsize) }
	return copy(mut out, part)
}

struct ProgressBodyCapture {
mut:
	data     []u8
	reads    []u64
	expected []u64
	statuses []int
}

fn receive_all_data_progress_body_cb(request &Request, chunk []u8, body_so_far u64, expected_size u64, status_code int) ! {
	mut capture := unsafe { &ProgressBodyCapture(request.user_ptr) }
	capture.data << chunk
	capture.reads << body_so_far
	capture.expected << expected_size
	capture.statuses << status_code
}

fn test_receive_all_data_from_cb_in_builder_propagates_non_eof_errors() {
	mut req := Request{}
	mut content := strings.new_builder(64)
	req.receive_all_data_from_cb_in_builder(mut content, unsafe { nil },
		receive_all_data_timeout_cb) or {
		assert err.code() == net.err_timed_out_code
		return
	}
	panic('expected a timeout error')
}

fn test_receive_all_data_from_cb_in_builder_stops_on_eof() {
	mut req := Request{}
	mut content := strings.new_builder(64)
	req.receive_all_data_from_cb_in_builder(mut content, unsafe { nil }, receive_all_data_eof_cb) or {
		panic('unexpected error: ${err}')
	}
	assert content.str() == ''
}

fn test_receive_all_data_from_cb_in_builder_dechunks_progress_body_and_parses_truncated_chunked_response() {
	parts := [
		'HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\nContent-Type: text/plain\r\n\r\n4\r\nWi',
		'ki\r\n6',
		'\r\nped',
		'ia!\r\n0\r',
		'\n\r\n',
	]
	full_response := parts.join('')
	mut fixture := ReceiveAllDataFixture{
		parts: parts
	}
	mut capture := ProgressBodyCapture{}
	mut req := Request{
		on_progress_body:   receive_all_data_progress_body_cb
		stop_copying_limit: i64(full_response.len - 1)
		user_ptr:           voidptr(&capture)
	}
	mut content := strings.new_builder(64)
	response_info := req.receive_all_data_from_cb_in_builder(mut content, voidptr(&fixture),
		receive_all_data_fixture_cb)!
	assert response_info.is_chunked_transfer
	assert response_info.has_truncated_body
	assert capture.data.bytestr() == 'Wikipedia!'
	assert capture.reads == [u64(2), 4, 7, 10]
	assert capture.expected == [u64(0), 0, 0, 0]
	assert capture.statuses == [200, 200, 200, 200]
	resp := parse_received_response(content.str(), response_info)!
	assert resp.status_code == 200
	assert resp.body == ''
}

fn test_receive_all_data_from_cb_in_builder_errors_on_premature_eof_with_content_length() {
	mut fixture := ReceiveAllDataFixture{
		parts: [
			'HTTP/1.1 200 OK\r\nContent-Length: 10\r\nContent-Type: text/plain\r\n\r\nhello',
		]
	}
	mut req := Request{}
	mut content := strings.new_builder(64)
	req.receive_all_data_from_cb_in_builder(mut content, voidptr(&fixture),
		receive_all_data_fixture_cb) or {
		assert err.msg().contains('response body ended early')
		assert err.msg().contains('5 of 10 bytes')
		return
	}
	panic('expected an early EOF error for a truncated fixed-length response')
}

fn test_receive_all_data_from_cb_in_builder_errors_on_incomplete_chunked_response() {
	mut fixture := ReceiveAllDataFixture{
		parts: [
			'HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\nContent-Type: text/plain\r\n\r\n4\r\nWi',
			'ki\r\n6\r\nped',
		]
	}
	mut req := Request{}
	mut content := strings.new_builder(64)
	req.receive_all_data_from_cb_in_builder(mut content, voidptr(&fixture),
		receive_all_data_fixture_cb) or {
		assert err.msg() == 'http.request: incomplete chunked response'
		return
	}
	panic('expected an early EOF error for an incomplete chunked response')
}