#!/usr/bin/env python

__author__ = "Gustavo Sverzut Barbieri / Artur Duque de Souza"

__author_email__ = "barbieri@gmail.com / artur.souza@indt.org.br"

__license__ = "GPL"

__version__ = "0.3"

import os

import cgi

import socket

import logging

import urlparse

import threading

import SocketServer

import BaseHTTPServer

import mimetypes

import lib.utils as utils

import lib.file_handler as files

import lib.transcoder as transcoder

from log import Log

__all__ = ("RequestHandler")

class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):

    """Class that implements an HTTP request handler for our server."""

    log = logging.getLogger("gms.request")

    def_transcoder = None

    transcoders = utils.PluginSet(transcoder.Transcoder)

    transcoders_log = Log()

    tid_queue = []

    menu = {

        "Log": "/get_log.do",

        "Stop": "/stop-transcoder.do",

        "Status": "/status.do",

        "All Log": "/get_all_log.do",

        "Version": "/version.do",

        "Shutdown": "/shutdown.do"

        }

    @classmethod

    def load_plugins_transcoders(cls, directory):

        cls.transcoders.load_from_directory(directory)

        if cls.def_transcoder is None and cls.transcoders:

            cls.def_transcoder = cls.transcoders[0].name

    # load_plugins_transcoders()

    def do_dispatch(self, body):

        self.url = self.path

        pieces = urlparse.urlparse(self.path)

        self.path = pieces[2]

        self.query = cgi.parse_qs(pieces[4])

        url = {

            "/": self.serve_main,

            "/shutdown.do": self.serve_shutdown,

            "/stop-transcoder.do": self.serve_stop_transcoder,

            "/status.do": self.serve_status,

            "/version.do": self.serve_version,

            "/new_id.do": self.serve_new_id,

            "/get_log.do": self.serve_get_log,

            "/get_all_log.do": self.serve_get_all_log,

            "/stream.do": self.serve_stream,

            "/transcode.do": self.serve_transcode,

            "/list.do": self.serve_list,

            "/get_file_info.do": self.serve_file_info,

            }

        try:

            url[self.path](body)

        except KeyError:

            try:

                action = self.query.get("action", None)

                if action and "stream.do" in action:

                    self.serve_stream(body)

                elif os.path.exists("html/%s" % self.path):

                    data = open("html/%s" % self.path)

                    self.wfile.write(data.read())

                else:

                    self.send_error(404, "File not found")

            except Exception, e:

                self.log.error(e)

    # do_dispatch()

    def do_GET(self):

        self.do_dispatch(True)

    # do_GET()

    def do_HEAD(self):

        self.do_dispatch(False)

    # do_HEAD()

    def _nav_items(self):

        ret = ""

        for name, url in self.menu.items():

            ret += utils.getHTML("menu", {"name": name, "url": url})

        return ret

    # _nav_items()

    def serve_main(self, body):

        self.send_response(200)

        self.send_header("Content-Type", "text/html")

        self.send_header('Connection', 'close')

        self.end_headers()

        if body:

            self.wfile.write(utils.getHTML("index", {"menu": self._nav_items()}))

    # serve_main()

    def serve_version(self, body):

        self.send_response(200)

        self.send_header("Content-Type", "text/html")

        self.send_header('Connection', 'close')

        self.end_headers()

        if body:

            self.wfile.write("Version: %s" %  __version__)

    # serve_version

    def serve_shutdown(self, body):

        self.send_response(200)

        self.send_header("Content-Type", "text/html")

        self.send_header('Connection', 'close')

        self.end_headers()

        if body:

            self.wfile.write(utils.getHTML("shutdown"))

        self.server.server_close()

    # serve_shutdown()

    def serve_list(self, body):

        self.send_response(200)

        self.send_header("Content-Type", "text/html")

        self.send_header('Connection', 'close')

        self.end_headers()

        if body:

            file_list = []

            files.list_media_files(utils.config.get_transcoded_location(), file_list)

            output = files.FileList(map(lambda x, y: x+y, file_list,

                                        ["<br>"]*len(file_list)))

            self.wfile.write(output)

    # serve_list()

    def serve_stop_all_transcoders(self, body):

        self.send_response(200)

        self.send_header("Content-Type", "text/html")

        self.send_header('Connection', 'close')

        self.end_headers()

        if body:

            self.server.stop_transcoders()

            self.wfile.write(utils.getHTML("stop_all",

                                           {"menu": self._nav_items()}))

    # serve_stop_all_transcoders()

    def serve_stop_selected_transcoders(self, body, tids=[]):

        self.send_response(200)

        self.send_header("Content-Type", "text/html")

        self.send_header('Connection', 'close')

        self.end_headers()

        opts = ""

        if body:

            transcoders = self.server.get_transcoders()

            for tid in tids:

                for t, r in transcoders:

                    if t.tid == int(tid):

                        try:

                            t.stop()

                        except Exception, e:

                            self.log.info("Plugin already stopped")

                        opts += utils._create_html_item("%s" % t)

                        break

                self.wfile.write(utils.getHTML("stop_selected",

                                               {"menu": self._nav_items(),

                                                "opts": opts}))

    # serve_stop_selected_transcoders()

    def serve_stop_transcoder(self, body):

        req = self.query.get("request", None)

        tid = self.query.get("tid", None)

        if req and "all" in req:

            self.serve_stop_all_transcoders(body)

        elif tid:

            self.serve_stop_selected_transcoders(body, tid[0].split(";"))

        else:

            self.serve_status(body)

    # serve_stop_transcoder()

    def serve_status(self, body):

        self.send_response(200)

        self.send_header("Content-Type", "text/html")

        self.send_header('Connection', 'close')

        self.end_headers()

        stopone = ""

        running = ""

        stopall = ""

        if body:

            tl = self.server.get_transcoders()

            if not tl and not self.query.get("tid", None) and \

                   not self.query.get("running", None):

                running = "<p>No running transcoder.</p>\n"

            elif not tl and self.query.get("tid", None):

                tids = self.query.get("tid")

                for tid in tids:

                    stat = self.transcoders_log.get_status(int(tid))

                    self.wfile.write("%s<br>" % stat)

                return True

            elif self.query.get("running", None):

                for transcoder, request in tl:

                    outf = transcoder.params_first("outfile")

                    tid = transcoder.tid

                    self.wfile.write("%s:%s<br>" % (tid, outf))

                return True

            elif self.query.get("tid", None):

                req_tid = self.query.get("tid")

                for transcoder, request in tl:

                    if str(transcoder.tid) in req_tid:

                        self.wfile.write("Status:%s:%s %%" % (\

                            transcoder.tid, transcoder.status))

                        return True

                stat = self.transcoders_log.get_status(int(req_tid[0]))

                self.wfile.write("%s<br>" % stat)

                return True

            else:

                running = "<p>Running transcoders:</p>\n"

                stopall = utils._create_html_item("<a href='%s?request=all'>"

                                                 "[STOP ALL]</a>" %

                                                 self.menu["Stop"])

                for transcoder, request in tl:

                    stopone += utils._create_html_item("%s;"

                                                       "<a href='%s?tid=%s'>"

                                                       " [STOP] </a>") % (

                        transcoder, self.menu["Stop"], transcoder.tid)

            self.wfile.write(utils.getHTML("status",

                                           {"menu": self._nav_items(),

                                            "running": running,

                                            "stopall": stopall,

                                            "stopone": stopone}))

    # serve_status()

    def _get_transcoder(self):

        # get transcoder option: mencoder is the default

        request_transcoders = self.query.get("transcoder", ["mencoder"])

        for t in request_transcoders:

            transcoder = self.transcoders.get(t)

            if transcoder:

                return transcoder

        if not transcoder:

            return self.transcoders[self.def_transcoder]

    # _get_transcoder()

    def _get_new_id(self, tid):

        self.server.last_tid = utils.create_tid(tid)

        self.tid_queue.append(self.server.last_tid)

        return self.server.last_tid

    # _get_new_id()

    def serve_new_id(self, body):

        self.send_response(200)

        self.send_header("Content-Type", "text/html")

        self.send_header('Connection', 'close')

        self.end_headers()

        if body:

            self.wfile.write("%s" % self._get_new_id(self.server.last_tid))

    # serve_new_id()

    def serve_get_log(self, body):

        self.send_response(200)

        self.send_header("Content-Type", "text/html")

        self.send_header('Connection', 'close')

        self.end_headers()

        if body:

            if self.query.get("tid", None):

                tid = int(self.query.get("tid")[0])

                stat = self.transcoders_log.get_status(tid)

                self.wfile.write("Status: %s" % stat)

            else:

                stat = self.transcoders_log.get_status()

                for rtid, status in stat.iteritems():

                    self.wfile.write("<b>%s</b>: %s<br><br>" % (rtid, status))

    # serve_get_log()

    def serve_get_all_log(self, body):

        self.send_response(200)

        self.send_header("Content-Type", "text/html")

        self.send_header('Connection', 'close')

        self.end_headers()

        if body:

            if self.query.get("tid", None):

                tid = int(self.query.get("tid")[0])

                stat = self.transcoders_log.get_status(tid, True)

                for status in stat:

                    self.wfile.write("%s<br><br>" % status)

            else:

                stat = self.transcoders_log.get_status(None, True)

                for rtid, history in stat.iteritems():

                    for status in history:

                        self.wfile.write("<b>%s</b>: %s<br>" % (rtid, status))

                    self.wfile.write("<br><br>")

    # serve_get_all_log()

    def serve_file_info(self, body):

        if body:

            file_dat = self.query.get("file", None)

            if file_dat:

                self.send_response(200)

                self.send_header("Content-Type", "text/html")

                self.send_header('Connection', 'close')

                self.end_headers()

                try:

                    opts = files.TranscodedFile(file_dat[0], self.query).opts

                    for key in opts.keys():

                        self.wfile.write("%s=%s<br>" % (key, opts.get(key, "None")[0]))

                except Exception, e:

                    self.send_error(500, str(e))

                    return

    # serve_file_info()

    def serve_stream(self, body):

	args = self.query.get("file", None)

	if not args:

	    self.send_error(404, "File not found")

	    return

        filename = args[0];	

        if not filename:

            self.send_error(404, "File not found")

            return

        #Only stream files on .transcode dir

        filename = os.path.join (utils.config.get_transcoded_location(), os.path.basename(filename))

        self.log.error("Stream file: %s" % filename)

        if not os.path.exists (filename):

            self.send_error(404, "File not found")

            return

        size = int(os.path.getsize(filename))

        self.send_response(200)

        self.send_header("Content-Type", mimetypes.guess_type(filename)[0])

        self.send_header("Cache-Control","no-cache")

        self.send_header("Content-Length", size)

        #self.send_header("Connection", "close")

        self.end_headers()

        media = open(filename)

        data_in = " "

        total_read = 0

        test_tid = int(self.query.get("tid", "0")[0])

        if test_tid == 0 or test_tid not in self.tid_queue:

            test_tid = self._get_new_id(self.server.last_tid)

        self.transcoders_log.insert(test_tid, "gms.Stream: %s" % filename)

        try:

            file_data = ""

            while data_in != "":

                data_in = media.read(4096)

                file_data += data_in

                #total_read += 4096

            self.wfile.write(file_data)

                #status = utils.progress_bar(total_read, size, 50)

                #msg_status = "Status:%s:%s%%" % (test_tid, status)

                #self.transcoders_log._update_status(test_tid, msg_status)

            self.transcoders_log._update_status(test_tid, "OK: Done")

        except Exception, e:

            self.log.error("Stream error: %s" %e)

            self.transcoders_log._update_status(test_tid, "Error: %s" % e)

    # serve_stream()

    def serve_transcode(self, body):

        type = self.query.get("type", None)[0]

        if type.upper() == "FILE":

            self.send_error(404, "Transcode local files not allowed")

            return

        transcoder = self._get_transcoder()

        try:

            obj = transcoder(self.query)

        except Exception, e:

            self.send_error(500, str(e))

            return

        self.send_response(200)

        self.send_header("Content-Type", obj.get_mimetype())

        self.send_header("Cache-Control","no-cache")

        if (obj.name == "gmencoder"):

            self.send_header("Transfer-Encoding", "chunked")

        #self.send_header("Connection", "close")

        self.end_headers()

        if body:

            test_tid = int(self.query.get("tid", "0")[0])

            if test_tid == 0 or test_tid not in self.tid_queue:

                test_tid = self._get_new_id(self.server.last_tid)

            if self.query.get("transcoder", None):

                self.transcoders_log.insert(test_tid, "gms.%s" % obj.name)

                obj.tid = test_tid

                obj.log = self.transcoders_log

                self.server.add_transcoders(self, obj)

                if obj.start(self.wfile):

                    self.transcoders_log.info (test_tid, "OK")

                else:

                    self.transcoders_log.info (test_tid, "Fail")

                self.server.del_transcoders(self, obj)

                files.TranscodedFile("", self.query)

    # serve_stream()

    def log_request(self, code='-', size='-'):

        self.log.info('"%s" %s %s', self.requestline, str(code), str(size))

    # log_request()

    def log_error(self, format, *args):

        self.log.error("%s: %s" % (self.address_string(), format % args))

    # log_error()

    def log_message(self, format, *args):

        self.log.info("%s: %s" % (self.address_string(), format % args))

    # log_message()

# RequestHandler