import os

import sys

import lib

import time

import signal

import socket

import ConfigParser

from select import *

from subprocess import *

class Media(object):

    def __init__(self, config):

        self.config = config

        self.args = ""

        self.language = "en"

        self.socket = None

        self.child_pid = None

        self.mplayer = None

        self.mencoder_pid = None

        self.mplayer_pid = None

        signal.signal(signal.SIGABRT, self.kill_handler)

    # __init__

    def kill_handler(self, sig, frame):

        try:

            os.kill(self.mplayer_pid.pid, signal.SIGKILL)

            log.debug("Killed Mplayer")

            sys.exit(0)

        except:

            log.error("Problems closing child")

    # kill_handler

    def set_args(self, options):

        for opt in options:

            if opt == "local":

                self.mplayer = lib.which("mplayer")

            elif opt.find("language=") >= 0:

                try:

                    self.language = opt.split("=")[1]

                except:

                    log.error("Bad language option")

            elif opt.find("format=") >= 0:

                try:

                    self.mux += " -mpegopts format=%s" % opt.split("=")[1]

                except:

                    log.error("Bad format option")

    # set_args

    def run_mplayer(self):

        msg = self.filename

        if self.kind == "dvd":

            msg = "dvd://" + msg

        self.mplayer_pid = Popen([self.mplayer, self.filename, "1> %s" % os.devnull,\

                                  "2> %s" % os.devnull], stdout=PIPE, close_fds=True)

    # run_mplayer

    def setup_mencoder(self):

        self.path = self.config.get("Mencoder", "path")

        mp = Popen([self.path], stdout=PIPE, close_fds=True)

        version = mp.stdout.read().split("MEncoder ")[1].split(" (C)")[0].split("-")[-1]

        if version > "4.1.1": self.mencoder_old = False

        else: self.mencoder_old = True

        os.kill(mp.pid, signal.SIGKILL)

        log.info("Mencoder version: %s" % version)

        if self.mencoder_old:

            self.fifo = self.config.get("Mencoder", "fifo_path")

        else:

            self.fifo = "-"

    # setup_mencoder

    def setup_audio(self, acodec):

        if acodec == "mp3lame":

            return "-oac mp3lame -lameopts cbr:br=%s vol=5" % self.abitrate

        else:

            return = "-oac lavc -lavcopts acodec=%s:abitrate=%s" % (\

                self.acodec, self.abitrate)

    def setup_filename(self, filename):

        try:

            self.kind, self.filename = filename.split("://")

        except:

            return (False, "Wrong filename protocol")

        audio = setup_audio(self.acodec)

        if self.kind == "file":

            if not os.path.exists(self.filename):

                msg = "File requested does not exist. SETUP failed."

                log.error(msg)

                return (False, msg)

            self.args += " %s -mf fps=%s -of %s %s"\

                         " -ovc lavc -lavcopts vcodec=%s:vbitrate=%s -vf scale=%s:%s"\

                         " -really-quiet -o %s 2>/dev/null" % (

                self.filename, self.fps, self.mux, audio, self.vcodec,

                self.vbitrate, self.width, self.height, self.fifo)

        elif self.kind == "dvd":

            self.args += " dvd://%s -alang %s -vf scale=%s:%s %s"\

                         " -of %s -ovc lavc -lavcopts vcodec=%s:vbitrate=%s"\

                         " -ofps %s -really-quiet -o %s 2>/dev/null" % (

                self.filename, self.language, self.width, self.height, audio,

                self.mux, self.vcodec, self.vbitrate, self.fps, self.fifo)

        return (True, "")

    # setup_filename

    def setup_socket(self, socket):

        if socket != None:

            del(socket)

        socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

        socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

        try:

            socket.bind( ('', self.port) )

            socket.listen(1)

        except Exception, e:

            log.error("Could not create socket: %s" % e)

            return (False, e)

        return (True, "")

    '''

    MENCODER SETUP DESCRIPTION

    ===========================

    -> mux, vcodecs and acodecs

     |-> mencoder (-of | -ovc | -oac) help

    -> if used mpeg as mux:

     |-> to setup format: format=%s as an option at the end

    '''

    def setup(self, filename, mux, vcodec, vbitrate,\

              fps, acodec, abitrate, width, height, port, options):

        self.mux = mux

        self.vcodec = vcodec

        self.vbitrate = vbitrate

        self.fps = fps

        self.acodec = acodec

        self.abitrate = abitrate

        self.width = width

        self.height = height

        self.port = int(port)

        self.setup_mencoder()

        ret_val = self.setup_filename(filename)

        if not ret_val[0]:

            return ret_val[1]

        self.set_args(options)

        # good one: /tmp/dvb.mpg avi mpeg4 400 25 mp3lame 192 320 240 5000 file

        # /tmp/dvb.mpg mpeg mpeg1video 400 25 mp2 192 320 240 5000 format=mpeg1 file

        #4 mpeg mpeg1video 400 25 mp3lame 192 400 240 5000 language=en local dvd

        ret_val = setup_socket(self.socket)

        if not ret_val[0]:

            return ret_val[1]

        return True

    # setup

    def play(self):

        if self.mencoder_old:

            try:

                os.mkfifo(self.fifo)

            except:

                lib.log("Fifo already exists")

        lib.log("Starting Mencoder: %s %s" % (self.path, self.args) )

        # exec Mencoder

        if self.mencoder_old:

            self.mencoder_pid = Popen(self.path + self.args, shell=True,

                                      close_fds=True)

            self.pout = open(self.fifo)

        else:

            self.path += self.args

            pin, self.pout = os.popen2(self.path)

        self.child_pid = os.fork()

        if self.child_pid == 0:

            conn,addr= self.socket.accept()

            lib.log("Sending Data to client: %s" % addr[0])

            data = self.pout.read(1024)

            conn.settimeout(5)

            retry = 0

            while data != "" and retry < 5:

                try:

                    conn.send(data)

                    r, w, x = select([conn], [], [], 0)

                    if conn in r:

                        back = conn.recv(1024)

                        if back == "OK" and self.mplayer and not self.mplayer_pid:

                            self.run_mplayer()

                except socket.error:

                    lib.log("Socket error (maybe timeout ?)")

                    retry += 1

                data = self.pout.read(1024)

            if retry < 5:

                lib.log("Finished sending Data to client: %s" % addr[0])

            else:

                lib.log("Client timed out")

            sys.exit(0)

    def stop(self):

        try:

            if self.mplayer_old:

                os.kill(self.mencoder_pid.pid + 1, signal.SIGKILL)

            else:

                self.pout.close()

            self.mplayer = None

        except:

            lib.log("Trying to stop before playing...")

        if self.socket != None:

            lib.log("Closing socket")

            self.socket.close()

            lib.log("Trying to stop Mencoder process")

            if self.child_pid != None:

                os.kill(self.child_pid, signal.SIGABRT)