import socket
import time
import threading
import thread
import os

class MythBackendConnection(threading.Thread):

    def __init__(self, videoPlayer, server, port):    
        self.protocolVersion = 31
        self.localhost_name = "myhost" # Change this later
        self.server = server #"192.168.0.8"
        self.server_port = port #6543
        self.addr = (self.server, self.server_port)
        self.videoPlayer = videoPlayer
        self.lock = False #Dictakes whether or not we have a signal lock
        
        #3 Sockets, 1 for cmds, 1 for data, 1 for monitoring messages
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.data_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.data_sock.connect((self.server, self.server_port))
        self.msg_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.msg_sock.connect((self.server, self.server_port))
        
        thread.start_new_thread(self.message_socket_mgr,(self.msg_sock,))
        
        #self.sock.connect( ("192.168.0.8", 6543) )
        self.connected = False
        self.recorder = None # Mythtv recorder
        self.connect(self.server, self.server_port)
        
        threading.Thread.__init__(self)
        
    #def start(self):
    #    threading.Thread.start(self)
         
        
    def run(self):
        print "Starting thread"
        self.setup_recorder()
        self.spawn_live()
        #self.disconnect()
        
    def receive_reply(self, sock):
        ret = ""
        tmp = sock.recv(8)
        count = int(tmp)
        #debug("REPLY LEN: %d" % count)
        ret = sock.recv(count)

        #print "read<--" + ret
        return ret

    def send_cmd(self, sock, base_cmd):
        cmd = str(len(base_cmd)).ljust(8) + base_cmd
        sock.send(cmd)
        #print "write-->" + cmd  
        
    def connect(self, host, port):
        self.sock.connect((host, port))
        
        #Do the protocol version check
        protString = "MYTH_PROTO_VERSION "+ str(self.protocolVersion)
        self.send_cmd(self.sock, protString)
        protRecvString = "ACCEPT[]:[]" + str(self.protocolVersion)
        result = self.receive_reply(self.sock)
        print result
        if not result == protRecvString:
            #Protocol Version check failed
            raise RuntimeError, "Myth Protocol version failure. Aborting."
        
        #Perform the mandatory ANN
        ANNstring = "ANN Playback " + self.localhost_name + " 0"
        self.send_cmd(self.sock, ANNstring)
        ANN_recv_string = "OK" #What a successful return should be
        result = self.receive_reply(self.sock)
        if not result == ANN_recv_string:
            raise RuntimeError, "Myth: ANN connection failed"
        
        #All looks good
        self.connected = True
        
    def disconnect(self):
        self.sock.close()
        
    def setup_recorder(self):
        if not self.connected:
            print "Cannot get recorder, no server connection exists"
            return None
            
        recorder_request_string = "GET_NEXT_FREE_RECORDER[]:[]-1"
        self.send_cmd(self.sock, recorder_request_string)
        result = self.receive_reply(self.sock)
        result_list = result.rsplit("[]:[]")
        if not result_list[0] == -1:
            #Then everything worked fine
            self.recorder = result_list[0]
        else:
            print "Myth: No recorders available"
            
    def spawn_live(self):
        if self.recorder == None:
            print "Myth: Cannot spawn live tv, no recorder available"
        
        chainID = "live-" + self.localhost_name + "-2007-08-03T21:54:21"#+str(time.clock())
        spawn_string = "QUERY_RECORDER "+str(self.recorder)+"[]:[]SPAWN_LIVETV[]:[]"+chainID +"[]:[]0"
        self.send_cmd(self.sock, spawn_string)
        spawn_receive_string = "ok"
        result = self.receive_reply(self.sock)
        if not result == spawn_receive_string:
            print "Myth: failed to spawn live tv. Result: "+str(result)
        
        #Check the recording
        check_string = "QUERY_RECORDER "+str(self.recorder)+"[]:[]IS_RECORDING"
        self.send_cmd(self.sock, check_string)
        is_recording = self.receive_reply(self.sock)
        if not is_recording == str(1):
            #Just send the check again
            self.send_cmd(self.sock, check_string)
        
        #Create a new data socket
        #self.data_sock.connect( (self.server, self.server_port) )
        protString = "MYTH_PROTO_VERSION "+ str(self.protocolVersion)
        self.send_cmd(self.data_sock, protString)
        #self.send_datagram(self.data_sock, protString)
        protRecvString = "ACCEPT[]:[]" + str(self.protocolVersion)
        result = self.receive_reply(self.data_sock)
        #result = self.receive_datagram(self.data_sock)
        
        #This is just a hack to make sure the channel has locked, I'll fix it later
        time.sleep(5)
        #while not self.lock:
        #   pass
        
        #Get the recording filename
        filename_string = "QUERY_RECORDER "+str(self.recorder)+"[]:[]GET_CURRENT_RECORDING"
        self.send_cmd(self.sock, filename_string)
        filedetails = self.receive_reply(self.sock)
        detail_list = filedetails.rsplit("[]:[]")
        filename_list = detail_list[8].rsplit("/")
        filename_list.reverse()
        filename = "/" + filename_list[0]
        print filename
             
        #Announce our intent to read a file
        announce_cmd = "ANN FileTransfer " + self.localhost_name + "[]:[]" + filename
        self.send_cmd(self.data_sock, announce_cmd)
        result = self.receive_reply(self.data_sock)
        #result = self.receive_datagram(self.data_sock)
        result_list = result.rsplit("[]:[]")
        self.data_socket_id = result_list[1]
        #print "Socket ID: " + str(data_socket_id)
        
        #Do some housekeeping
        frontend_ready_cmd = "QUERY_RECORDER "+str(self.recorder) +"[]:[]FRONTEND_READY"
        self.send_cmd(self.sock, frontend_ready_cmd)
        result = self.receive_reply(self.sock)
        input_cmd = "QUERY_RECORDER "+ str(self.recorder) +"[]:[]GET_INPUT"
        self.send_cmd(self.sock, input_cmd)
        result = self.receive_reply(self.sock)
        rec_list_cmd = "MESSAGE[]:[]RECORDING_LIST_CHANGE"
        self.send_cmd(self.sock, rec_list_cmd)
        result = self.receive_reply(self.sock)  
        
        #Start a recording thread
        self.buffer_live(self.sock, self.data_sock, self.data_socket_id)
    
    def buffer_live(self, cmd_sock, data_sock, socket_id):
        #Create a buffer file
        buffer_file_name = "test.mpg"
        self.buffer_file = open(buffer_file_name,"w")
        request_size = 32768
        #max_request_size = 135000
        max_request_size = 270000
        request_size_step = 16384
        
        #Need to create a bit of a buffer so playback will begin
        """
        x=0
        while x<80:
            transfer_cmd = "QUERY_FILETRANSFER "+ str(socket_id) + "[]:[]REQUEST_BLOCK[]:[]"+str(request_size)
            self.send_cmd(cmd_sock, transfer_cmd)
            num_bytes = int(self.receive_reply(cmd_sock))
            data = data_sock.recv(num_bytes)
            self.buffer_file.write(data)
            x=x+1
        self.buffer_file.flush()
        """
        
        #self.videoPlayer.begin_playback(buffer_file_name)
        reader_fd = os.dup(data_sock.fileno())
        self.videoPlayer.begin_playback(reader_fd)
        
        print "BEGINNING PLAYBACK!"
        self.Playing = True
        while self.Playing:
            transfer_cmd = "QUERY_FILETRANSFER "+ str(socket_id) + "[]:[]REQUEST_BLOCK[]:[]"+str(request_size)
            self.send_cmd(cmd_sock, transfer_cmd)
            num_bytes = int(self.receive_reply(cmd_sock))
            data_sock.recv(num_bytes)
            #self.buffer_file.write(data)
            #self.buffer_file.flush()
            
            #This tries to optimise the request size
            #print "Received: " + str(num_bytes)
            if (num_bytes == request_size) and (request_size < max_request_size):
                request_size = request_size + request_size_step
                if request_size > max_request_size:
                    request_size = max_request_size
            elif (request_size > request_size_step) and (num_bytes != request_size):
                request_size = request_size - request_size_step
                
        
        print "Ending playback"
        #self.buffer_file.close()
        
    def message_socket_mgr(self, msg_socket):
        #Do the protocol version check
        print "Starting the msg thread"
        protString = "MYTH_PROTO_VERSION "+ str(self.protocolVersion)
        self.send_cmd(self.msg_sock, protString)
        protRecvString = "ACCEPT[]:[]" + str(self.protocolVersion)
        result = self.receive_reply(self.msg_sock)
        print result
        if not result == protRecvString:
            #Protocol Version check failed
            raise RuntimeError, "Myth Protocol version failure. Aborting."
        
        #Perform the mandatory ANN (The 1 at the end says that we want to receive all messages from the server)
        ANNstring = "ANN Monitor " + self.localhost_name + " 1"
        self.send_cmd(self.msg_sock, ANNstring)
        ANN_recv_string = "OK" #What a successful return should be
        result = self.receive_reply(self.msg_sock)
        if not result == ANN_recv_string:
            raise RuntimeError, "Myth: ANN connection failed"
       
        while not self.lock:
            #ANN_recv_string = "OK" #What a successful return should be
            result = self.receive_reply(self.msg_sock)
            result_list = result.rsplit("[]:[]")
            print result
            
            if result_list[1] == "RECORDING_LIST_CHANGE":
                #print resul
                self.lock = True
        
    def change_channel(self):
        if self.Playing:
            pass #self.Playing = False

    def end_stream(self):
        self.stream = False
        
    def stop(self):
        self.Playing = False
        
        stop_cmd = "QUERY_RECORDER "+str(self.recorder) +"[]:[]STOP_LIVETV"
        self.send_cmd(self.sock, stop_cmd)
        result = self.receive_reply(self.sock)
        
        end_transfer_cmd = "QUERY_FILETRANSFER "+str(self.data_socket_id) +"[]:[]DONE"
        self.send_cmd(self.sock, end_transfer_cmd)
        #Shouldn't need to monitor for a reply here, we're done.
        #result = self.receive_reply(self.sock)