// Matrix Construct
//
// Copyright (C) Matrix Construct Developers, Authors & Contributors
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice is present in all copies. The
// full license for this software is available in the LICENSE file.

namespace ircd::http
{
	using reason_codes = std::unordered_map<http::code, string_view>;
	using expectation_failure = spirit::qi::expectation_failure<const char *>;

	[[clang::internal_linkage, clang::always_destroy]]
	extern const reason_codes reason;

	[[noreturn]]
	static void throw_error(const expectation_failure &, const bool & = false);
}

BOOST_FUSION_ADAPT_STRUCT
(
    ircd::http::query,
    ( decltype(ircd::http::query::first),   first  )
    ( decltype(ircd::http::query::second),  second )
)

BOOST_FUSION_ADAPT_STRUCT
(
    ircd::http::header,
    ( decltype(ircd::http::header::first),   first  )
    ( decltype(ircd::http::header::second),  second )
)

BOOST_FUSION_ADAPT_STRUCT
(
    ircd::http::line::response,
    ( decltype(ircd::http::line::response::version),  version )
    ( decltype(ircd::http::line::response::status),   status  )
    ( decltype(ircd::http::line::response::reason),   reason  )
)

BOOST_FUSION_ADAPT_STRUCT
(
    ircd::http::line::request,
    ( decltype(ircd::http::line::request::method),    method   )
    ( decltype(ircd::http::line::request::path),      path     )
    ( decltype(ircd::http::line::request::query),     query    )
    ( decltype(ircd::http::line::request::fragment),  fragment )
    ( decltype(ircd::http::line::request::version),   version  )
)

decltype(ircd::http::reason)
ircd::http::reason
{
	{ code::CONTINUE,                            "Continue"                                        },
	{ code::SWITCHING_PROTOCOLS,                 "Switching Protocols"                             },
	{ code::PROCESSING,                          "Processing"                                      },
	{ code::EARLY_HINTS,                         "Early Hints"                                     },

	{ code::OK,                                  "OK"                                              },
	{ code::CREATED,                             "Created"                                         },
	{ code::ACCEPTED,                            "Accepted"                                        },
	{ code::NON_AUTHORITATIVE_INFORMATION,       "Non-Authoritative Information"                   },
	{ code::NO_CONTENT,                          "No Content"                                      },
	{ code::PARTIAL_CONTENT,                     "Partial Content"                                 },

	{ code::MULTIPLE_CHOICES,                    "Multiple Choices"                                },
	{ code::MOVED_PERMANENTLY,                   "Moved Permanently"                               },
	{ code::FOUND,                               "Found"                                           },
	{ code::SEE_OTHER,                           "See Other"                                       },
	{ code::NOT_MODIFIED,                        "Not Modified"                                    },
	{ code::USE_PROXY,                           "Use Proxy"                                       },
	{ code::SWITCH_PROXY,                        "Switch Proxy"                                    },
	{ code::TEMPORARY_REDIRECT,                  "Temporary Redirect"                              },
	{ code::PERMANENT_REDIRECT,                  "Permanent Redirect"                              },

	{ code::BAD_REQUEST,                         "Bad Request"                                     },
	{ code::UNAUTHORIZED,                        "Unauthorized"                                    },
	{ code::FORBIDDEN,                           "Forbidden"                                       },
	{ code::NOT_FOUND,                           "Not Found"                                       },
	{ code::METHOD_NOT_ALLOWED,                  "Method Not Allowed"                              },
	{ code::NOT_ACCEPTABLE,                      "Not Acceptable"                                  },
	{ code::REQUEST_TIMEOUT,                     "Request Time-out"                                },
	{ code::CONFLICT,                            "Conflict"                                        },
	{ code::GONE,                                "Gone"                                            },
	{ code::LENGTH_REQUIRED,                     "Length Required"                                 },
	{ code::PAYLOAD_TOO_LARGE,                   "Payload Too Large"                               },
	{ code::REQUEST_URI_TOO_LONG,                "Request URI Too Long"                            },
	{ code::UNSUPPORTED_MEDIA_TYPE,              "Unsupported Media Type"                          },
	{ code::RANGE_NOT_SATISFIABLE,               "Range Not Satisfiable"                           },
	{ code::EXPECTATION_FAILED,                  "Expectation Failed"                              },
	{ code::IM_A_TEAPOT,                         "Negative, I Am A Meat Popsicle"                  },
	{ code::UNPROCESSABLE_ENTITY,                "Unprocessable Entity"                            },
	{ code::PRECONDITION_REQUIRED,               "Precondition Required"                           },
	{ code::TOO_MANY_REQUESTS,                   "Too Many Requests"                               },
	{ code::REQUEST_HEADER_FIELDS_TOO_LARGE,     "Request Header Fields Too Large"                 },

	{ code::INTERNAL_SERVER_ERROR,               "Internal Server Error"                           },
	{ code::NOT_IMPLEMENTED,                     "Not Implemented"                                 },
	{ code::BAD_GATEWAY,                         "Bad Gateway"                                     },
	{ code::SERVICE_UNAVAILABLE,                 "Service Unavailable"                             },
	{ code::GATEWAY_TIMEOUT,                     "Gateway Timeout"                                 },
	{ code::HTTP_VERSION_NOT_SUPPORTED,          "HTTP Version Not Supported"                      },
	{ code::INSUFFICIENT_STORAGE,                "Insufficient Storage"                            },

	{ code::CLOUDFLARE_REFUSED,                  "Cloudflare Customer Connection Refused"          },
	{ code::CLOUDFLARE_TIMEDOUT,                 "Cloudflare Customer Connection Timed-out"        },
	{ code::CLOUDFLARE_UNREACHABLE,              "Cloudflare Customer Unreachable"                 },
	{ code::CLOUDFLARE_REQUEST_TIMEOUT,          "Cloudflare Customer Request Time-out"            },
};

namespace ircd::http::parser
{
	using namespace ircd::spirit;

	template<class R = unused_type,
	         class... S>
	struct [[clang::internal_linkage]] rule
	:qi::rule<const char *, R, S...>
	{
		using qi::rule<const char *, R, S...>::rule;
	};

	const expr NUL                     { lit('\0')                                          ,"nul" };

	// insignificant whitespaces
	const expr SP                      { lit('\x20')                                      ,"space" };
	const expr HT                      { lit('\x09')                             ,"horizontal tab" };
	const expr ws                      { SP | HT                                     ,"whitespace" };

	const expr CR                      { lit('\x0D')                            ,"carriage return" };
	const expr LF                      { lit('\x0A')                                  ,"line feed" };
	const expr CRLF                    { CR >> LF                    ,"carriage return, line feed" };

	const expr illegal                 { NUL | CR | LF                                  ,"illegal" };
	const expr colon                   { lit(':')                                         ,"colon" };
	const expr slash                   { lit('/')                               ,"forward solidus" };
	const expr question                { lit('?')                                 ,"question mark" };
	const expr pound                   { lit('#')                                    ,"pound sign" };
	const expr equal                   { lit('=')                                    ,"equal sign" };
	const expr ampersand               { lit('&')                                     ,"ampersand" };

	const rule<string_view> token      { raw[+(char_ - (illegal | ws))]                   ,"token" };
	const rule<string_view> str        { raw[+(char_ - illegal)]                         ,"string" };
	const rule<string_view> line       { *ws >> -str >> CRLF                               ,"line" };

	const rule<string_view> status     { raw[repeat(3)[char_('0','9')]]                  ,"status" };
	const rule<string_view> reason     { str                                             ,"reason" };

	const rule<string_view> head_key   { raw[+(char_ - (illegal | ws | colon))]        ,"head key" };
	const rule<string_view> head_val   { -str                                        ,"head value" };
	const rule<http::header> header    { head_key >> *ws >> colon >> *ws >> head_val     ,"header" };
	const rule<> headers               { header % (*ws >> CRLF)                         ,"headers" };

	const expr query_terminator        { equal | question | ampersand | pound  ,"query terminator" };
	const expr query_illegal           { illegal | ws | query_terminator          ,"query illegal" };
	const rule<string_view> query_key  { raw[+(char_ - query_illegal)]                ,"query key" };
	const rule<string_view> query_val  { raw[*(char_ - query_illegal)]              ,"query value" };

	const rule<string_view> method     { token                                           ,"method" };
	const rule<string_view> path       { raw[-slash >> *(char_ - query_illegal)]           ,"path" };
	const rule<string_view> fragment   { pound >> -token                               ,"fragment" };
	const rule<string_view> version    { token                                          ,"version" };

	const rule<size_t> content_size    { ulong_                                  ,"content length" };
	const rule<uint32_t> chunk_size
	{
		qi::uint_parser<uint32_t, 16, 1, 8>{}
		,"chunk size"
	};

	const rule<string_view> chunk_extensions
	{
		';' >> raw[str]             //TODO: extensions
		,"chunk extensions"
	};

	const rule<http::query> query
	{
		query_key >> -(equal >> query_val)
		,"query"
	};

	const rule<string_view> query_string
	{
		question >> -raw[(query_key >> -(equal >> query_val)) % ampersand]
		,"query string"
	};

	const rule<line::request> request_line
	{
		method >> +SP >> path >> -query_string >> -fragment >> +SP >> version
		,"request line"
	};

	const rule<line::response> response_line
	{
		version >> +SP >> status >> -(+SP >> -reason)
		,"response line"
	};

	const rule<> request
	{
		request_line >> *ws >> CRLF >> -headers >> CRLF
		,"request"
	};

	const rule<> response
	{
		response_line >> *ws >> CRLF >> -headers >> CRLF
		,"response"
	};

	static size_t content_length(const string_view &val);
}

/// Compose a request. This prints an HTTP head into the buffer. No real IO is
/// done here. After composing into the buffer, the user can then drive the
/// socket by sending the header and the content as specified.
///
/// If termination is false, no extra CRLF is printed to the buffer allowing
/// additional headers not specified to be appended later.
ircd::http::request::request(window_buffer &out,
                             const string_view &host,
                             const string_view &method,
                             const string_view &uri,
                             const size_t &content_length,
                             const string_view &content_type,
                             const vector_view<const header> &headers,
                             const bool &termination)
{
	writeline(out, [&method, &uri](const mutable_buffer &out) -> size_t
	{
		assert(!method.empty());
		assert(!uri.empty());
		return fmt::sprintf
		{
			out, "%s %s HTTP/1.1", method, uri
		};
	});

	if(!has(headers, "host"))
		writeline(out, [&host](const mutable_buffer &out) -> size_t
		{
			assert(!host.empty());
			return fmt::sprintf
			{
				out, "Host: %s", host
			};
		});

	if(content_length && !has(headers, "content-type"))
		writeline(out, [&content_type](const mutable_buffer &out) -> size_t
		{
			return fmt::sprintf
			{
				out, "Content-Type: %s", content_type?: "text/plain; charset=utf-8"
			};
		});

	if(!has(headers, "content-length"))
		writeline(out, [&content_length](const mutable_buffer &out) -> size_t
		{
			return fmt::sprintf
			{
				out, "Content-Length: %zu", content_length
			};
		});

	// Note: pass your own user-agent with an empty value to mute this header.
	if(!has(headers, "user-agent") && info::user_agent)
		writeline(out, [](const mutable_buffer &out) -> size_t
		{
			return fmt::sprintf
			{
				out, "User-Agent: %s", info::user_agent
			};
		});

	write(out, headers);

	if(termination)
		writeline(out);
}

namespace ircd::http
{
	static void assign(request::head &, const header &);
}

ircd::http::request::head::head(parse::capstan &pc,
                                const headers::closure &closure)
:line::request{pc}
,uri
{
	fragment? string_view { begin(path), end(fragment) }:
	query?    string_view { begin(path), end(query)    }:
	          string_view { begin(path), end(path)     }
}
,headers{[this, &pc, &closure]
{
	const bool version_compatible
	{
		this->version == "HTTP/1.0" ||
		this->version == "HTTP/1.1"
	};

	if(unlikely(!version_compatible))
		throw error
		{
			HTTP_VERSION_NOT_SUPPORTED, fmt::snstringf
			{
				128, "Sorry, no speak '%s'. Try HTTP/1.1 here.",
				this->version
			}
		};

	return http::headers
	{
		pc, [this, &closure](const auto &header)
		{
			assign(*this, header);
			if(likely(closure))
				closure(header);
		}
	};
}()}
{
}

ircd::http::request::head::operator
string_view()
const
{
	const string_view request_line
	{
		static_cast<const line::request &>(*this)
	};

	if(request_line.empty() || headers.empty())
		return request_line;

	return string_view
	{
		request_line.begin(), headers.end()
	};
}

void
ircd::http::assign(request::head &head,
                   const header &header)
{
	char buf[64];
	const auto &[key_, val] {header};
	assert(size(key_) <= sizeof(buf));
	const auto &key
	{
		tolower(buf, key_)
	};

	if(key == "content-length"_sv)
		head.content_length = parser::content_length(val);

	else if(key == "host"_sv)
		head.host = val;

	else if(key == "expect"_sv)
		head.expect = val;

	else if(key == "te"_sv)
		head.te = val;

	else if(key == "authorization"_sv)
		head.authorization = val;

	else if(key == "connection"_sv)
		head.connection = val;

	else if(key == "content-type"_sv)
		head.content_type = val;

	else if(key == "user-agent"_sv)
		head.user_agent = val;

	else if(key == "upgrade"_sv)
		head.upgrade = val;

	else if(key == "range"_sv)
		head.range = val;

	else if(key == "if-range"_sv)
		head.if_range = val;

	else if(key == "forwarded"_sv)
		head.forwarded[0] = val;

	else if(key == "x-forwarded-for"_sv)
		head.forwarded_for[0] = val;

	else if(key == "x-forwarded-host"_sv)
		head.forwarded_host[0] = val;
}

ircd::http::response::response(window_buffer &out,
                               const code &code,
                               const size_t &content_length,
                               const string_view &content_type,
                               const http::headers &headers_s,
                               const vector_view<const header> &headers_v,
                               const bool &termination)
{
	const auto has_header{[&headers_s, &headers_v]
	(const string_view &key) -> bool
	{
		return has(headers_v, key) || has(headers_s, key);
	}};

	writeline(out, [&code](const mutable_buffer &out) -> size_t
	{
		return fmt::sprintf
		{
			out, "HTTP/1.1 %u %s", uint(code), status(code)
		};
	});

	const bool write_server_header
	{
		code >= 200 && code < 300
		&& !has_header("server")
	};

	if(write_server_header)
		writeline(out, [&code](const mutable_buffer &out) -> size_t
		{
			size_t ret{0};
			ret += copy(out, "Server: "_sv);
			ret += copy(out + ret, ircd::info::server_agent);
			return ret;
		});

	const bool write_date_header
	{
		code < 400
		&& !has_header("date")
	};

	if(write_date_header)
		writeline(out, [](const mutable_buffer &out) -> size_t
		{
			char date_buf[96];
			return fmt::sprintf
			{
				out, "Date: %s", timef(date_buf, ircd::localtime)
			};
		});

	const bool write_content_type_header
	{
		code != NO_CONTENT
		&& content_type && content_length
		&& !has_header("content-type")
	};

	if(write_content_type_header)
		writeline(out, [&content_type](const mutable_buffer &out) -> size_t
		{
			return fmt::sprintf
			{
				out, "Content-Type: %s", content_type?: "text/plain; charset=utf-8"
			};
		});

	const bool write_content_length_header
	{
		code != NO_CONTENT
		&& content_length != size_t(-1) // chunked encoding indication
		&& !has_header("content-length")
	};

	if(write_content_length_header)
		writeline(out, [&content_length](const mutable_buffer &out) -> size_t
		{
			return fmt::sprintf
			{
				out, "Content-Length: %zu", content_length
			};
		});

	const bool write_transfer_encoding_chunked
	{
		content_length == size_t(-1)
		&& !has_header("transfer-encoding")
	};

	if(write_transfer_encoding_chunked)
		writeline(out, [&content_length](const mutable_buffer &out) -> size_t
		{
			return copy(out, "Transfer-Encoding: chunked"_sv);
		});

	if(!headers_s.empty())
		out([&headers_s](const mutable_buffer &out)
		{
			assert(endswith(headers_s, "\r\n"));
			return copy(out, headers_s);
		});

	if(!headers_v.empty())
		write(out, headers_v);

	if(termination)
		writeline(out);
}

namespace ircd::http
{
	static void assign(response::head &, const header &);
}

ircd::http::response::head::head(parse::capstan &pc)
try
:line::response{pc}
,headers
{
	pc, [this](const auto &header)
	{
		assign(*this, header);
	}
}
{
}
catch(const expectation_failure &e)
{
	throw_error(e, true);
}

ircd::http::response::head::head(parse::capstan &pc,
                                 const headers::closure &closure)
try
:line::response{pc}
,headers
{
	pc, [this, &closure](const auto &header)
	{
		assign(*this, header);
		closure(header);
	}
}
{
}
catch(const expectation_failure &e)
{
	throw_error(e, true);
}

void
ircd::http::assign(response::head &head,
                   const header &header)
{
	char buf[96];
	const auto &[key_, val] {header};
	assert(size(key_) <= sizeof(buf));
	if(unlikely(size(key_) > sizeof(buf)))
		throw error
		{
			REQUEST_HEADER_FIELDS_TOO_LARGE
		};

	const auto &key
	{
		tolower(buf, key_)
	};

	if(key == "content-length"_sv)
		head.content_length = parser::content_length(val);

	else if(key == "content-type"_sv)
		head.content_type = val;

	else if(key == "content-range"_sv)
		head.content_range = val;

	else if(key == "accept-range"_sv)
		head.content_range = val;

	else if(key == "transfer-encoding"_sv)
		head.transfer_encoding = val;

	else if(key == "server"_sv)
		head.server = val;

	else if(key == "location"_sv)
		head.location = val;
}

namespace ircd::http::parser
{
	extern const rule<size_t> parse_chunk_head;
}

decltype(ircd::http::parser::parse_chunk_head)
ircd::http::parser::parse_chunk_head
{
	eoi | (eps > (chunk_size >> -chunk_extensions))
	,"chunk head"
};

ircd::http::response::chunk::chunk(parse::capstan &pc)
try
:line{pc}
{
	const char *start(line::begin()), *const stop(line::end());
	const auto res
	{
		ircd::parse(start, stop, parser::parse_chunk_head, this->size)
	};

	assert(res == true);
}
catch(const expectation_failure &e)
{
	throw_error(e, true);
}

//
// headers
//

bool
ircd::http::has(const vector_view<const header> &headers,
                const string_view &key)
{
	return end(headers) != std::find_if(begin(headers), end(headers), [&key]
	(const header &header)
	{
		return header == key;
	});
}

bool
ircd::http::has(const headers &headers,
                const string_view &key)
{
	return headers.has(key);
}

//
// headers::headers
//

decltype(ircd::http::headers::terminator)
ircd::http::headers::terminator
{
	"\r\n\r\n"
};

ircd::http::headers::headers(parse::capstan &pc,
                             closure c)
:string_view{[&pc, &c]
() -> string_view
{
	header h{pc};
	const char *const &started{h.first.data()}, *stopped{started};
	for(; !h.first.empty(); stopped = pc.parsed, h = header{pc})
		if(c && !c(h))
			c = {};

	return { started, stopped };
}()}
{
}

bool
ircd::http::headers::has(const string_view &key)
const
{
	// has header if break early from for_each
	return !for_each([&key]
	(const header &header)
	{
		// true to continue; false to break (for_each protocol)
		return iequals(header.first, key)? false : true;
	});
}

ircd::string_view
ircd::http::headers::at(const string_view &key)
const
{
	const string_view ret
	{
		this->operator[](key)
	};

	if(unlikely(!ret))
		throw std::out_of_range{key};

	return ret;
}

ircd::string_view
ircd::http::headers::operator[](const string_view &key)
const
{
	string_view ret;
	for_each([&key, &ret](const auto &header)
	{
		if(iequals(header.first, key))
		{
			ret = header.second;
			return false;
		}
		else return true;
	});

	return ret;
}

bool
ircd::http::headers::for_each(const closure &closure)
const
{
	if(empty())
		return true;

	parse::buffer pb{const_buffer{*this}};
	parse::capstan pc{pb};
	header h{pc};
	for(; !h.first.empty(); h = header{pc})
		if(!closure(h))
			return false;

	return true;
}

//
// header
//

namespace ircd::http::parser
{
	extern const rule<http::header> parse_header;
	extern const rule<http::line::request> parse_request;
	extern const rule<http::line::response> parse_response;
}

decltype(ircd::http::parser::parse_header)
ircd::http::parser::parse_header
{
	eoi | expect[header]
	,"header"
};

decltype(ircd::http::parser::parse_request)
ircd::http::parser::parse_request
{
	expect[request_line]
	,"request head line"
};

decltype(ircd::http::parser::parse_response)
ircd::http::parser::parse_response
{
	expect[response_line]
	,"response head line"
};

ircd::http::header::header(const line &line)
try
{
	const char
	*start(line.data()),
	*const stop(line.data() + line.size());
	const auto ok
	{
		ircd::parse(start, stop, parser::parse_header, *this)
	};

	assert(ok);
	assert(start == stop);
}
catch(const expectation_failure &e)
{
	throw_error(e);
}

ircd::http::line::response::response(const line &line)
try
{
	const char
	*start(line.data()),
	*const stop(line.data() + line.size());
	const auto ok
	{
		ircd::parse(start, stop, parser::parse_response, *this)
	};

	assert(ok);
	assert(start == stop);
}
catch(const expectation_failure &e)
{
	throw_error(e, true);
}

ircd::http::line::request::request(const line &line)
try
{
	const char
	*start(line.data()),
	*const stop(line.data() + line.size());
	const auto ok
	{
		ircd::parse(start, stop, parser::parse_request, *this)
	};

	assert(ok);
	assert(start == stop);
}
catch(const expectation_failure &e)
{
	throw_error(e);
}

ircd::http::line::request::operator
string_view()
const
{
	if(method.empty())
		return string_view{};

	assert(!version.empty());
	assert(method.begin() < version.end());
	return string_view
	{
		method.begin(), version.end()
	};
}

//
// http::line
//

namespace ircd::http::parser
{
	extern const rule<string_view> parse_line;
}

decltype(ircd::http::parser::parse_line)
ircd::http::parser::parse_line
{
	expect[line]
	,"line"
};

decltype(ircd::http::line::terminator)
ircd::http::line::terminator
{
	"\r\n"
};

ircd::http::line::line(parse::capstan &pc)
{
	auto &ret(static_cast<string_view &>(*this));
	pc([&ret](const char *&start, const char *const &stop)
	{
		if(start == stop)
			return false;

		const bool ok
		{
			ircd::parse(start, stop, parser::parse_line, ret)
		};

		assert(ok);
		return ok;
	});
}

//
// query::string
//

bool
ircd::http::query::string::has(const string_view &key)
const
{
	bool ret{false};
	for_each(key, [&ret]
	(const auto &)
	noexcept
	{
		ret = true;
		return false;
	});

	return ret;
}

size_t
ircd::http::query::string::count(const string_view &key)
const
{
	size_t ret{0};
	for_each(key, [&ret]
	(const auto &)
	noexcept
	{
		++ret;
		return true;
	});

	return ret;
}

ircd::vector_view<ircd::string_view>
ircd::http::query::string::array(const mutable_buffer &buf,
                                 const string_view &key,
                                 string_view *const &out,
                                 const size_t &max)
const
{
	if(unlikely(!max))
		return {};

	size_t ret(0);
	window_buffer window(buf);
	for_each(key, [&out, &max, &ret, &window]
	(const auto &query)
	{
		window([&out, &max, &ret, &query]
		(const mutable_buffer &buf)
		{
			assert(ret < max);
			const auto &[_, val] {query};
			out[ret] = url::decode(buf, val);
			return out[ret];
		});

		return ++ret < max;
	});

	return vector_view<string_view>
	{
		out, ret
	};
}


ircd::string_view
ircd::http::query::string::at(const string_view &key,
                              const size_t &idx)
const
{
	const string_view &ret
	{
		_get(key, idx)
	};

	if(unlikely(!ret))
	{
		char buf[1024];
		const string_view msg
		{
			fmt::sprintf
			{
				buf, "Failed to find value for required query string key '%s' #%zu.",
				key,
				idx
			}
		};

		throw std::out_of_range
		{
			msg.c_str() // fmt::sprintf() will null terminate msg
		};
	}

	return ret;
}

ircd::string_view
ircd::http::query::string::operator[](const string_view &key)
const
{
	return _get(key, 0);
}

ircd::string_view
ircd::http::query::string::_get(const string_view &key,
                                size_t idx)
const
{
	string_view ret;
	for_each(key, [&idx, &ret]
	(const auto &query)
	noexcept
	{
		if(!idx--)
		{
			ret = query.second;
			return false;
		}
		else return true;
	});

	return ret;
}

bool
ircd::http::query::string::for_each(const string_view &key,
                                    const closure &closure)
const
{
	return for_each([&key, &closure]
	(const auto &query)
	{
		if(query.first != key)
			return true;

		return closure(query);
	});
}

bool
ircd::http::query::string::for_each(const closure &view)
const
{
	bool ret{true};
	const auto action{[&view, &ret]
	(const auto &attribute, const auto &context, auto &continue_)
	{
		ret = view(attribute);
		continue_ = ret;
	}};

	const parser::rule<> grammar
	{
		-parser::question >> (parser::query[action] % parser::ampersand)
		,"query strings"
	};

	const string_view &s(*this);
	const char *start(s.begin()), *const stop(s.end());
	ircd::parse(start, stop, grammar);
	return ret;
}

//
// parser util
//

size_t
ircd::http::parser::content_length(const string_view &str)
{
	const char
	*start(str.data()),
	*const stop(start + str.size());

	size_t ret;
	const bool parsed
	{
		ircd::parse(start, stop, parser::content_size, ret)
	};

	if(!parsed || ret >= 256_GiB)
		throw error
		{
			BAD_REQUEST, "Invalid content-length value"
		};

	return ret;
}

//
// util
//

ircd::const_buffer
ircd::http::writechunk(const mutable_buffer &buf,
                       const uint32_t &chunk_size)
{
	window_buffer window{buf};
	writechunk(window, chunk_size);
	return window.completed();
}

void
ircd::http::writechunk(window_buffer &buf,
                       const uint32_t &chunk_size)
{
	writeline(buf, [&chunk_size]
	(const mutable_buffer &out) -> size_t
	{
		assert(size(out) >= (8 + 1));
		return ::snprintf(data(out), size(out), "%08x", chunk_size);
	});
}

std::string
ircd::http::strung(const vector_view<const header> &headers)
{
	return ircd::string(serialized(headers), [&]
	(window_buffer out)
	{
		write(out, headers);
		return out.consumed();
	});
}

/// Indicates the buffer size required to write these headers. This size
/// may include room for a terminating null character which may be written
/// by write(headers). Only use write(headers) to know the actually written
/// string size (without null) not this.
size_t
ircd::http::serialized(const vector_view<const header> &headers)
{
	// Because the write(header) functions use fmt::sprintf we have to
	// indicate an extra space for a null string terminator to not overlof
	const size_t initial{!headers.empty()};
	return std::accumulate(std::begin(headers), std::end(headers), initial, []
	(auto &&ret, const auto &pair)
	{
		//            key                 :   SP  value                CRLF
		return ret += pair.first.size() + 1 + 1 + pair.second.size() + 2;
	});
}

void
ircd::http::write(window_buffer &out,
                  const vector_view<const header> &headers)
{
	for(const auto &header : headers)
		write(out, header);
}

void
ircd::http::write(window_buffer &out,
                  const header &header)
{
	if(header.second.empty())
		return;

	assert(!header.first.empty());
	if(unlikely(header.first.empty()))
		return;

	writeline(out, [&header](const mutable_buffer &out) -> size_t
	{
		return fmt::sprintf
		{
			out, "%s: %s", header.first, header.second
		};
	});
}

/// Close over the user's closure to append a newline.
void
ircd::http::writeline(window_buffer &write,
                      const window_buffer::closure &closure)
{
	// A new window_buffer is implicit constructed out of the mutable_buffer
	// otherwise presented to this closure as its write window.
	write([&closure](window_buffer write)
	{
		const auto newline{[](const mutable_buffer &out)
		{
			return copy(out, line::terminator);
		}};

		write(closure);
		write(newline);
		return write.consumed();
	});
}

void
ircd::http::writeline(window_buffer &write)
{
	writeline(write, []
	(const mutable_buffer &out)
	noexcept
	{
		return 0;
	});
}

/// Called to translate a grammar exception into an http::error within our
/// system. This will then usually propagate back to our client.
///
/// If we are a client to another server, set internal=true. Even though this
/// still generates an HTTP error, the code is 500 so if it propagates back to
/// a client it does not indicate to *that* client that *they* made a bad
/// request from a 400 back to them.
void
ircd::http::throw_error(const expectation_failure &e,
                        const bool &internal)
{
	const auto &code_
	{
		internal?
			code::INTERNAL_SERVER_ERROR:
			code::BAD_REQUEST
	};

	const char *const &fmtstr
	{
		internal?
			"I expected a valid HTTP %s. Server sent %zu invalid characters starting with `%s'.":
			"I require a valid HTTP %s. You sent %zu invalid characters starting with `%s'."
	};

	const auto &rule
	{
		ircd::string(e.what_)
	};

	throw error
	{
		code_, fmt::snstringf
		{
			512, fmtstr,
			between(rule, "<", ">"),
			size_t(e.last - e.first),
			string_view{e.first, e.last}
		}
	};
}

//
// error
//

ircd::http::error::error(const http::code &code,
                         std::string content,
                         const vector_view<const header> &headers)
:http::error
{
	code, std::move(content), strung(headers)
}
{
}

ircd::http::error::error(const http::code &code,
                         std::string content,
                         std::string headers)
:ircd::error
{
	generate_skip
}
,content
{
	std::move(content)
}
,headers
{
	std::move(headers)
}
,code{code}
{
	auto &buf(ircd::error::buf);
	const auto msg(status(code));
	::snprintf
	(
		buf, sizeof(buf),
		"%u %s",
		uint(code),
		msg? msg.c_str(): ""
	);
}

// Out-of-line placement.
ircd::http::error::~error()
noexcept
{
}

//
// status
//

namespace ircd::http::parser
{
	extern const rule<uint8_t> status_codepoint;
	extern const rule<enum http::category> status_category;
	extern const rule<enum http::code> status_code;
}

decltype(ircd::http::parser::status_codepoint)
ircd::http::parser::status_codepoint
{
	qi::uint_parser<uint8_t, 10, 1, 1>{}
	,"status codepoint"
};

decltype(ircd::http::parser::status_category)
ircd::http::parser::status_category
{
	&char_('1','9')
	>> status_codepoint
	>> omit[repeat(2)[char_('0','9')] >> (eoi | ws)]
	,"status category"
};

decltype(ircd::http::parser::status_code)
ircd::http::parser::status_code
{
	qi::uint_parser<uint16_t, 10, 3, 3>{}
	>> omit[eoi | ws]
	,"status code"
};

enum ircd::http::code
ircd::http::status(const string_view &str)
{
	short ret;
	const char *start(begin(str)), *const stop(end(str));
	const bool parsed
	{
		ircd::parse(start, stop, parser::status_code, ret)
	};

	if(!parsed)
		throw ircd::error
		{
			"Invalid HTTP status code"
		};

	assert(ret >= 0 && ret < 1000);
	return http::code(ret);
}

ircd::string_view
ircd::http::status(const enum code &code)
noexcept try
{
	return reason.at(code);
}
catch(const std::out_of_range &e)
{
	log::dwarning
	{
		"No reason string for HTTP status code %u", uint(code)
	};

	return ""_sv;
}

enum ircd::log::level
ircd::http::severity(const enum category &category)
noexcept
{
	switch(category)
	{
		case http::category::NONE:        return log::level::DERROR;
		case http::category::SUCCESS:     return log::level::DEBUG;
		case http::category::REDIRECT:    return log::level::DWARNING;
		case http::category::ERROR:       return log::level::DERROR;
		case http::category::SERVER:      return log::level::DERROR;
		case http::category::INTERNAL:    return log::level::ERROR;
		default:
		case http::category::UNKNOWN:     return log::level::DWARNING;
	}
}

enum ircd::http::category
ircd::http::category(const string_view &str)
noexcept
{
	enum category ret;
	const char *start(begin(str)), *const stop(end(str));
	const bool parsed
	{
		ircd::parse(start, stop, parser::status_category, ret)
	};

	if(!parsed || ret > category::UNKNOWN)
		ret = category::UNKNOWN;

	assert(uint8_t(ret) <= uint8_t(category::UNKNOWN));
	return ret;
}

enum ircd::http::category
ircd::http::category(const enum code &code)
noexcept
{
	if(ushort(code) == 0)
		return category::NONE;

	if(ushort(code) < 200)
		return category::INFO;

	if(ushort(code) < 300)
		return category::SUCCESS;

	if(ushort(code) < 400)
		return category::REDIRECT;

	if(ushort(code) < 500)
		return category::ERROR;

	if(ushort(code) == 500)
		return category::INTERNAL;

	if(ushort(code) < 600)
		return category::SERVER;

	return category::UNKNOWN;
}

ircd::string_view
ircd::http::category(const enum category &category)
noexcept
{
	switch(category)
	{
		case category::NONE:      return "NONE";
		case category::INFO:      return "INFO";
		case category::SUCCESS:   return "SUCCESS";
		case category::REDIRECT:  return "REDIRECT";
		case category::ERROR:     return "ERROR";
		case category::SERVER:    return "SERVER";
		case category::INTERNAL:  return "INTERNAL";
		case category::UNKNOWN:   break;
	}

	return "UNKNOWN";
}