#MyTheatre Python client for XBMC
#Version 2.0 by marplar 11-Dec-2004

############################################################
#Set IP address of PC running MyTheatre
ServIP = '192.168.2.3'
#
#Set port for avbroadcaster http
AVBServPort = 8000
#
#Set port for python EPG server
EPGServPort = 8001
#
#Set delay for channel change in seconds (default = 4, max = 18)
ChangeDelay=4
############################################################

import urllib, time, xbmc, xbmcgui, xml.parsers.expat, string, thread
from socket import *
from HTMLParser import HTMLParser
try: Emulating = xbmcgui.Emulating
except: Emulating = False

#get actioncodes from keymap.xml
ACTION_PREVIOUS_MENU = 10
ACTION_SELECT_ITEM = 7
ACTION_SHOW_FILE_INFO = 11
ACTION_POPUP_CONTEXT=117

#Reads AVBroadcaster web page and creates list of favorite groups or channels
class MyParser(HTMLParser):

    #Read tag
    def handle_starttag(self, tag, attrs):
        #Create dictionary of tag attributes
        attrdict=dict(attrs)
        if tag == 'html':
            #Initialse list
            self.parselist = []
            self.chtype = ''
        elif tag == 'a':
            #Hyperlink tag - get link
            self.href=attrdict['href']
        elif tag == 'td' and len(attrdict) == 2 and self.tag == 'tr':
            #Table tag - check colour to determine if encrypted
            if attrdict['bgcolor'] == '#00BF00':
                self.encrypt = ' '
            else:
                self.encrypt = '!'
        #Store tag type
        self.tag=tag

    #Read data (outside tag)   
    def handle_data(self,data):
        if self.tag == 'title':
            #Add title to list
            self.parselist.append(['Title', data])
            #Store title to determine if page is favorite group list or channels
            self.title = data
        elif self.tag == 'center':
            #Get channel type (V/R) and add to encrypted flag (!/ )
            self.chtype=data + self.encrypt + ' '
        elif self.tag == 'a':
            #Hyperlink data 
            if self.href[:16] == '/list.htm?favid=':
                #Link is for favorite lists
                if data[:9] == 'Next page' and len(self.parselist) > 10:
                    #Add next page link to list
                    self.parselist.append(['NextPage', data, self.href])
                elif self.title == 'Favorite groups list':
                    # Add favorite group name and link to list
                    self.parselist.append(['FavList', data, self.href])
            elif self.href[:17] == '/set_ch.htm?chid=':
                #Link is for channel
                self.parselist.append(['Channel', self.chtype + data,self.href])

    def close(self):
        #Return list to caller
        return self.parselist
        self.close()

#Reads mytheatre EPG data
class ListingsXMLParser:
    def getPrograms(self, chid):
		#set up parser
        p = xml.parsers.expat.ParserCreate('UTF-8')
        p.StartElementHandler = self.start_element
        p.EndElementHandler = self.end_element
        p.CharacterDataHandler = self.char_data
		#get EPG data
        sockobj = socket(AF_INET, SOCK_STREAM)
        try:
            sockobj.connect((ServIP, EPGServPort))
            sockobj.send('/?chid=' + chid)
            data = sockobj.recv(200000)
            sockobj.close()
            p.Parse(data)
        except:
            self.parselist = []
            self.parselist.append(['','','','','Error connecting to EPG Server', '',''])
        return self.parselist
    def start_element(self, name, attrs):
        if name == 'XML':
            #Initialse list
            self.parselist = []
        elif name == 'Program':
            #New Program
            self.Language=''
            self.StartDate=''
            self.StartTime=''
            self.EndTime=''
            self.EventName=''
            self.ShortDescr=''
            self.ExtDescr=''
        #Store Name
        self.name=name
            
    def end_element(self, name):
        if name =='Program':
            #Add data to list if not in past
            if float(self.EndTime)>time.time():
                self.StartDate=time.strftime('%d %b',time.localtime(float(self.StartTime)))
                self.StartTime=time.strftime('%H:%M',time.localtime(float(self.StartTime)))
                self.EndTime=time.strftime('%H:%M',time.localtime(float(self.EndTime)))
                self.parselist.append([self.Language,self.StartDate,self.StartTime,self.EndTime,self.EventName,self.ShortDescr,self.ExtDescr])                     
                
        #Clear Name
        self.name = ''
        
    def char_data(self, data):
        #Store attributes
        if self.name == 'Language':
            self.Language=data
        elif self.name == 'StartTime':
            self.StartTime=data
        elif self.name == 'EndTime':
            self.EndTime=data
        elif self.name == 'EventName':
            self.EventName=data
        elif self.name == 'ShortDescr':
            self.ShortDescr=data
        elif self.name == 'ExtDescr':
            self.ExtDescr=data
        

class MyClass(xbmcgui.Window):
    def __init__(self):
        if Emulating: xbmcgui.Window.__init__(self)
        #Set default mode
        self.TVRadioMode = 'TV Only'
        self.EncryptMode = 'All Channels'
        #Set up screen
        self.addControl(xbmcgui.ControlImage(0,0,800,600, 'background.png'))
        self.addControl(xbmcgui.ControlLabel(50, 60, 10, 80, 'my', 'font14', '0xFFFF2000'))
        self.addControl(xbmcgui.ControlLabel(75, 60, 100, 80, 'Theatre', 'font14', '0xFF000000'))
        self.butTVRadio = xbmcgui.ControlButton(300, 60, 120, 35, self.TVRadioMode, 'button-focus.png', 'button-nofocus.png')
        self.addControl(self.butTVRadio)
        self.butEncrypt = xbmcgui.ControlButton(500, 60, 120, 35, self.EncryptMode, 'button-focus.png', 'button-nofocus.png')
        self.addControl(self.butEncrypt)
        self.strTitle = xbmcgui.ControlLabel(50, 120, 200, 200, '', 'font14', '0xFFA5FF00')
        self.addControl(self.strTitle)
        self.list = xbmcgui.ControlList(50, 150, 250, 370)
        self.addControl(self.list)
        self.strEPGTitle = xbmcgui.ControlLabel(350, 190, 200, 200, 'Program Guide', 'font14', '0xFFA5FF00')
        self.addControl(self.strEPGTitle)
        self.txtProgDesc = xbmcgui.ControlLabel(350, 220, 350, 350,'','font13','0xFFA5FF00')
        self.addControl(self.txtProgDesc)
        self.txtProgDesc.setVisible(False)
        self.epglistVisible=True
        self.epglist = xbmcgui.ControlList(350, 220, 320, 300)
        self.addControl(self.epglist)
        

        #Set Navigation
        self.list.controlLeft(self.butTVRadio)
        self.epglist.controlLeft(self.list)
        self.epglist.controlRight(self.butEncrypt)
        self.butEncrypt.controlLeft(self.butTVRadio)
        self.butEncrypt.controlDown(self.list)
        self.butTVRadio.controlDown(self.list)
        self.butTVRadio.controlRight(self.butEncrypt)
       
        #Initialise Parsers
        self.MyParser=MyParser()
        self.EPGParser=ListingsXMLParser()
        
        #Get favorites group list
        self.file = '/list.htm'
        self.ParseList(URL)
        self.setFocus(self.list)

    #Read html page 
    def GetList(self,URL,file):
        opener = urllib.FancyURLopener({})
        try:
            doc = opener.open(URL + file)
            webpage = doc.read()  # read file
            doc.close()
            self.MyParser.feed(webpage)
            listings=self.MyParser.close()
            return listings                      
        except:
            self.message('Unable to retrieve channel list')
            return 'NoList'

    #Check if stream is being received
    def TestChannel(self, URL):
        opener = urllib.FancyURLopener({})
        try:
            doc = opener.open(URL + '/dvbcore.mpg')
            datacount = len(doc.readline())
            doc.close
            if datacount > 0:
                return 'OK'
            else:
                return ' '
        except:
            return ' '
                   
    #Display Listing
    def ParseList(self,URL):
        #Get listings
        self.listings =self.GetList(URL,self.file)

        #Check listing was retreived
        if self.listings == 'NoList':
            return

        self.list.reset()
        
        #Check if list is complete
        while self.listings[len(self.listings)-1][0] == 'NextPage':
            nextpage = self.GetList(URL, self.listings[len(self.listings)-1][2])
            self.listings.pop(len(self.listings)-1)   #Remove NextPage from original list
            nextpage.pop(0)         #Remove Title from extended list
            self.listings.extend(nextpage)   #Join original and extended lists

        #Filter Channels to show TV/Radio and FTA/Encryted
        count = 0
        while count < len(self.listings):
            if self.listings[count][0] == 'Channel':
                if self.ParseCheckMode(self.listings[count][1]) == 0:
                    self.listings.pop(count)
                else:
                    count = count + 1
            else:
                count = count + 1

        #Populate list
        for listing in self.listings:
            if listing[0] == 'Title':
                if listing[1] == 'Favorite groups list':
                    self.strTitle.setLabel(listing[1])
            else:
                self.list.addItem(listing[1])
        
       

    #Check Channel to show TV/Radio and FTA/Encryted
    def ParseCheckMode(self, listing):
        if self.TVRadioMode == 'TV Only' and listing[0:1] <> 'V':
            return 0
        elif self.TVRadioMode == 'Radio Only' and listing[0:1] <> 'R':
            return 0
        elif self.EncryptMode == 'FTA Only' and listing[1:2] =='!':
            return 0
        elif self.TVRadioMode == 'TV and Radio':
            if listing[0:1] <> 'V' and listing[0:1] <> 'R':
                return 0
            else:
                return 1

    #Display EPG Info
    def DisplayEPG(self,chid):
        #Populate New Listings
        self.epglistings=self.EPGParser.getPrograms(chid)
        for listing in self.epglistings:
            self.epglist.addItem(listing[2] + ' ' + listing[4])

    #Split EPG Description lines        
    def linesplit(self,text,width):
  
        lines = []
        while len(text) > width:
            cutoff1 = string.rfind(text[:width]," ")
            cutoff2 = string.find(text[:width],"\n")
            if cutoff2 > cutoff1:
                cutoff = cutoff2
            elif cutoff1 < width*4/5:
                cutoff = width
            else:
                cutoff = cutoff1
            lines.append(text[:cutoff])
            text = " " + string.lstrip(text[cutoff:])
            if width < 3: text = string.lstrip(text)
            
        lines.append(text)
        return lines

        
    #Handle user input               
    def onControl(self, control):
        if control == self.list:
            #User selected group/channel list
            try:
                listingspos = self.list.getSelectedPosition()+1
                if self.listings[listingspos][0] == 'Channel':
                    #User selected channel change
                    dialog = xbmcgui.DialogProgress()
                    dialog.create('MyTheatre', 'Tuning to ' +  self.listings[listingspos][1][3:])
                    self.GetList(URL, self.listings[listingspos][2])
                    searchpos = 0
                    #Wait for change delay
                    while searchpos <= ChangeDelay * 5 and dialog.iscanceled() == 0:
                        searchpos = searchpos + 5
                        dialog.update(searchpos)
                        time.sleep(1)
                        
                    #Wait for stream to be detected
                    while searchpos <= 95 and dialog.iscanceled() == 0 and self.TestChannel(URL) != 'OK':
                        searchpos = searchpos + 5
                        dialog.update(searchpos)
                        time.sleep(1)
                    
                    if searchpos < 100 and dialog.iscanceled() == 0:
                        #Play stream
                        dialog.close()
                        xbmc.Player().play(URL + '/dvbcore.mpg')
                    elif dialog.iscanceled() == 0:
                        #Time out
                        dialog.close()
                        self.message('Channel not decryptable or not broadcasting')
                    else:
                        #User cancelled
                        dialog.close()
                else:
                    #User selected group list
                    self.file = self.listings[self.list.getSelectedPosition()+1][2]
                    self.strTitle.setLabel(self.listings[self.list.getSelectedPosition()+1][1])
                    self.ParseList(URL)
            except:
                self.message('Error tuning Channel.')
                
        if control == self.epglist:
            if self.epglistVisible == True:
                #Display extended EPG Info
                listingspos = self.epglist.getSelectedPosition()
                if len(self.epglistings) > 0:
                    self.strEPGTitle.setLabel(self.epglistings[listingspos][4])
                    epgdata = 'Start: ' + self.epglistings[listingspos][1]
                    epgdata = epgdata + ' ' + self.epglistings[listingspos][2]
                    epgdata = epgdata + ' End: ' + self.epglistings[listingspos][3] + '\n'
                    epgdata = epgdata + 'Description: \n'
                    epgdesclist=self.linesplit(self.epglistings[listingspos][5] + '\n' + self.epglistings[listingspos][6], 40)
                    for epgdesc in epgdesclist:
                        epgdata = epgdata + epgdesc + '\n'
                    epgdata = epgdata + 'Language : ' + self.epglistings[listingspos][0]
                    
                    self.epglist.setVisible(False)
                    self.epglistVisible = False
                    self.txtProgDesc.setVisible(True)
                    self.txtProgDesc.setLabel(epgdata)
            else:
                    #Return to list
                    self.setFocus(self.list)
                    self.txtProgDesc.setVisible(False)
                    self.epglist.setVisible(True)
                    self.epglistVisible = True
                    self.setFocus(self.epglist)
                    listingspos = self.list.getSelectedPosition()+1
                    self.strEPGTitle.setLabel(self.listings[listingspos][1][3:])
            
        elif control == self.butTVRadio:
            #User selected TV/Radio mode button - toggle button and display list
            if self.TVRadioMode == 'TV and Radio':
                self.TVRadioMode = 'TV Only'
            elif self.TVRadioMode == 'TV Only':
                self.TVRadioMode = 'Radio Only'
            else:
                self.TVRadioMode = 'TV and Radio'

            self.butTVRadio.setLabel(self.TVRadioMode)
            self.ParseList(URL)
            
        elif control == self.butEncrypt:
            #User selected Encrypt mode button - toggle button and display list
            if self.EncryptMode == 'All Channels':
                self.EncryptMode = 'FTA Only'
            else:
                self.EncryptMode = 'All Channels'

            self.butEncrypt.setLabel(self.EncryptMode)
            self.ParseList(URL)

    def onAction(self, action):

        if action == ACTION_PREVIOUS_MENU:
        #User selected back - show favourite groups or exit
            if self.listings[1][0] == 'Channel':
                self.file = '/list.htm'
                self.ParseList(URL)
                self.setFocus(self.list)
            else:
                self.close()

        if action == ACTION_SHOW_FILE_INFO or action == ACTION_POPUP_CONTEXT:
        #Display EPG
            if self.epglistVisible == False:
                self.txtProgDesc.setVisible(False)
                self.epglist.setVisible(True)
                self.epglistVisible = True
            if self.listings[1][0] == 'Channel':
                listingspos = self.list.getSelectedPosition()+1
                #Clear List
                self.epglist.reset()
                #Get Listings
                self.DisplayEPG(self.listings[listingspos][2][17:])
                self.strEPGTitle.setLabel(self.listings[listingspos][1][3:])
                if len(self.epglistings) > 0:
                    self.setFocus(self.epglist)
                else:
                    self.epglist.addItem('No Program Guide')
                    self.setFocus(self.list)
            
    #Display message
    def message(self, message):
            dialog = xbmcgui.Dialog()
            dialog.ok(" MyTheatre", message)

###############
#Main     
###############

URL='http://' + ServIP + ':' + str(AVBServPort)
mydisplay = MyClass()
mydisplay.doModal()
del mydisplay