#!/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.4"

import os
import threading
import SocketServer
import BaseHTTPServer
import socket
import urlparse
import cgi
import lib.utils as utils
import logging

from log import Log
from request_handler import RequestHandler

__all__ = ("Server", "serve_forever", "load_plugins_transcoders")

class Server(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer):
    log = logging.getLogger("gms.server")
    last_tid = 0
    run = True
    _transcoders = {}
    _lock = threading.RLock()

    def serve_forever(self):
        self.log.info("GMyth-Streamer serving HTTP on %s:%s" %
                      self.socket.getsockname())
        try:
            while self.run:
                self.handle_request()
        except KeyboardInterrupt, e:
            pass

        self.log.debug("Stopping all remaining transcoders...")
        self.stop_transcoders()
        self.log.debug("Transcoders stopped!")
    # serve_forever()


    def get_request(self):
        skt = self.socket
        old = skt.gettimeout()
        skt.settimeout(0.5)
        while self.run:
            try:
                r = skt.accept()
                skt.settimeout(old)
                return r
            except socket.timeout, e:
                pass
        raise socket.error("Not running")
    # get_request()


    def server_close(self):
        self.run = False
        self.stop_transcoders()

        BaseHTTPServer.HTTPServer.server_close(self)
    # server_close()


    def stop_transcoders(self):
        self._lock.acquire()
        for transcoder, request in self._transcoders.iteritems():
            self.log.info("Stop transcoder: %s, client=%s" %
                          (transcoder, request.client_address))
            transcoder.stop()
        self._lock.release()
    # stop_transcoders()


    def get_transcoders(self):
        self._lock.acquire()
        try:
            return self._transcoders.items()
        finally:
            self._lock.release()
    # get_transcoders()


    def add_transcoders(self, request, transcoder):
        self._lock.acquire()
        try:
            self._transcoders[transcoder] = request
        finally:
            self._lock.release()
    # add_transcoders()


    def del_transcoders(self, request, transcoder):
        self._lock.acquire()
        try:
            del self._transcoders[transcoder]
        finally:
            self._lock.release()
    # del_transcoders()
# Server



def serve_forever(host="0.0.0.0", port=40000):
    addr = (host, port)
    RequestHandler.protocol_version = "HTTP/1.0"
    httpd = Server(addr, RequestHandler)
    httpd.serve_forever()
# serve_forever()


def load_plugins_transcoders(directory):
    RequestHandler.load_plugins_transcoders(directory)
# load_plugins_transcoders()