require 'socket'
require 'rack/content_length'
require 'rack/rewindable_input'
require 'stringio'

module Rack
  module Handler
    class Uwsgi

      def self.run(app, options={})
	if ENV['UWSGI_FD']
          server = UNIXServer.for_fd(ENV['UWSGI_FD'].to_i)
	else
          server = TCPServer.new(options[:Host], options[:Port])
	end
	while client = server.accept
          serve client, app
	end
      end

      def self.serve(client, app)

	head, sender = client.recvfrom(4)

	unless head
	  client.close
	  return
	end
	
	mod1, size, mod2 = head.unpack('CvC')

	if size == 0 or size.nil?
	  client.close
	  return
	end

	vars, sender = client.recvfrom(size)

	if vars.length != size
	  client.close
	  return
	end

	env = Hash.new

	i = 0
	while i < size
          kl = vars[i, 2].unpack('v')[0]
          i = i + 2
          key = vars[i, kl]
	  i = i + kl
          vl = vars[i, 2].unpack('v')[0]
          i = i + 2
	  value = vars[i, vl]
          i = i + vl
          env[key] = value
	end



        env.delete "HTTP_CONTENT_LENGTH"
        env.delete "HTTP_CONTENT_TYPE"

        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
        env["QUERY_STRING"] ||= ""
        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
        env["REQUEST_PATH"] ||= "/"
        env.delete "PATH_INFO"  if env["PATH_INFO"] == ""
        env.delete "CONTENT_TYPE"  if env["CONTENT_TYPE"] == ""
        env.delete "CONTENT_LENGTH"  if env["CONTENT_LENGTH"] == ""
        
	
	if env["CONTENT_LENGTH"].to_i > 4096
		rack_input = Rack::RewindableInput::Tempfile.new('Rack_uwsgi_Input')
		rack_input.chmod(0000)
		rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
      		rack_input.binmode
      		if RUBY_PLATFORM !~ /(mswin|mingw|cygwin|java)/
        	  rack_input.unlink
		end

		remains = env["CONTENT_LENGTH"].to_i
		while remains > 0
			if remains >= 4096
				buf, sender = client.recvfrom(4096)
			else
				buf, sender = client.recvfrom(remains)
			end

			rack_input.write( buf )
			remains -= buf.length
		end

	elsif env["CONTENT_LENGTH"].to_i > 0
		rack_input =  StringIO.new(client.recvfrom(env["CONTENT_LENGTH"].to_i)[0])
	else
		rack_input = StringIO.new('')
	end

	rack_input.rewind

        env.update({"rack.version" => [1,1],
                     "rack.input" => rack_input,
                     "rack.errors" => $stderr,

                     "rack.multithread" => false,
                     "rack.multiprocess" => true,
                     "rack.run_once" => false,

                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
                   })


        app = Rack::ContentLength.new(app)

        begin
          status, headers, body = app.call(env)
          begin
            send_headers client, env["HTTP_VERSION"] ,status, headers
            send_body client, body
          ensure
            body.close  if body.respond_to? :close
          end
	rescue Errno::EPIPE, Errno::ECONNRESET
        ensure
	  rack_input.close
	  client.close
        end
      end

      def self.send_headers(client, protocol, status, headers)
	client.print "#{protocol} #{status} #{Rack::Utils::HTTP_STATUS_CODES[status]}\r\n"
        headers.each { |k, vs|
          vs.split("\n").each { |v|
            client.print "#{k}: #{v}\r\n"
          }
        }
        client.print "\r\n"
        client.flush
      end

      def self.send_body(client, body)
        body.each { |part|
          client.print part
          client.flush
        }
      end
    end
  end
end