require 'greactor'
require 'stringio'


class MiniServer < GReactor::Protocol
    def on_connect
     @con ||= Time.now
     conn_inactivity_timeout = 5
     @headers = {}
    end

    def on_message data
        data = StringIO.new data
        l = nil
        headers = @headers
        while (l = data.gets)
            unless l.match /^[\r]?\n/
                if l.include? ':'
                    l = l.strip.downcase.split(':', 2)
                    headers[l[0]] = l[1]
                else
                    headers[:method], headers[:query], headers[:version] = l.strip.split(/[\s]+/, 3)
                    headers[:request_start] = Time.now
                end
                next
            end
            if headers['connection'].to_s.match(/keep/i) || headers[:version].match(/1\.1/)
                send "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 12\r\nConnection: keep-alive\r\nKeep-Alive: 5\r\n\r\nhello world\n"
            else
                send "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 12\r\nConnection: close\r\n\r\nhello world\n"
                close
            end
            headers.clear
        end
        data.string.clear
    end
end

GR.on_shutdown { GR.instance_exec { puts "We're done: #{@stop}" } }
GR.start(1) { GR.listen timeout: 5, handler: MiniServer, port: 3000 }

require 'socket'
require 'stringio'

server = TCPServer.new(3000)
trap('INT'){ server.close rescue true }
trap('TERM'){ server.close rescue true }

until server.closed?
    Thread.new(server.accept) do |client|
        begin
            headers = {}
            while (l = client.gets)
                unless headers[:method]
                        headers[:method], headers[:query], headers[:version] = l.strip.split(/[\s]+/, 3)
                        headers[:request_start] = Time.now
                        unless headers[:method].to_s.match /get|post|trace|delete|head/i
                            client.close rescue true
                            return false
                        end
                        next    
                end
                unless l.match /^[\r]?\n/
                    if l.include? ':'
                        l = l.strip.downcase.split(':', 2)
                        headers[l[0]] = l[1]
                    else
                    end
                    next
                end
                if headers['connection'].to_s.match(/keep/i) || headers[:version].to_s.match(/1\.1/)
                    client.write "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 12\r\nConnection: keep-alive\r\nKeep-Alive: 5\r\n\r\nhello world\n"
                else
                    client.write "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 12\r\nConnection: close\r\n\r\nhello world\n"
                    client.close
                end
                headers.clear
            end
        rescue => e
            # puts e.message
        ensure
            client.close rescue true
        end
    end
end

require 'socket'

class JobManager
    def initialize
        @run = false
        @workers = []
        @queue = []
        @locker = Mutex.new
        @ios = {}
        @io_lock = Mutex.new
        @review_lock = Mutex.new
    end
    def start
        @run = true
        10.times { @workers << ( Thread.new {( work || review ) while @run } ) }
        true
    end
    def stop
        @run = false
        @ios.each {|io, h| io.close rescue true}
        @workers.each {|t| t.join rescue true }
        @workers.clear
        @ios.clear
        @queue.clear
        true
    end

    def listen io, handler = nil, &block
        handler ||= block
        @io_lock.synchronize {@ios[io] = handler}
    end

    def clear io
        io.close unless io.closed?
        @io_lock.synchronize {@ios.delete io}
    end

    def queue *args, &block
        @locker.synchronize {@queue << [args, block]} if block
    end
    def work
        job = @locker.synchronize { @queue.shift }
        return false unless job
        begin
            job[1].call *job[0]
        rescue Errno::EWOULDBLOCK => e

        rescue => e
            puts e.message
            puts e.backtrace
        end
    end
    def review
        @review_lock.synchronize do
            return if @queue.any?
            begin
                io_array = @io_lock.synchronize { @ios.keys }
                io_r = ::IO.select(io_array, nil, io_array, 0.2)
                if io_r
                    io_r[0].each {|io| queue io, &@ios[io] }
                    io_r[2].each { |io| @ios.delete io }
                end
            rescue => e
                @io_lock.synchronize { @ios.keys } .each {|io| clear io if io.closed? || ( (io.stat && false) rescue true )}
            end
            true
        end
    end
end


reactor = JobManager.new
reactor.start
trap('INT'){ reactor.stop ; raise 'stop' }
trap('TERM'){ reactor.stop ; raise 'stop' }

reactor.listen(TCPServer.new(3000)) do |io|
    begin
        reactor.listen(io.accept_nonblock) do |client|
            begin
                headers = {}
                while (l = client.gets)
                    unless headers[:method]
                            headers[:method], headers[:query], headers[:version] = l.strip.split(/[\s]+/, 3)
                            headers[:request_start] = Time.now
                            unless headers[:method].to_s.match /get|post|trace|delete|head/i
                                reactor.clear client
                            end
                            next    
                    end
                    unless l.to_s.match /^[\r]?\n/
                        if l.include? ':'
                            l = l.strip.downcase.split(':', 2)
                            headers[l[0]] = l[1]
                        else
                        end
                        next
                    end
                    if headers['connection'].to_s.match(/keep/i) || headers[:version].to_s.match(/1\.1/)
                        client.write "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 12\r\nConnection: keep-alive\r\nKeep-Alive: 5\r\n\r\nhello world\n"
                    else
                        client.write "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 12\r\nConnection: close\r\n\r\nhello world\n"
                        client.close
                    end
                    headers.clear
                end
            rescue Errno::EWOULDBLOCK => e
            end
        end
    rescue Errno::EWOULDBLOCK => e
    end
end

sleep rescue true