import os
import sys
import math
import re
import httplib
import cStringIO
import mimetools
import mimetypes
import weakref
import cgi
import logging

from cosocket import *
import channels

try:
    import json
except ImportError:
    import simplejson as json

KEEP_ALIVE_MAX_REQUESTS = 99
KEEP_ALIVE_TIMEOUT = int(DEFAULT_TIMEOUT)
KEEP_ALIVE_ENABLED = True

BLOCK_SIZE = 8192

def until_http_response_sent(msg = '', mimetype = 'text/plain',
                             length = None, code = 200,
                             additional_headers = None):
    headers = {'Content-Type': mimetype}
    if KEEP_ALIVE_ENABLED:
        headers.update({'Keep-Alive': 'timeout=%d, max=%d' %
                        (KEEP_ALIVE_TIMEOUT,
                         KEEP_ALIVE_MAX_REQUESTS),
                        'Connection': 'Keep-Alive'})
    if additional_headers:
        headers.update(additional_headers)
    if length is None:
        length = len(msg)
    headers['Content-Length'] = str(length)

    header_lines = ['HTTP/1.1 %d %s' % (code,
                                        httplib.responses[code])]
    header_lines.extend(['%s: %s' % (key, value)
                         for key, value in headers.items()])
    header_lines.extend(['', msg])
    content = '\r\n'.join(header_lines)
    yield until_sent(content)

def until_http_file_sent(filename, block_size = BLOCK_SIZE):
    ext = '.' + filename.split('.')[-1]

    if ext in mimetypes.types_map:
        mimetype = mimetypes.types_map[ext]
    else:
        mimetype = 'text/plain'

    length = os.stat(filename).st_size
    num_blocks = length / block_size
    if length % block_size:
        num_blocks += 1
    infile = open(filename, 'r')

    yield until_http_response_sent(mimetype = mimetype,
                                   length = length)

    for i in range(num_blocks):
        # TODO: This could be bad since we're reading the file
        # synchronously.
        block = infile.read(block_size)
        yield until_sent(block)

class AsyncWebServer(object):
    def __init__(self, addr, app):
        self._num_connections = 0
        self._app = app
        AsyncChatCoroutine(self._server_coroutine(addr))

    def _server_coroutine(self, bind_addr):
        yield until_listening(bind_addr)
        while 1:
            conn, addr = yield until_connection_accepted()
            AsyncChatCoroutine(self._connection_coroutine(addr), conn)

    def _connection_coroutine(self, addr):
        self._num_connections += 1
        try:
            if KEEP_ALIVE_ENABLED:
                for i in range(KEEP_ALIVE_MAX_REQUESTS):
                    yield self._until_one_request_processed(addr)
            else:
                yield self._until_one_request_processed(addr)
        finally:
            logging.info('Closing connection to %s' % repr(addr))
            self._num_connections -= 1

    def _until_one_request_processed(self, addr):
        request = yield until_received(terminator = '\r\n\r\n')
        request = request.splitlines()
        request_line = request[0]
        logging.info("Request from %s: %s" % (addr, request_line))
        stringfile = cStringIO.StringIO('\n'.join(request[1:]))
        headers = mimetools.Message(stringfile)
        req_parts = request_line.split()

        yield self._app.until_request_processed(method = req_parts[0],
                                                path = req_parts[1],
                                                headers = headers,
                                                addr = addr)

class BugzillaApiApp(object):
    QUERYSTRING_TEMPLATE = re.compile('([^\?]*)\?(.*)')
    REDIRECT_TEMPLATE = re.compile('\/([A-Za-z0-9_]+)$')
    URL_TEMPLATE = re.compile('\/([A-Za-z0-9_]+)/(.*)')
    MAX_MESSAGE_SIZE = 8192
    ROBOTS_TXT = "User-agent: *\r\nDisallow: /"

    def __init__(self, media_dir, index_filename):
        self._media_dir = media_dir
        self._index_filename = index_filename

    def until_request_processed(self, method, path, headers, addr):
        match = self.URL_TEMPLATE.match(path)

        if path == '/':
            yield until_http_file_sent(self._index_filename)
        elif not match:
            match = self.REDIRECT_TEMPLATE.match(path)
            if match:
                newpath = path + '/'
                yield until_http_response_sent(
                    newpath,
                    code = 301,
                    additional_headers = {'Location': newpath}
                    )
            elif path == '/robots.txt':
                yield until_http_response_sent(self.ROBOTS_TXT)
            else:
                yield until_http_response_sent('not found',
                                               code = 404)
        else:
            conv_name = match.group(1)
            page = match.group(2)
            if conv_name == 'status':
                # TODO: Return 404 if page is non-empty.
                lines = ('open connections  : %d' % self._num_connections,
                         'open timers       : %d' % len(time_map))
                yield until_http_response_sent('\r\n'.join(lines))
            elif conv_name == 'media':
                path = os.path.join(self._media_dir, *page.split('/'))
                path = os.path.normpath(path)
                if (path.startswith(self._media_dir) and
                    os.path.exists(path) and
                    os.path.isfile(path)):
                    yield until_http_file_sent(path)
                else:
                    yield until_http_response_sent('not found',
                                                   code = 404)
            else:
                yield self._until_conv_request_processed(addr, headers,
                                                         method, conv_name,
                                                         page)

    def _parse_qs(self, querystring):
        querydict = {}
        cgi_querydict = cgi.parse_qs(querystring)
        for key, value in cgi_querydict.items():
            querydict[key] = cgi_querydict[key][0]
        return querydict

    def _until_conv_request_processed(self, addr, headers, method,
                                      conv_name, page):
        match = self.QUERYSTRING_TEMPLATE.match(page)
        querydict = {}
        if match:
            querydict.update(self._parse_qs(match.group(2)))
            page = match.group(1)
        if page == 'listen':
            logging.info("Waiting for message on channel '%s' for %s" %
                         (conv_name, addr))
            msg = yield channels.until_message_received(conv_name)
            yield until_http_response_sent(
                json.dumps(msg),
                mimetype = 'application/json'
                )
        elif page == 'send':
            length = int(headers.getheader('Content-Length', 0))
            if length == 0 or length > self.MAX_MESSAGE_SIZE:
                yield until_http_response_sent('message too large',
                                               code = 413)
            else:
                msg = yield until_received(bytes = length)
                json_msg = json.loads(msg)
                yield channels.until_message_sent(conv_name, json_msg)
                yield until_http_response_sent('sent.')
        else:
            yield until_http_response_sent('not found', code = 404)

if __name__ == '__main__':
    args = dict(ip = '127.0.0.1',
                port = 8071,
                logfile = '',
                loglevel = 'info',
                media_dir = os.path.abspath('media'))

    args['index_filename'] = os.path.join(args['media_dir'], 'html',
                                          'index.html')
    args['loglevel'] = getattr(logging, args['loglevel'].upper())
    if args['logfile']:
        logging.basicConfig(filename = args['logfile'],
                            level = args['loglevel'])
    else:
        logging.basicConfig(stream = sys.stdout,
                            level = args['loglevel'])

    app = BugzillaApiApp(media_dir = args['media_dir'],
                         index_filename = args['index_filename'])

    server = AsyncWebServer(addr = (args['ip'], args['port']),
                            app = app)

    logging.info("Starting server with configuration: %s" % args)
    loop()