--[[
LuCI - Lua Development Framework 

Copyright 2009 Steven Barth <steven@midlink.org>

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

$Id$
]]--

require "nixio.util"
local nixio = require "nixio"
local httpc = require "luci.httpclient"
local ltn12 = require "luci.ltn12"

local print, tonumber, require = print, tonumber, require

module "luci.httpclient.receiver"

local function prepare_fd(target)
	-- Open fd for appending
	local oflags = nixio.open_flags("wronly", "creat")
	local file, code, msg = nixio.open(target, oflags)
	if not file then
		return file, code, msg
	end
	
	-- Acquire lock
	local stat, code, msg = file:lock("tlock")
	if not stat then
		return stat, code, msg
	end
	
	file:seek(0, "end") 
	
	return file
end

local function splice_async(sock, pipeout, pipein, file, cb)
	local ssize = 65536
	local smode = nixio.splice_flags("move", "more", "nonblock")

	-- Set pipe non-blocking otherwise we might end in a deadlock
	local stat, code, msg = pipein:setblocking(false)
	if stat then
		stat, code, msg = pipeout:setblocking(false)
	end
	if not stat then
		return stat, code, msg
	end
	
	
	local pollsock = {
		{fd=sock, events=nixio.poll_flags("in")}
	}
	
	local pollfile = {
		{fd=file, events=nixio.poll_flags("out")}
	}
	
	local done
	local active -- Older splice implementations sometimes don't detect EOS
	
	repeat
		active = false
		
		-- Socket -> Pipe
		repeat
			nixio.poll(pollsock, 15000)
		
			stat, code, msg = nixio.splice(sock, pipeout, ssize, smode)
			if stat == nil then
				return stat, code, msg
			elseif stat == 0 then
				done = true
				break
			elseif stat then
				active = true
			end
		until stat == false
		
		-- Pipe -> File
		repeat
			nixio.poll(pollfile, 15000)
		
			stat, code, msg = nixio.splice(pipein, file, ssize, smode)
			if stat == nil then
				return stat, code, msg
			elseif stat then
				active = true
			end
		until stat == false
		
		if cb then
			cb(file)
		end
		
		if not active then
			-- We did not splice any data, maybe EOS, fallback to default
			return false
		end
	until done
	
	pipein:close()
	pipeout:close()
	sock:close()
	file:close()
	return true
end

local function splice_sync(sock, pipeout, pipein, file, cb)
	local os = require "os"
	local posix = require "posix"
	local ssize = 65536
	local smode = nixio.splice_flags("move", "more")
	local stat
	
	-- This is probably the only forking http-client ;-)
	local pid, code, msg = posix.fork()
	if not pid then
		return pid, code, msg
	elseif pid == 0 then
		pipein:close()
		file:close()

		repeat
			stat, code = nixio.splice(sock, pipeout, ssize, smode)
		until not stat or stat == 0
	
		pipeout:close()
		sock:close()
		os.exit(stat or code)
	else
		pipeout:close()
		sock:close()
		
		repeat
			stat, code, msg = nixio.splice(pipein, file, ssize, smode)
			if cb then
				cb(file)
			end
		until not stat or stat == 0
		
		pipein:close()
		file:close()
		
		if not stat then
			posix.kill(pid)
			posix.wait(pid)
			return stat, code, msg
		else
			pid, msg, code = posix.wait(pid)
			if msg == "exited" then
				if code == 0 then
					return true
				else
					return nil, code, nixio.strerror(code)
				end
			else
				return nil, -0x11, "broken pump"
			end
		end
	end
end

function request_to_file(uri, target, options, cbs)
	options = options or {}
	cbs = cbs or {}
	options.headers = options.headers or {}
	local hdr = options.headers
	
	local file, code, msg = prepare_fd(target)
	if not file then
		return file, code, msg
	end
	
	local off = file:tell()
	
	-- Set content range
	if off > 0 then
		hdr.Range = hdr.Range or ("bytes=" .. off .. "-")  
	end
	
	local code, resp, buffer, sock = httpc.request_raw(uri, options)
	if not code then
		-- No success
		file:close()
		return code, resp, buffer
	elseif hdr.Range and code ~= 206 then
		-- We wanted a part but we got the while file
		sock:close()
		file:close()
		return nil, -4, code, resp
	elseif not hdr.Range and code ~= 200 then
		-- We encountered an error
		sock:close()
		file:close()
		return nil, -4, code, resp
	end
	
	if cbs.on_header then
		if cbs.on_header(file, code, resp) == false then
			file:close()
			sock:close()
			return true
		end
	end

	local chunked = resp.headers["Transfer-Encoding"] == "chunked"
	local stat

	-- Write the buffer to file
	file:writeall(buffer)
	
	repeat
		if not options.splice or not sock:is_socket() or chunked then
			break
		end
		
		-- This is a plain TCP socket and there is no encoding so we can splice
	
		local pipein, pipeout, msg = nixio.pipe()
		if not pipein then
			sock:close()
			file:close()
			return pipein, pipeout, msg
		end
		
		
		-- Adjust splice values
		local ssize = 65536
		local smode = nixio.splice_flags("move", "more")
		
		-- Splicing 512 bytes should never block on a fresh pipe
		local stat, code, msg = nixio.splice(sock, pipeout, 512, smode)
		if stat == nil then
			break
		end
		
		-- Now do the real splicing
		local cb = cbs.on_write
		if options.splice == "asynchronous" then
			stat, code, msg = splice_async(sock, pipeout, pipein, file, cb)
		elseif options.splice == "synchronous" then
			stat, code, msg = splice_sync(sock, pipeout, pipein, file, cb)
		else
			break
		end
		
		if stat == false then
			break
		end

		return stat, code, msg
	until true
	
	local src = chunked and httpc.chunksource(sock) or sock:blocksource()
	local snk = file:sink()
	
	if cbs.on_write then
		src = ltn12.source.chain(src, function(chunk)
			cbs.on_write(file)
			return chunk
		end)
	end
	
	-- Fallback to read/write
	stat, code, msg = ltn12.pump.all(src, snk)

	file:close()
	sock:close()
	return stat and true, code, msg
end