#
# an in-memory resource set for testing rufus-verbs
#
# jmettraux@gmail.com
#
# Fri Jan 11 12:36:45 JST 2008
#

require 'date'
require 'webrick'


$dcount = 0 # tracking the number of hits when doing digest auth


#
# the hash for the /items resource (collection)
#
class LastModifiedHash

    def initialize

        @hash = {}
        touch
    end

    def touch (key=nil)

        now = Time.now.httpdate
        @hash[key] = now if key
        @hash['__self'] = now
    end

    def delete (key)

        @hash.delete key
        @hash['__self'] = Time.now.httpdate
    end

    def last_modified (key)

        key = key || '__self'
        @hash[key]
    end

    def clear

        @hash.clear
        @hash['__self'] = Time.now.httpdate
    end
end


#
# This servlet provides a RESTful in-memory resource "/items".
#
class ItemServlet < WEBrick::HTTPServlet::AbstractServlet

    @@items = {}
    @@last_item_id = -1

    @@lastmod = LastModifiedHash.new

    @@authenticator = WEBrick::HTTPAuth::DigestAuth.new(
        :UserDB => WEBrick::HTTPAuth::Htdigest.new('test/test.htdigest'),
        :Realm => 'test_realm')

    def initialize (server, *options)

        super
        @auth = server.auth
    end

    #
    # Overriding the service() method to perform a potential auth check
    #
    def service (req, res)

        if @auth == :basic

            WEBrick::HTTPAuth.basic_auth(req, res, "items") do |u, p|
                (u != nil and u == p)
            end

        elsif @auth == :digest

            $dcount += 1
            @@authenticator.authenticate(req, res)
        end

        super
    end

    def do_GET (req, res)

        i = item_id req

        return reply(res, 404, "no item '#{i}'") \
            if i and not items[i]

        representation, et, lm = fetch_representation i

        since = req['If-Modified-Since']
        since = DateTime.parse(since) if since
        match = req['If-None-Match']

        if ((not since and not match) or
            (since and (since > DateTime.parse(lm))) or
            (match and (match != et)))

            res['Etag'] = et
            res['Last-Modified'] = lm
            res.body = representation.inspect + "\n"

        else

            reply(res, 304, "Not Modified")
        end
    end

    def do_POST (req, res)

        query = WEBrick::HTTPUtils::parse_query(req.query_string)
        m = query['_method']
        m = m.downcase if m
        return do_PUT(req, res) if m == 'put'
        return do_DELETE(req, res) if m == 'delete'

        i = item_id req

        i = (@@last_item_id += 1) unless i

        items[i] = req.body
        lastmod.touch i

        res['Location'] = "#{@host}/items/#{i}"
        reply res, 201, "item created"
    end

    def do_PUT (req, res)

        i = item_id req

        return reply(res, 404, "no item '#{i}'") unless items[i]

        items[i] = req.body
        lastmod.touch i

        reply res, 200, "item updated"
    end

    def do_DELETE (req, res)

        i = item_id req

        return reply(res, 404, "no item '#{i}'") unless items[i]

        items.delete i
        lastmod.delete i

        reply res, 200, "item deleted"
    end

    #
    # clears the items
    #
    def self.flush

        @@items.clear
        @@lastmod.clear
    end

    protected

        def items
            @@items
        end

        def lastmod
            @@lastmod
        end

        def is_modified (req, key)

            since = req['If-Modified-Since']
            match = req['If-None-Match']

            return true unless since or match

            #puts
            #p [ since, match ]
            #puts

            (since or match)
        end

        #
        # Returns representation, etag, last_modified
        #
        def fetch_representation (key=nil)

            representation = if key
                items[key]
            else
                items
            end

            [ representation,
              representation.inspect.hash.to_s,
              lastmod.last_modified(key) ]
        end

        def reply (res, code, message)

            res.status = code
            res.body = message + "\n"
            res['Content-type'] = "text/plain"
        end

        def item_id (req)

            p = req.path_info[1..-1]
            return nil if not p or p == ''
            p.to_i
        end
end

#
# just redirecting to the ItemServlet...
#
class ThingServlet < WEBrick::HTTPServlet::AbstractServlet

    def do_GET (req, res)

        res.set_redirect(
            WEBrick::HTTPStatus[303],
            "http://localhost:7777/items")
    end
end

#
# testing Rufus::Verbs cookies...
#
class CookieServlet < WEBrick::HTTPServlet::AbstractServlet

    @@sessions = {}

    def do_GET (req, res)

        res.body = get_session(req, res).inspect
    end

    def do_POST (req, res)

        get_session(req, res) << req.body.strip
        res.body = "ok."
    end

    protected

        def get_session (req, res)

            c = req.cookies.find { |c| c.name == 'tcookie' }

            if c
                @@sessions[c.value]
            else
                s = []
                key = (Time.now.to_f * 100000).to_i.to_s
                @@sessions[key] = s
                res.cookies << WEBrick::Cookie.new('tcookie', key)
                s
            end
        end
end

#
# a servlet that doesn't reply (for timeout testing)
#
class LostServlet < WEBrick::HTTPServlet::AbstractServlet

    def do_GET (req, res)

        sleep 200
    end
end

#
# Serving items, a dummy resource...
# Also serving things, which just redirect to items...
#
class ItemServer

    def initialize (args={})

        port = args[:port] || 7777

        #al = [
        #    [ "", WEBrick::AccessLog::COMMON_LOG_FORMAT ],
        #    [ "", WEBrick::AccessLog::REFERER_LOG_FORMAT ]]

        @server = WEBrick::HTTPServer.new :Port => port, :AccessLog => nil

        class << @server
            attr_accessor :auth
        end

        @server.auth = args[:auth]

        @server.mount "/items", ItemServlet
        @server.mount "/things", ThingServlet
        @server.mount "/cookie", CookieServlet
        @server.mount "/lost", LostServlet

        [ 'INT', 'TERM' ].each do |signal|
            trap(signal) { shutdown }
        end
    end

    def start

        Thread.new { @server.start }
            # else the server and the test lock each other
    end

    def shutdown

        ItemServlet.flush
        @server.shutdown
    end
end