-----------------------------------------------------------------------------
-- HTTP/1.1 client support for the Lua language.
-- LuaSocket toolkit.
-- Author: Diego Nehab
-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
-- Declare module and import dependencies
-------------------------------------------------------------------------------
local socket = require("socket")
local url = require("socket.url")
local ltn12 = require("ltn12")
local mime = require("mime")
local string = require("string")
local headers = require("socket.headers")
local base = _G
local table = require("table")
socket.http = {}
local _M = socket.http
-----------------------------------------------------------------------------
-- Program constants
-----------------------------------------------------------------------------
-- connection timeout in seconds
TIMEOUT = 60
-- default port for document retrieval
_M.PORT = 80
-- user agent field sent in request
_M.USERAGENT = socket._VERSION

-----------------------------------------------------------------------------
-- Reads MIME headers from a connection, unfolding where needed
-----------------------------------------------------------------------------
local function receiveheaders(sock, headers)
	local line, name, value, err
	headers = headers or {}
	-- get first line
	line, err = sock:receive()

	if err then return nil, err end

	-- headers go until a blank line is found
	while line ~= "" do
		-- get field-name and value
		name, value = socket.skip(2, string.find(line, "^(.-):%s*(.*)"))

		if not (name and value) then return nil, "malformed reponse headers" end

		name = string.lower(name)
		-- get next line (value might be folded)
		line, err = sock:receive()

		if err then return nil, err end

		-- unfold any folded values
		while string.find(line, "^%s") do
			value = value .. line
			line = sock:receive()

			if err then return nil, err end
		end

		-- save pair in table
		if headers[name] then
			headers[name] = headers[name] .. ", " .. value
		else
			headers[name] = value
		end
	end

	return headers
end

-----------------------------------------------------------------------------
-- Extra sources and sinks
-----------------------------------------------------------------------------
socket.sourcet["http-chunked"] = function(sock, headers)
	return base.setmetatable(
		{
			getfd = function()
				return sock:getfd()
			end,
			dirty = function()
				return sock:dirty()
			end,
		},
		{
			__call = function()
				-- get chunk size, skip extention
				local line, err = sock:receive()

				if err then return nil, err end

				local size = base.tonumber(string.gsub(line, ";.*", ""), 16)

				if not size then return nil, "invalid chunk size" end

				-- was it the last chunk?
				if size > 0 then
					-- if not, get chunk and skip terminating CRLF
					local chunk, err, part = sock:receive(size)

					if chunk then sock:receive() end

					return chunk, err
				else
					-- if it was, read trailers into headers table
					headers, err = receiveheaders(sock, headers)

					if not headers then return nil, err end
				end
			end,
		}
	)
end
socket.sinkt["http-chunked"] = function(sock)
	return base.setmetatable(
		{
			getfd = function()
				return sock:getfd()
			end,
			dirty = function()
				return sock:dirty()
			end,
		},
		{
			__call = function(self, chunk, err)
				if not chunk then return sock:send("0\r\n\r\n") end

				local size = string.format("%X\r\n", string.len(chunk))
				return sock:send(size .. chunk .. "\r\n")
			end,
		}
	)
end
-----------------------------------------------------------------------------
-- Low level HTTP API
-----------------------------------------------------------------------------
local metat = {__index = {}}

function _M.open(host, port, create)
	-- create socket with user connect function, or with default
	local c = socket.try((create or socket.tcp)())
	local h = base.setmetatable({c = c}, metat)
	-- create finalized try
	h.try = socket.newtry(function()
		h:close()
	end)
	-- set timeout before connecting
	h.try(c:settimeout(_M.TIMEOUT))
	h.try(c:connect(host, port or _M.PORT))
	-- here everything worked
	return h
end

function metat.__index:sendrequestline(method, uri)
	local reqline = string.format("%s %s HTTP/1.1\r\n", method or "GET", uri)
	return self.try(self.c:send(reqline))
end

function metat.__index:sendheaders(tosend)
	local canonic = headers.canonic
	local h = "\r\n"

	for f, v in base.pairs(tosend) do
		h = (canonic[f] or f) .. ": " .. v .. "\r\n" .. h
	end

	self.try(self.c:send(h))
	return 1
end

function metat.__index:sendbody(headers, source, step)
	source = source or ltn12.source.empty()
	step = step or ltn12.pump.step
	-- if we don't know the size in advance, send chunked and hope for the best
	local mode = "http-chunked"

	if headers["content-length"] then mode = "keep-open" end

	return self.try(ltn12.pump.all(source, socket.sink(mode, self.c), step))
end

function metat.__index:receivestatusline()
	local status = self.try(self.c:receive(5))

	-- identify HTTP/0.9 responses, which do not contain a status line
	-- this is just a heuristic, but is what the RFC recommends
	if status ~= "HTTP/" then return nil, status end

	-- otherwise proceed reading a status line
	status = self.try(self.c:receive("*l", status))
	local code = socket.skip(2, string.find(status, "HTTP/%d*%.%d* (%d%d%d)"))
	return self.try(base.tonumber(code), status)
end

function metat.__index:receiveheaders()
	return self.try(receiveheaders(self.c))
end

function metat.__index:receivebody(headers, sink, step)
	sink = sink or ltn12.sink.null()
	step = step or ltn12.pump.step
	local length = base.tonumber(headers["content-length"])
	local t = headers["transfer-encoding"] -- shortcut
	local mode = "default" -- connection close
	if t and t ~= "identity" then
		mode = "http-chunked"
	elseif base.tonumber(headers["content-length"]) then
		mode = "by-length"
	end

	return self.try(ltn12.pump.all(socket.source(mode, self.c, length), sink, step))
end

function metat.__index:receive09body(status, sink, step)
	local source = ltn12.source.rewind(socket.source("until-closed", self.c))
	source(status)
	return self.try(ltn12.pump.all(source, sink, step))
end

function metat.__index:close()
	return self.c:close()
end

-----------------------------------------------------------------------------
-- High level HTTP API
-----------------------------------------------------------------------------
local function adjusturi(reqt)
	local u = reqt

	-- if there is a proxy, we need the full url. otherwise, just a part.
	if not reqt.proxy and not PROXY then
		u = {
			path = socket.try(reqt.path, "invalid path 'nil'"),
			params = reqt.params,
			query = reqt.query,
			fragment = reqt.fragment,
		}
	end

	return url.build(u)
end

local function adjustproxy(reqt)
	local proxy = reqt.proxy or PROXY

	if proxy then
		proxy = url.parse(proxy)
		return proxy.host, proxy.port or 3128
	else
		return reqt.host, reqt.port
	end
end

local function adjustheaders(reqt)
	-- default headers
	local lower = {
		["user-agent"] = _M.USERAGENT,
		["host"] = reqt.host,
		["connection"] = "close, TE",
		["te"] = "trailers",
	}

	-- if we have authentication information, pass it along
	if reqt.user and reqt.password then
		lower["authorization"] = "Basic " .. (mime.b64(reqt.user .. ":" .. reqt.password))
	end

	-- override with user headers
	for i, v in base.pairs(reqt.headers or lower) do
		lower[string.lower(i)] = v
	end

	return lower
end

-- default url parts
local default = {host = "", port = _M.PORT, path = "/", scheme = "http"}

local function adjustrequest(reqt)
	-- parse url if provided
	local nreqt = reqt.url and url.parse(reqt.url, default) or {}

	-- explicit components override url
	for i, v in base.pairs(reqt) do
		nreqt[i] = v
	end

	if nreqt.port == "" then nreqt.port = 80 end

	socket.try(
		nreqt.host and nreqt.host ~= "",
		"invalid host '" .. base.tostring(nreqt.host) .. "'"
	)
	-- compute uri if user hasn't overriden
	nreqt.uri = reqt.uri or adjusturi(nreqt)
	-- ajust host and port if there is a proxy
	nreqt.host, nreqt.port = adjustproxy(nreqt)
	-- adjust headers in request
	nreqt.headers = adjustheaders(nreqt)
	return nreqt
end

local function shouldredirect(reqt, code, headers)
	return headers.location and
		string.gsub(headers.location, "%s", "") ~= "" and
		(
			reqt.redirect ~= false
		)
		and
		(
			code == 301 or
			code == 302 or
			code == 303 or
			code == 307
		)
		and
		(
			not reqt.method or
			reqt.method == "GET" or
			reqt.method == "HEAD"
		)
		and
		(
			not reqt.nredirects or
			reqt.nredirects < 5
		)
end

local function shouldreceivebody(reqt, code)
	if reqt.method == "HEAD" then return nil end

	if code == 204 or code == 304 then return nil end

	if code >= 100 and code < 200 then return nil end

	return 1
end

-- forward declarations
local trequest, tredirect

--[[local]] function tredirect(reqt, location)
	local result, code, headers, status = trequest(
		{
			-- the RFC says the redirect URL has to be absolute, but some
			-- servers do not respect that
			url = url.absolute(reqt.url, location),
			source = reqt.source,
			sink = reqt.sink,
			headers = reqt.headers,
			proxy = reqt.proxy,
			nredirects = (reqt.nredirects or 0) + 1,
			create = reqt.create,
		}
	)
	-- pass location header back as a hint we redirected
	headers = headers or {}
	headers.location = headers.location or location
	return result, code, headers, status
end

--[[local]] function trequest(reqt)
	-- we loop until we get what we want, or
	-- until we are sure there is no way to get it
	local nreqt = adjustrequest(reqt)
	local h = _M.open(nreqt.host, nreqt.port, nreqt.create)
	-- send request line and headers
	h:sendrequestline(nreqt.method, nreqt.uri)
	h:sendheaders(nreqt.headers)

	-- if there is a body, send it
	if nreqt.source then h:sendbody(nreqt.headers, nreqt.source, nreqt.step) end

	local code, status = h:receivestatusline()

	-- if it is an HTTP/0.9 server, simply get the body and we are done
	if not code then
		h:receive09body(status, nreqt.sink, nreqt.step)
		return 1, 200
	end

	local headers

	-- ignore any 100-continue messages
	while code == 100 do
		headers = h:receiveheaders()
		code, status = h:receivestatusline()
	end

	headers = h:receiveheaders()

	-- at this point we should have a honest reply from the server
	-- we can't redirect if we already used the source, so we report the error
	if shouldredirect(nreqt, code, headers) and not nreqt.source then
		h:close()
		return tredirect(reqt, headers.location)
	end

	-- here we are finally done
	if shouldreceivebody(nreqt, code) then
		h:receivebody(headers, nreqt.sink, nreqt.step)
	end

	h:close()
	return 1, code, headers, status
end

local function srequest(u, b)
	local t = {}
	local reqt = {url = u, sink = ltn12.sink.table(t)}

	if b then
		reqt.source = ltn12.source.string(b)
		reqt.headers = {
			["content-length"] = string.len(b),
			["content-type"] = "application/x-www-form-urlencoded",
		}
		reqt.method = "POST"
	end

	local code, headers, status = socket.skip(1, trequest(reqt))
	return table.concat(t), code, headers, status
end

_M.request = socket.protect(function(reqt, body)
	if base.type(reqt) == "string" then
		return srequest(reqt, body)
	else
		return trequest(reqt)
	end
end)
return _M