// vtest retry: 3
// vtest build: !windows // fasthttp.Server.run is not implemented on windows yet
import crypto.sha256
import io
import net
import time
import veb

const chunked_multipart_port = 13005

const chunked_multipart_boundary = '----VChunkedMultipartBoundary'
const chunked_multipart_chunk_size = 4096

const chunked_multipart_localserver = '127.0.0.1:${chunked_multipart_port}'

pub struct ChunkedMultipartContext {
	veb.Context
}

pub struct ChunkedMultipartApp {
pub mut:
	started chan bool
}

pub fn (mut app ChunkedMultipartApp) before_accept_loop() {
	app.started <- true
}

@['/upload'; post]
pub fn (mut app ChunkedMultipartApp) upload(mut ctx ChunkedMultipartContext) veb.Result {
	if 'file' !in ctx.files || ctx.files['file'].len == 0 {
		ctx.res.set_status(.bad_request)
		return ctx.text('missing file')
	}
	file := ctx.files['file'][0]
	return ctx.text(sha256.sum256(file.data.bytes()).hex())
}

fn testsuite_begin() {
	mut app := &ChunkedMultipartApp{}
	spawn veb.run_at[ChunkedMultipartApp, ChunkedMultipartContext](mut app,
		port:               chunked_multipart_port
		family:             .ip
		timeout_in_seconds: 10
	)
	_ := <-app.started
}

fn test_large_chunked_multipart_form_upload() {
	payload := make_chunked_multipart_payload(2 * 1024 * 1024)
	expected_hash := sha256.sum256(payload).hex()
	response := send_chunked_multipart_request(payload) or {
		assert false, 'failed to send chunked multipart request: ${err}'
		return
	}
	assert response.starts_with('HTTP/1.1 200 OK')
	assert response.all_after('\r\n\r\n') == expected_hash
}

fn make_chunked_multipart_payload(size int) []u8 {
	mut payload := []u8{len: size}
	for i in 0 .. size {
		payload[i] = u8(i % 256)
	}
	return payload
}

fn send_chunked_multipart_request(payload []u8) !string {
	mut client := net.dial_tcp(chunked_multipart_localserver)!
	defer {
		client.close() or {}
	}
	client.set_read_timeout(10 * time.second)
	client.set_write_timeout(10 * time.second)
	headers := 'POST /upload HTTP/1.1\r\nHost: ${chunked_multipart_localserver}\r\nTransfer-Encoding: chunked\r\nContent-Type: multipart/form-data; boundary=${chunked_multipart_boundary}\r\nConnection: close\r\n\r\n'
	client.write_string(headers)!
	body := build_multipart_body(payload)
	write_chunked_body(mut client, body)!
	return read_response(mut client)
}

fn build_multipart_body(payload []u8) []u8 {
	mut body := []u8{}
	body << '--${chunked_multipart_boundary}\r\n'.bytes()
	body << 'Content-Disposition: form-data; name="file"; filename="payload.bin"\r\n'.bytes()
	body << 'Content-Type: application/octet-stream\r\n\r\n'.bytes()
	body << payload
	body << '\r\n--${chunked_multipart_boundary}--\r\n'.bytes()
	return body
}

fn write_chunked_body(mut client net.TcpConn, body []u8) ! {
	for start := 0; start < body.len; start += chunked_multipart_chunk_size {
		end := if start + chunked_multipart_chunk_size < body.len {
			start + chunked_multipart_chunk_size
		} else {
			body.len
		}
		chunk := body[start..end]
		client.write_string('${chunk.len:x}\r\n')!
		client.write(chunk)!
		client.write_string('\r\n')!
	}
	client.write_string('0\r\n\r\n')!
}

fn read_response(mut client net.TcpConn) !string {
	mut response := []u8{}
	mut buf := []u8{len: 4096}
	for {
		n := client.read(mut buf) or {
			if err is io.Eof {
				break
			}
			return err
		}
		if n == 0 {
			break
		}
		response << buf[..n]
	}
	return response.bytestr()
}