import os

import urllib

import time

import re

from cPickle import load, dump

from webob import Request, Response, html_escape

from webob import exc

class Commenter(object):

    def __init__(self, app, storage_dir):

        self.app = app

        self.storage_dir = storage_dir

        if not os.path.exists(storage_dir):

            os.makedirs(storage_dir)

    def __call__(self, environ, start_response):

        req = Request(environ)

        if req.path_info_peek() == '.comments':

            return self.process_comment(req)(environ, start_response)

        # This is the base path of *this* middleware:

        base_url = req.application_url

        resp = req.get_response(self.app)

        if resp.content_type != 'text/html' or resp.status_int != 200:

            # Not an HTML response, we don't want to

            # do anything to it

            return resp(environ, start_response)

        # Make sure the content isn't gzipped:

        resp.decode_content()

        comments = self.get_data(req.url)

        body = resp.body

        body = self.add_to_end(body, self.format_comments(comments))

        body = self.add_to_end(body, self.submit_form(base_url, req))

        resp.body = body

        return resp(environ, start_response)

    def get_data(self, url):

        # Double-quoting makes the filename safe

        filename = self.url_filename(url)

        if not os.path.exists(filename):

            return []

        else:

            f = open(filename, 'rb')

            data = load(f)

            f.close()

            return data

    def save_data(self, url, data):

        filename = self.url_filename(url)

        f = open(filename, 'wb')

        dump(data, f)

        f.close()

    def url_filename(self, url):

        return os.path.join(self.storage_dir, urllib.quote(url, ''))

    _end_body_re = re.compile(r'</body.*?>', re.I|re.S)

    def add_to_end(self, html, extra_html):

        """

        Adds extra_html to the end of the html page (before </body>)

        """

        match = self._end_body_re.search(html)

        if not match:

            return html + extra_html

        else:

            return html[:match.start()] + extra_html + html[match.start():]

    def format_comments(self, comments):

        if not comments:

            return ''

        text = []

        text.append('<hr>')

        text.append('<h2><a name="comment-area"></a>Comments (%s):</h2>' % len(comments))

        for comment in comments:

            text.append('<h3><a href="%s">%s</a> at %s:</h3>' % (

                html_escape(comment['homepage']), html_escape(comment['name']),

                time.strftime('%c', comment['time'])))

            # Susceptible to XSS attacks!:

            text.append(comment['comments'])

        return ''.join(text)

    def submit_form(self, base_path, req):

        return '''<h2>Leave a comment:</h2>

        <form action="%s/.comments" method="POST">

         <input type="hidden" name="url" value="%s">

         <table width="100%%">

          <tr><td>Name:</td>

              <td><input type="text" name="name" style="width: 100%%"></td></tr>

          <tr><td>URL:</td>

              <td><input type="text" name="homepage" style="width: 100%%"></td></tr>

         </table>

         Comments:<br>

         <textarea name="comments" rows=10 style="width: 100%%"></textarea><br>

         <input type="submit" value="Submit comment">

        </form>

        ''' % (base_path, html_escape(req.url))

    def process_comment(self, req):

        try:

            url = req.params['url']

            name = req.params['name']

            homepage = req.params['homepage']

            comments = req.params['comments']

        except KeyError, e:

            resp = exc.HTTPBadRequest('Missing parameter: %s' % e)

            return resp

        data = self.get_data(url)

        data.append(dict(

            name=name,

            homepage=homepage,

            comments=comments,

            time=time.gmtime()))

        self.save_data(url, data)

        resp = exc.HTTPSeeOther(location=url+'#comment-area')

        return resp

if __name__ == '__main__':

    import optparse

    parser = optparse.OptionParser(

        usage='%prog --port=PORT BASE_DIRECTORY'

        )

    parser.add_option(

        '-p', '--port',

        default='8080',

        dest='port',

        type='int',

        help='Port to serve on (default 8080)')

    parser.add_option(

        '--comment-data',

        default='./comments',

        dest='comment_data',

        help='Place to put comment data into (default ./comments/)')

    options, args = parser.parse_args()

    if not args:

        parser.error('You must give a BASE_DIRECTORY')

    base_dir = args[0]

    from paste.urlparser import StaticURLParser

    app = StaticURLParser(base_dir)

    app = Commenter(app, options.comment_data)

    from wsgiref.simple_server import make_server

    httpd = make_server('localhost', options.port, app)

    print 'Serving on http://localhost:%s' % options.port

    try:

        httpd.serve_forever()

    except KeyboardInterrupt:

        print '^C'