#
# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved.
# This component and the accompanying materials are made available
# under the terms of "Eclipse Public License v1.0"
# which accompanies this distribution, and is available
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
#
# Initial Contributors:
# Nokia Corporation - initial contribution.
#
# Contributors:
#
# Description:
#

import SimpleHTTPServer
import SocketServer
import threading
import httplib
import os
import simplejson
import urllib
import urlparse
import posixpath
import cgi
from StringIO import StringIO

class SimpleWebHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
    def __init__(self, request, client_address, server):
        SimpleHTTPServer.SimpleHTTPRequestHandler.__init__(self, request, client_address, server)
        self.action = ''

    def send_head(self):
        """Common code for GET and HEAD commands.

        This sends the response code and MIME headers.

        Return value is either a file object (which has to be copied
        to the outputfile by the caller unless the command was HEAD,
        and must be closed by the caller under all circumstances), or
        None, in which case the caller has nothing further to do.

        """
        (action,path) = self.translate_path(self.path)
        
        if action == 'list_resources':
            return self.list_directory(path)
        elif action == 'get_resource':
            return self.get_resource(path) 
        else:
            self.send_error(404, "File not found")
            return None

    def get_resource(self,path):
        f = None
        ctype = self.guess_type(path)
        if ctype.startswith('text/'):
            mode = 'r'
        else:
            mode = 'rb'
        try:
            f = open(path, mode)
        except IOError:
            self.send_error(404, "File not found")
            return None
        self.send_response(200)
        self.send_header("Content-type", ctype)
        fs = os.fstat(f.fileno())
        self.send_header("Content-Length", str(fs[6]))
        self.send_header("Last-Modified", self.date_time_string(fs.st_mtime))
        self.end_headers()
        return f

    def list_directory(self, path):
        """Helper to produce a directory listing (absent index.html).

        Return value is either a file object, or None (indicating an
        error).  In either case, the headers are sent, making the
        interface the same as for send_head().

        """
        try:
            list = os.listdir(path)
        except os.error:
            self.send_error(404, "No permission to list directory")
            return None
        list.sort(key=lambda a: a.lower())
        f = StringIO()
        displaypath = cgi.escape(urllib.unquote(self.path))
        files = []
        for name in list:
            fullname = os.path.join(path, name)
            displayname = linkname = name
            # Append / for directories or @ for symbolic links
            if os.path.isdir(fullname):
                displayname = name + "/"
                linkname = name + "/"
            if os.path.islink(fullname):
                displayname = name + "@"
                # Note: a link to a directory displays with @ and links with /
            files.append(displayname)
        
        f.write(simplejson.dumps(files))
        length = f.tell()
        f.seek(0)
        self.send_response(200)
        self.send_header("Content-type", "text/html")
        self.send_header("Content-Length", str(length))
        self.end_headers()
        return f

    def translate_path(self, path):
        """Translate a /-separated PATH to the local filename syntax.

        Components that mean special things to the local file system
        (e.g. drive or directory names) are ignored.  (XXX They should
        probably be diagnosed.)
        @return: action,path
        """
        # abandon query parameters
        action = ''
        path = urlparse.urlparse(path)[2]
        path = path.lstrip('/')
        splittedpath = path.split('/')
        if len(splittedpath) > 1:
            action = splittedpath[1]
            path   = "/".join(splittedpath[2:])
            path = posixpath.normpath(urllib.unquote(path))
            words = path.split('/')
            words = filter(None, words)
            path = os.getcwd()
            for word in words:
                drive, word = os.path.splitdrive(word)
                head, word = os.path.split(word)
                if word in (os.curdir, os.pardir): continue
                path = os.path.join(path, word)
        return (action,path)
        

class SimpleWebServer(threading.Thread):
    def __init__(self, folder=".", port=8000):
        super(SimpleWebServer,self).__init__()
        self.PORT    = port
        self.folder  = folder
        self.handler = SimpleWebHandler
        self.httpd   = SocketServer.TCPServer(("localhost", self.PORT), self.handler)
        self.active  = False
        print "serving at port", self.PORT
 
    def run(self):
        # minimal web server.  serves files relative to the
        # current directory.
        os.chdir(self.folder)
        self.active = True
        while self.active:
            self.httpd.handle_request()
        return 0

    def stop(self):
        self.active = False
        conn = httplib.HTTPConnection('localhost', self.PORT)
        conn.request("GET", "/")
        r1 = conn.getresponse()
        print r1.status, r1.reason

if __name__ == '__main__':
    server = SimpleWebServer()
    server.start()