use errors;
use fmt;
use io;
use net::ip;
use net::uri;
use strconv;
use strings;

// Stores state related to an HTTP request.
//
// For a request to be processable by an HTTP [[client]], i.e. via [[do]], the
// method and target must be filled in appropriately. The target must include at
// least a host, port, and scheme. The default values for other fields are
// suitable if appropriate for the request you wish to perform.
export type request = struct {
	// HTTP request method, e.g. GET
	method: str,
	// Request target URI.
	//
	// Note that the normal constraints for [[uri::parse]] are not upheld in
	// the case of a request using the origin-form (e.g. /index.html), i.e.
	// the scheme field may be empty.
	target: *uri::uri,

	// List of HTTP request headers.
	header: header,

	// Transport configuration, or null to use the [[client]] default.
	transport: nullable *transport,

	// I/O reader for the request body, or void if there is no body.
	body: (io::handle | void),
};

// Frees state associated with an HTTP [[request]].
export fn request_finish(req: *request) void = {
	header_free(&req.header);
	uri::finish(req.target);
	free(req.target);
};

// Creates a new HTTP [[request]] using the given HTTP [[client]] defaults.
export fn new_request(
	client: *client,
	method: str,
	target: *uri::uri,
) (request | errors::unsupported) = {
	let req = request {
		method = method,
		target = alloc(uri::dup(target)),
		header = header_dup(&client.default_header),
		transport = null,
		body = void,
	};
	switch (req.target.scheme) {
	case "http" =>
		if (req.target.port == 0) {
			req.target.port = 80;
		};
	case "https" =>
		if (req.target.port == 0) {
			req.target.port = 443;
		};
	case =>
		return errors::unsupported;
	};

	let host = match (req.target.host) {
	case let host: str =>
		yield host;
	case let ip: ip::addr4 =>
		yield ip::string(ip);
	case let ip: ip::addr6 =>
		static let buf: [64 + 2]u8 = [0...];
		yield fmt::bsprintf(buf, "[{}]", ip::string(ip));
	};

	if (req.target.scheme == "http" && req.target.port != 80) {
		host = fmt::asprintf("{}:{}", host, req.target.port);
	} else if (target.scheme == "https" && target.port != 443) {
		host = fmt::asprintf("{}:{}", host, req.target.port);
	} else {
		host = strings::dup(host);
	};
	defer free(host);
	header_add(&req.header, "Host", host);
	return req;
};

// Creates a new HTTP [[request]] using the given HTTP [[client]] defaults and
// the provided request body.
//
// If the provided I/O handle is seekable, the Content-Length header is added
// automatically. Otherwise, Transfer-Encoding: chunked will be used.
export fn new_request_body(
	client: *client,
	method: str,
	target: *uri::uri,
	body: io::handle,
) (request | errors::unsupported) = {
	let req = new_request(client, method, target)?;
	req.body = body;

	const offs = match (io::seek(body, 0, io::whence::CUR)) {
	case let off: io::off =>
		yield off;
	case io::error =>
		header_add(&req.header, "Transfer-Encoding", "chunked");
		return req;
	};
	const ln = io::seek(body, 0, io::whence::END)!;
	io::seek(body, offs, io::whence::SET)!;
	header_add(&req.header, "Content-Length", strconv::ztos(ln: size));
	return req;
};