from enigma import eServiceReference, eServiceCenter, iServiceInformation, eTimer, iRecordableService, eDVBServicePMTHandler
from Plugins.Plugin import PluginDescriptor
from Screens.ChannelSelection import BouquetSelector, ChannelSelection
from Screens.MessageBox import MessageBox
from Components.config import config, ConfigSubsection, ConfigIP, ConfigInteger, ConfigText, getConfigListEntry, ConfigSelection, ConfigOnOff, NoSave
from Components.ConfigList import ConfigListScreen
from Components.ActionMap import ActionMap
from Screens.Screen import Screen
from Components.Sources.StaticText import StaticText
from Components.Label import Label

import json
from collections import OrderedDict
from Tools.Directories import pathExists, resolveFilename, SCOPE_CONFIG

try:
	from Plugins.Extensions.WebInterface.WebScreens import streamingScreens, streamingEvents
except:
	streamingScreens = []
	streamingEvents = []

from datetime import datetime
def writelog(text=''):
	print text
	with open('/tmp/streamrelay.log', "a") as fp:
		fp.write('{0} {1}\n'.format(datetime.today().strftime("%d.%m.%Y %H:%M:%S"),text))

def writeerror():
	from traceback import print_exc
	with open('/tmp/streamrelayerror.log', "a") as fp:
		print_exc(file=fp)

icamref = OrderedDict()
icamrefchanged = False
streamrelayconf = {}
streamrelayconf['icamref'] = False
streamrelayconf['referencefix'] = False
streamrelayconf['streamhost'] = '127.0.0.1'
streamrelayconf['streamport'] = 17999
streamrelayconf['nameadd'] = ''
streamrelayconf['noresources'] = False
streamrelayconf['recordstate'] = False

icamident = {}#{'compare':'','value':''}
icamident['compare'] = ''
icamident['servicestr'] = ''

mainstreamptr = []

ICAMREFDIR = resolveFilename(SCOPE_CONFIG, "icamref.json")
ICAMIDENTDIR = resolveFilename(SCOPE_CONFIG, "icamident.json")
STREAMRELAYCONFDIR = resolveFilename(SCOPE_CONFIG, "streamrelayconf.json")

def writestreamrelayconf():
	if streamrelayconf:
		tmp = {}
		if streamrelayconf['icamref'] != False:
			tmp['icamref'] = streamrelayconf['icamref']
		if streamrelayconf['noresources'] != False:
			tmp['noresources'] = streamrelayconf['noresources']
		if streamrelayconf['referencefix'] != False:
			tmp['referencefix'] = streamrelayconf['referencefix']
		if streamrelayconf['recordstate'] != False:
			tmp['recordstate'] = streamrelayconf['recordstate']
		if streamrelayconf['streamhost'] != '127.0.0.1':
			tmp['streamhost'] = streamrelayconf['streamhost']
		if streamrelayconf['streamport'] != 17999:
			tmp['streamport'] = streamrelayconf['streamport']
		if streamrelayconf['nameadd'] != '':
			tmp['nameadd'] = streamrelayconf['nameadd']
		
		with open(STREAMRELAYCONFDIR, 'w') as fp:
			json.dump(OrderedDict(sorted(tmp.items(), key=lambda x: x[1])), fp, encoding='utf-8', indent=2, sort_keys=False, ensure_ascii=True)

def readstreamrelayconf():
	if pathExists(STREAMRELAYCONFDIR):
		with open(STREAMRELAYCONFDIR) as data_file:
			data = json.load(data_file, encoding='utf-8', object_pairs_hook=OrderedDict)
			if data.get('icamref'):
				streamrelayconf['icamref'] = data['icamref']
			if data.get('noresources'):
				streamrelayconf['noresources'] = data['noresources']
			if data.get('referencefix'):
				streamrelayconf['referencefix'] = data['referencefix']
			if data.get('recordstate'):
				streamrelayconf['recordstate'] = data['recordstate']
			if data.get('streamhost'):
				streamrelayconf['streamhost'] = data['streamhost'].encode('utf-8')
			if data.get('streamport'):
				streamrelayconf['streamport'] = data['streamport']
			if 'nameadd' in data:
				streamrelayconf['nameadd'] = data['nameadd'].encode('utf-8')

def __writeicamref__():
	if icamref and icamrefchanged:
		with open(ICAMREFDIR, 'w') as fp:
			json.dump(OrderedDict(sorted(icamref.items(), key=lambda x: x[1])), fp, encoding='utf-8', indent=2, sort_keys=False, ensure_ascii=True)
	
	try:
		from os import remove as os_remove
		if icamident and icamident['compare']:
			service = None
			from Screens.InfoBar import InfoBar
			if InfoBar.instance:
				service = InfoBar.instance.session.nav.getCurrentlyPlayingServiceReference()
			if service and service.toCompareString() == icamident['compare']:
				with open(ICAMIDENTDIR, 'w') as fp:
					json.dump(OrderedDict(sorted(icamident.items(), key=lambda x: x[1])), fp, encoding='utf-8', indent=2, sort_keys=False, ensure_ascii=True)
			elif pathExists(ICAMIDENTDIR):
				os_remove(ICAMIDENTDIR)
		elif pathExists(ICAMIDENTDIR):
			os_remove(ICAMIDENTDIR)
	except:
		writeerror()
		
def readicamref():
	if pathExists(ICAMREFDIR):
		with open(ICAMREFDIR) as data_file:
			data = json.load(data_file, encoding='utf-8', object_pairs_hook=OrderedDict)
			for key, value in data.items():
				icamref[key] = value
	if pathExists(ICAMIDENTDIR):
		with open(ICAMIDENTDIR) as data_file:
			data = json.load(data_file, encoding='utf-8', object_pairs_hook=OrderedDict)
			if data.get('compare'):
				icamident['compare'] = data['compare'].encode('utf-8')
			if data.get('servicestr'):
				icamident['servicestr'] = data['servicestr'].encode('utf-8')
		from os import remove as os_remove
		os_remove(ICAMIDENTDIR)
		
#ptrdict = dict()
#ptrlist = []
def checkstreaming_ok(stoprecord = False, toremove = False):
	ptrlist = []
	try:
		if streamingScreens:
			for streaming in streamingScreens:
				if streaming.has_key("StreamService"):
					service = streaming["StreamService"].getService()
					if service:
						ptr = service.getPtrString()
						if ptr not in ptrlist:
							#ptrlist.insert(0, ptr)
							ptrlist.append(ptr)
						if stoprecord:
							streaming["StreamService"].navcore.stopRecordService(service)
							streamingScreens.remove(streaming)
				else:
					if toremove:
						streamingScreens.remove(streaming)
	except:
		pass
	return ptrlist[:]

def checkstreaming(stoprecord = False, toremove = False):
	ptrlist = []
	try:
		if streamingScreens:
			for streaming in streamingScreens:
				stream = streaming.get("StreamService")
				if stream:
					service = stream.getService()
					if service:
						ptr = service.getPtrString()
						if ptr not in ptrlist:
							ptrlist.append(ptr)
						if stoprecord:
							if stream.recordEvent in stream.navcore.record_event:
								stream.navcore.record_event.remove(stream.recordEvent)
							if stream._StreamService__service is not None:
								stream.navcore.stopRecordService(stream._StreamService__service)
								stream._StreamService__service = None
							if streaming in streamingScreens:
								streamingScreens.remove(streaming)
				else:
					if toremove:
						streamingScreens.remove(streaming)
	except:
		writeerror()
	return ptrlist[:]
	
def MycheckRecordings(session):
	try:
		recslen = 0
		recslist = session.nav.getRecordings()
		if recslist:
			for recs in recslist:
				if recs.getPtrString() not in mainstreamptr:
					recslen += 1
		return recslen
	except:
		writeerror()
	return len(session.nav.getRecordings())
	
class repeatzap(Screen):
	skin = """<screen backgroundColor="transparent" name="repeatzap" position="center,center" size="600,500" title="repeatzap" flags="wfNoBorder">
		<eLabel backgroundColor="background" cornerRadius="30" position="0,0" size="600,500" zPosition="-1"/>
		<widget backgroundColor="background" font="Regular;30" name="text" position="50,50" size="500,400" transparent="1" />
	</screen>
	"""
	def __init__(self, session):
		self.skinName = 'repeatzap'
		Screen.__init__(self, session)
		
		self.lastservice = self.session.nav.getCurrentlyPlayingServiceReference()
		self.lastservicestr = self.lastservice.toString()
		self.lastservicestr = self.lastservicestr[:self.lastservicestr.find('http')]
		
		from ServiceReference import ServiceReference
		serviceref = ServiceReference(self.lastservice)
		self.servicerefname = serviceref.getServiceName()
		self.session.nav.stopService()

		text = '{0}\n{1}\n{2}\n{3} {4}'.format(_("stop service"), self.servicerefname, self.lastservicestr, 'streamingScreens len', len(streamingScreens))
		if mainstreamptr:
			text += '\nstreamptr {0}'.format(', '.join(mainstreamptr))
		self["text"] = Label(text)

		self.timer = eTimer()
		self.timer_conn = self.timer.timeout.connect(self.rezapstop)
		self.timer.start(250,True)
		self.timerstate = 0
	
	def rezapstop(self):
		if self.timerstate == 0:
			ptrlistval = checkstreaming()
			#del mainstreamptr[:]
			#del streamingScreens[:]
			#writelog('mainstreamptr {0} '.format(mainstreamptr))
			self["text"].text += '\n{0} {1} {2}'.format(_('Cleanup'), len(ptrlistval), _('Services'))
			service = self.lastservice
			if service and service.getUnsignedData(4) == 33:
				path = service.getPath()
				if path:
					service = eServiceReference('1:0:19:2888:40F:1:C00000:0:0:0:')
					service.setName('{0}'.format('Repeatzap'))
					self.session.nav.playService(service, forceRestart = True)
			self.timerstate += 1
			self.timer.start(500,True)
		elif self.timerstate == 1:
			from Screens.InfoBar import InfoBar
			historylen = len(InfoBar.instance.servicelist.history)
			## mainstreamptr
			del InfoBar.instance.servicelist.history[:]
			InfoBar.instance.servicelist.history_pos = 0
			self["text"].text += '\n{0} {1} {2} {3}'.format(_('Removing'), _('History'), _('Entries'), historylen)
			self.timerstate += 1
			self.timer.start(250,True)
		elif self.timerstate == 2:
			self["text"].text += '\n{0}\n{1}\n{2}'.format(_('Play last movie starting'), self.servicerefname, self.lastservicestr)
			from Screens.InfoBar import InfoBar
			InfoBar.instance.servicelist.zap(self.lastservice)
			self.timerstate += 1
			self.timer.start(250,True)
		else:
			self.timer.stop()
			self.timer_conn = None
			self.close()

'''
class StreamRelayInfo(Screen):
	stream_running = False
	toggleshow = None
	skin___ = """<screen backgroundColor="transparent" name="StreamRelayInfo" position="1600,845" size="200,40" title="StreamRelayInfo" flags="wfNoBorder">
		<eLabel backgroundColor="background" cornerRadius="30" position="0,0" size="200,40" zPosition="-1"/>
		<eLabel backgroundColor="background" font="Regular;24" position="0,0" size="200,40" text="Streaming" valign="center" halign="center" transparent="1"/>
	</screen>
	"""
	skin = """<screen backgroundColor="transparent" name="StreamRelayInfo" position="1540,830" size="140,50" flags="wfNoBorder">
		<eLabel backgroundColor="background" cornerRadius="30" position="0,0" size="140,50" zPosition="-1"/>
		<ePixmap pixmap="/usr/lib/enigma2/python/Plugins/Extensions/StreamRelay/streamingwhite.png" position="20,5" size="100,40" scale="stretch" />
	</screen>
	"""
	
	def __init__(self, session):
		self.skinName = 'StreamRelayInfo'
		Screen.__init__(self, session)
		StreamRelayInfo.toggleshow = self.toggleShow
		
	def toggleShow(self):
		from Screens.InfoBar import InfoBar
		if self.stream_running and InfoBar.instance._InfoBarShowHide__state == InfoBar.instance.STATE_SHOWN:
			self.show()
		else:
			self.hide()
'''

class StreamRelaySetup(Screen, ConfigListScreen):
	skin = """
		<screen name="StreamRelaySetup" position="center,170" size="1200,820" title="Setup">
		<layout name="Button_Small"/>
		<layout name="Button_Small_source"/>
		<widget enableWrapAround="1" name="config" position="10,90" scrollbarMode="showOnDemand" size="1180,720"/>
		</screen>"""
	
	def __init__(self, session):
		
		Screen.__init__(self, session)
		self.skinName = "StreamRelaySetup"
		ConfigListScreen.__init__(self, [], session=session)

		self["key_red"] = StaticText(_("Cancel"))
		self["key_green"] = StaticText(_("Save"))
		self["key_blue"] = StaticText(_("Reset"))
		self["key_yellow"] = StaticText(_("Repeatzap"))
		
		self["actions"] = ActionMap(["SetupActions", "ColorActions", "InfobarActions", "ChannelSelectEPGActions"],
			{
				"cancel": self.keyCancel,
				"red": self.keyCancel,
				"blue": self.keyblue,
				"yellow": self.keyyellow,
				"save": self.keySave,
				"showMovies": self.keykey_1,
				"showTv": self.keykey_2,
				"showRadio": self.keykey_3,
				"showEPGList": self.StreamrelayInfo,
			})
			
		self.settings = ConfigSubsection()
		self.settings.icamref = NoSave(ConfigOnOff(default = streamrelayconf['icamref']))
		self.settings.noresources = NoSave(ConfigOnOff(default = streamrelayconf['noresources']))
		self.settings.referencefix = NoSave(ConfigOnOff(default = streamrelayconf['referencefix']))
		self.settings.recordstate = NoSave(ConfigOnOff(default = streamrelayconf['recordstate']))
		#self.settings.streamhost = NoSave(ConfigIP(default = streamrelayconf['streamhost'].split('.'), auto_jump=True))
		self.settings.streamhost = NoSave(ConfigText(default = streamrelayconf['streamhost'], fixed_size=False))
		self.settings.streamport = NoSave(NoSave(ConfigInteger(default=streamrelayconf['streamport'], limits=(1, 65555))))
		self.settings.nameadd = NoSave(ConfigText(default = streamrelayconf['nameadd'], fixed_size=False))
		
		self.changeicamref = streamrelayconf['icamref']
		self.changenoresources = streamrelayconf['noresources']
		self.changerecordstate = streamrelayconf['recordstate']
		self.onLayoutFinish.append(self.firststart)
		
		self._createSetup()
	
	def KeyText(self):
		curr = self["config"].getCurrent()
		if curr and isinstance(curr[1], ConfigText):
			ConfigListScreen.KeyText(self)
			
	def keyLeft(self):
		ConfigListScreen.keyLeft(self)
		curr = self["config"].getCurrent()
		if curr and curr[1] == self.settings.referencefix:
			self._createSetup()
	
	def keyRight(self):
		ConfigListScreen.keyRight(self)
		curr = self["config"].getCurrent()
		if curr and curr[1] == self.settings.referencefix:
			self._createSetup()
		
	def firststart(self):
		self.setTitle("Stream Relay " + _("Setup"))
		
	def _createSetup(self):
		entries = []
		entries.append(getConfigListEntry('Stream Host ' + _('Default') + ' (127.0.0.1)', self.settings.streamhost))
		entries.append(getConfigListEntry('Stream Port ' + _('Default') + ' (17999)', self.settings.streamport))
		entries.append(getConfigListEntry('Name ' + _('advanced'), self.settings.nameadd))
		entries.append(getConfigListEntry(_('No free tuner!') + ' ' + ' / ' + _('Channel Selection') + ' ' + _('Color') + ' ' + _("disable"), self.settings.noresources))
		entries.append(getConfigListEntry(_('Record') + ' ' + _('blinking') + ' ' + _("disable"), self.settings.recordstate))
		#entries.append(getConfigListEntry('Auto Convert icamref / ' + _('Namespace') + ' (ID=33 / 0x21)', self.settings.icamref))
		entries.append(getConfigListEntry('Auto Convert icamref' + ' ' + _('enable'), self.settings.icamref))
		if self.settings.referencefix.value:
			#entries.append(getConfigListEntry(_('Service') + ' ' + _('Type') + '=1 ' + _('Transponder') + ' (ID=11 / 0xB) ' + _('Network') + ' (ID=22 / 0x16)', self.settings.referencefix))
			entries.append(getConfigListEntry(_('Service reference') + ' 1:0:1:xxxx:B:16:21:0:0:0:' , self.settings.referencefix))
		else:
			entries.append(getConfigListEntry(_('Service reference') + ' 1:0:x:xxxx:x:xx:21:0:0:0:' , self.settings.referencefix))
		self["config"].list = entries
		
	def keySave(self):
		if self["config"].isChanged():
			streamrelayconf['icamref'] = self.settings.icamref.value
			streamrelayconf['noresources'] = self.settings.noresources.value
			streamrelayconf['recordstate'] = self.settings.recordstate.value
			streamrelayconf['streamhost'] = self.settings.streamhost.getText()
			streamrelayconf['streamport'] = self.settings.streamport.value
			streamrelayconf['nameadd'] = self.settings.nameadd.getText()
			#if self.settings.icamref.value:
			streamrelayconf['referencefix'] = self.settings.referencefix.value
			#else:
			#	streamrelayconf['referencefix'] = False
			
			writestreamrelayconf()
			if (self.changeicamref != streamrelayconf['icamref']) or (self.changenoresources != streamrelayconf['noresources']) or (self.changerecordstate != streamrelayconf['recordstate']):
				restartbox = self.session.openWithCallback(self.restartGUI, MessageBox,_("GUI needs a restart to apply the new settings.\nDo you want to Restart the GUI now?"), MessageBox.TYPE_YESNO)
				restartbox.setTitle(_("Restart GUI now?"))
			else:
				self.close(True)
		else:
			self.close(False)
	
	def keyblue(self):
		self.settings.streamhost.value = '127.0.0.1'
		self.settings.streamport.value = 17999
		self.settings.noresources.value = False
		self.settings.recordstate.value = False
		self.settings.icamref.value = False
		self.settings.nameadd.value = ''
		self._createSetup()
	
	def keyyellow(self):
		curr = self["config"].getCurrent()
		if curr and getattr(curr[1], 'help_window', None):
			helpwin = self._getHelpWindow()
			if helpwin:
				helpwin.hide()
		self.session.open(repeatzap)
		self.close(True)
		
	def keykey_1(self):
		self.settings.streamhost.value = '127.0.0.1'
		self._createSetup()
		
	def keykey_2(self):
		self.settings.streamhost.value = '192.168.2.124'
		self._createSetup()
		
	def keykey_3(self):
		self.settings.streamhost.value = '192.168.2.129'
		self._createSetup()
		
	def restartGUI(self, answer):
		if answer:
			from Screens.Standby import TryQuitMainloop
			self.session.open(TryQuitMainloop, 3)
			#from twisted.internet import reactor
			#reactor.callLater(1, self.session.open, TryQuitMainloop, 3)
		self.close(True)

	def StreamrelayInfo(self):
		service = self.session.nav.getCurrentlyPlayingServiceReference()
		info = eServiceCenter.getInstance().info(service)
		name = info.getName(service).replace('\xc2\x86', '').replace('\xc2\x87', '')
		#sserviceref = info and info.getInfoString(service, iServiceInformation.sServiceref)
	
		text = '{0}\n{1}\n'.format(name, service.toString().replace('%3a',':'))
		#if mainstreamptr:
		text += 'mainstreamptr len ({0}) ptr {1}\n'.format(len(mainstreamptr),', '.join(mainstreamptr))
		ptrlistval = checkstreaming()
		text += 'checkstreaming len ({0}) ptr {1}\n'.format(len(ptrlistval), ', '.join(ptrlistval))
		text += 'streamingScreens len ({0})\n'.format(len(streamingScreens))
		text += 'streamingEvents len ({0})\n'.format(len(streamingEvents))
		text += 'MycheckRecordings ({0})\n'.format(MycheckRecordings(self.session))
		recslist = self.session.nav.getRecordings()
		recsptr = []
		for recs in recslist:
			if recs:
				recsptr.append(recs.getPtrString())
		text += 'getRecordings len ({0}) ptr {1}\n'.format(len(recslist), ', '.join(recsptr))
		import NavigationInstance
		if NavigationInstance.instance:
			recslistpnav = NavigationInstance.instance.pnav and NavigationInstance.instance.pnav.getRecordings(False)
			recsptrpnav = []
			for recs in recslistpnav:
				if recs:
					recsptrpnav.append(recs.getPtrString())
			text += 'pnav.getRecordings len ({0}) ptr {1}\n'.format(len(recslistpnav), ', '.join(recsptrpnav))
		#writelog('{0}{1}'.format(text, '#'*50))
		self.session.open(MessageBox, text, MessageBox.TYPE_INFO, title='Streamrelay' + ' ' + _('Information'))


def addicambouquet(session, service, csel, **kwargs):
	if service and csel:
		def bouquetCallback(bouquet):
			_result_ = getattr(csel, '_addicambouquetresult_', None)
			if _result_:
				name = _result_[0]
				servicestr = _result_[1]
				delattr(csel, '_addicambouquetresult_')
				
				if streamrelayconf['nameadd']:
					name += ' ' + streamrelayconf['nameadd']
				
				service.type = 1
				if streamrelayconf['referencefix']:
					service.setUnsignedData(0, 1)
					service.setUnsignedData(2, 11)
					service.setUnsignedData(3, 22)
			
				service.setUnsignedData(4, 33)
				service.setName('{0}'.format(name))
				service.setPath('http://{0}:{1}/{2}'.format(streamrelayconf['streamhost'], streamrelayconf['streamport'], servicestr))
				if isinstance(service, eServiceReference):
					csel.addServiceToBouquet(bouquet, service=service)
					from ServiceReference import ServiceReference
					serviceref = ServiceReference(bouquet)
					def messCallback(val=None):
						bouquetSel.close()

					servicestr = service.toString()
					servicestr = servicestr[:servicestr.find('http')]
					text = '{0}\n\n{1} {2}\n{3} {4}\n{5} {6}'.format(_("Added: "), _('Bouquet'), serviceref.getServiceName(), _('Channel'), name, _('Service reference'), servicestr)
					session.openWithCallback(messCallback, MessageBox, text, MessageBox.TYPE_INFO, timeout=3)
			
		bouquets = csel.getBouquetList()
		bouquetSel = session.open(BouquetSelector, bouquets, bouquetCallback, enableWrapAround=True)

def addicambouquethelperfnc(csel):
	if csel and csel.movemode == False:
		try:
			service = csel.getCurrentSelection()
			if service:
				serviceHandler = eServiceCenter.getInstance()
				info = serviceHandler.info(service)
				if info and info.getInfo(service, iServiceInformation.sIsCrypted) == 1:
					name = (info.getName(service) or "<n/a>").replace('\xc2\x86', '').replace('\xc2\x87', '')
					servicestr = service.toString()
					if servicestr:
						setattr(csel, '_addicambouquetresult_', (name, servicestr))
						return True
		except:
			return False
	return False
	
def addicamrefhelperfnc(csel):
	if csel and csel.movemode == False and streamrelayconf['icamref']:
		try:
			service = csel.getCurrentSelection()
			if service:
				serviceHandler = eServiceCenter.getInstance()
				info = serviceHandler.info(service)
				if info and info.getInfo(service, iServiceInformation.sIsCrypted) == 1:
					name = (info.getName(service) or "<n/a>").replace('\xc2\x86', '').replace('\xc2\x87', '')
					servicestr = service.toString()
					if servicestr:
						setattr(csel, '_icamresult_', {servicestr:name})
						return True
		except:
			return False
	return False
	
def addicamref(session, service, csel, **kwargs):
	if service and csel:
		_icamresult_ = getattr(csel, '_icamresult_', None)
		if _icamresult_:
			global icamrefchanged
			icamrefchanged = True
			
			name = _icamresult_.values()[0]
			servicestr = _icamresult_.keys()[0]
			
			if servicestr and servicestr in icamref:
				del icamref[servicestr]
				textvalu = _('Removed successfully.')
			else:
				icamref.update(_icamresult_)
				textvalu = _('Added: ')
			delattr(csel, '_icamresult_')
			text = '{0}\n\n{1} {2}\n{3} {4}'.format(textvalu, _('Channel'), name, _('Service reference'), servicestr)
			session.open(MessageBox, text, MessageBox.TYPE_INFO, timeout=3)
	
def infobarstart(session, **kwargs):
	
	from Screens.InfoBar import InfoBar
	'''if InfoBar.instance and streamrelayconf['recordstate']:
		StreamRelayInfoinstantiateDialog = session.instantiateDialog(StreamRelayInfo, zPosition=-1)
		StreamRelayInfoinstantiateDialog.neverAnimate()
		InfoBar.instance.onShow.append(StreamRelayInfoinstantiateDialog.toggleShow)
		InfoBar.instance.onHide.append(StreamRelayInfoinstantiateDialog.hide)'''
		
	if InfoBar.instance and streamrelayconf['icamref']:
		InfoBar.instance.onClose.append(__writeicamref__)
		orizap = ChannelSelection.zap
		#orizap = InfoBar.instance.servicelist.zap
		serviceHandler = eServiceCenter.getInstance()
	
		def convertref(nref, name, servicestr):
			if streamrelayconf['nameadd']:
				name += ' ' + streamrelayconf['nameadd']
			nref.type = 1
			if streamrelayconf['referencefix']:
				nref.setUnsignedData(0, 1)
				nref.setUnsignedData(2, 11)
				nref.setUnsignedData(3, 22)
			
			nref.setUnsignedData(4, 33)
			nref.setName('{0}'.format(name))
			nref.setPath('http://{0}:{1}/{2}'.format(streamrelayconf['streamhost'], streamrelayconf['streamport'], servicestr))
			
			icamident['compare'] = nref.toCompareString()
			icamident['servicestr'] = servicestr
			
		def zap(self, nref=None, root=None):
		#def zap(nref=None, root=None):
			if not nref:
				nref = self.getCurrentSelection()
				#nref = InfoBar.instance.servicelist.getCurrentSelection()
				if nref:
					info = serviceHandler.info(nref)
					if info:
						#if streamingScreens:
						#	checkstreaming()
						if info.getInfo(nref, iServiceInformation.sIsCrypted) == 1:
							servicestr = nref.toString()
							if servicestr and icamref and servicestr in icamref:
								#name = (icamref[servicestr] and icamref[servicestr].encode('utf-8')) or (info.getName(nref) or "<n/a>").replace('\xc2\x86', '').replace('\xc2\x87', '') or '<n/a>'
								name = (info.getName(nref) or "").replace('\xc2\x86', '').replace('\xc2\x87', '') or (icamref[servicestr] and icamref[servicestr].encode('utf-8')) or '<n/a>'
								#self.setCurrentSelection(eServiceReference(servicestr))
								convertref(nref, name, servicestr)
								#self.setCurrentSelection(nref)
								#writelog('zap {0} {1}'.format(name, servicestr))
								#InfoBar.instance.session.nav.stopService()
			orizap(self, nref, root)
			#orizap(nref, root)
		
		readicamref()
		ChannelSelection.zap = zap
		#InfoBar.instance.servicelist.zap = zap

def setup(session, **kwargs):
	session.open(StreamRelaySetup)

def openrepeatzap(session, **kwargs):
	session.open(repeatzap)
	
def Plugins(path, **kwargs):
	return [
		PluginDescriptor(
			name="Stream Relay " + _("Repeatzap"),
			description="Stream Relay " + _("Repeatzap"),
			where = PluginDescriptor.WHERE_EXTENSIONSMENU,
			fnc=openrepeatzap,
			icon="plugin.png"),
		PluginDescriptor(
			name=_("add service to bouquet") + ' (ICAM)',
			description=_("add service to bouquet") + ' (ICAM)',
			where = PluginDescriptor.WHERE_CHANNEL_CONTEXT_MENU,
			fnc=addicambouquet,
			helperfnc=addicambouquethelperfnc,
			weight=24),
		PluginDescriptor(
			name=_('Add') + ' / ' + _("Remove") + ' (ICAMREF)',
			description=_('Add') + ' / ' + _("Remove") + ' (ICAMREF)',
			where = PluginDescriptor.WHERE_CHANNEL_CONTEXT_MENU,
			fnc=addicamref,
			helperfnc=addicamrefhelperfnc,
			weight=25),
		PluginDescriptor(
			name="Stream Relay " + _("Setup"),
			description="Stream Relay " + _("Setup"),
			where = PluginDescriptor.WHERE_PLUGINMENU,
			fnc=setup,
			icon="plugin.png"),
		PluginDescriptor(
			where = PluginDescriptor.WHERE_INFOBAR,
			fnc=infobarstart,
			needsRestart = True,
			weight=1000)
		]
		
#########################################################
readstreamrelayconf()

def serviceEvent_ok(event, self):
	try:
		if event == 1:
			if self.has_key("StreamService"):
				eventservice = self.getRecordServiceRef()
				if eventservice:
					eventservice = self.getRecordServiceRef().toCompareString()
					for streaming in streamingScreens:
						if streaming.has_key("StreamService"):
							streamingservice = self.getRecordServiceRef()
							if streamingservice:
								streamingservice = self.getRecordServiceRef().toCompareString()
								if eventservice == streamingservice:
									streamingScreens.remove(streaming)
	except:
		writeerror()

def serviceEvent(event, self):
	try:
		if event == 1:
			eventstream = self.get("StreamService")
			if eventstream and eventstream.ref:
				eventstreamcompare = eventstream.ref.toCompareString()
				if eventstreamcompare:
					for streaming in streamingScreens:
						stream = streaming.get("StreamService")
						if stream and stream.ref:
							if eventstreamcompare == stream.ref.toCompareString():
								streamingScreens.remove(streaming)
	except:
		writeerror()

#if streamrelayconf.get('icamref', None) or streamrelayconf.get('recordstate', None):
#	if serviceEvent not in streamingEvents:
#		streamingEvents.append(serviceEvent)


def gotRecordEvent_timer_list(self, service, event):
	try:
		prev_records = self.records_running
		if event in [iRecordableService.evNewEventInfo, iRecordableService.evEnd, None]:
			recordres = 0
			if service:
				recslist = self.session.nav.getRecordings()
				if recslist:
					for timer in self.session.nav.RecordTimer.timer_list:
						if timer.state == TimerEntry.StateRunning and not timer.justplay and hasattr(timer, "Filename"):
							recordres += 1
						
			self.records_running = recordres
			if self.records_running != prev_records:
				self.changed((self.CHANGED_ALL,))
	except:
		writeerror()
			
def gotRecordEvent_streamingptr(self, service, event):
	try:
		prev_records = self.records_running
		if event in [iRecordableService.evNewEventInfo, iRecordableService.evEnd, None]:
			recslen = 0
			if service:
				recslist = self.session.nav.getRecordings()
				if recslist:
					streamingptr = checkstreaming()
					#recslistptr = []
					for x in recslist:
						recsptr = x.getPtrString()
						#recslistptr.append(recsptr)
						if recsptr not in streamingptr:
							recslen += 1
						
			self.records_running = recslen
			if self.records_running != prev_records:
				self.changed((self.CHANGED_ALL,))
	except:
		writeerror()
			
def gotRecordEvent(self, service, event):
	try:
		#writelog('event {0} mainstreamptr {1} getRecordings {2} MycheckRecordings {3}'.format(event, mainstreamptr, len(self.session.nav.getRecordings()), MycheckRecordings(self.session)))
		prev_records = self.records_running
		if event in [iRecordableService.evNewEventInfo, iRecordableService.evEnd, None]:
			recslen = 0
			if service:
				recslen = MycheckRecordings(self.session)
				#recslist = self.session.nav.getRecordings()
				#if recslist:
				#	for x in recslist:
				#		if x.getPtrString() not in mainstreamptr:
				#			recslen += 1
						
			self.records_running = recslen
			if self.records_running != prev_records:
				self.changed((self.CHANGED_ALL,))
	except:
		writeerror()

def getRecordings(self, simulate=False):
	try:
		streamingptr = checkstreaming()
		#writelog('streamingptr {0}'.format(streamingptr))
		if streamingptr:
			recslist = self.pnav and self.pnav.getRecordings(simulate)
			if recslist:
				recsres = []
				for recs in recslist:
					#recsptr = recs.getPtrString()
					if recs.getPtrString() not in streamingptr:
						recsres.append(recs)
				#writelog('getRecordings {0}'.format(recsres))
				return recsres
				
		#else:
		#return self.pnav and self.pnav.getRecordings(simulate)
	except:
		writeerror()
	
	return self.pnav and self.pnav.getRecordings(simulate)
	
def execBegin(self):
	try:
		ori_execBegin(self)
		_service_ = self.getService()
		if _service_:
			mainstreamptr.append(_service_.getPtrString())
			#writelog('execBegin {0} {1}'.format(mainstreamptr, self.ref.toString()))
	except:
		writeerror()


def execEnd(self):
	try:
		_service_ = self.getService()
		if _service_:
			ptr = _service_.getPtrString()
			#writelog('execEnd start mainstreamptr {0} ptr {1}  {2}'.format(mainstreamptr, ptr, self.ref.toString()))
			if ptr in mainstreamptr:
				mainstreamptr.remove(ptr)
			#writelog('execEnd stop mainstreamptr {0} ptr {1}  {2}'.format(mainstreamptr, ptr, self.ref.toString()))
		ori_execEnd(self)
	except:
		writeerror()

if streamrelayconf.get('recordstate', None):

	#ori_execBegin = getattr(StreamService, 'execBegin', None)
	#delattr(StreamService, 'execBegin')
	#setattr(StreamService, 'execBegin', execBegin)
	if serviceEvent not in streamingEvents:
		streamingEvents.append(serviceEvent)
	
	#############################
	from Components.Sources.StreamService import StreamService
	from Components.Sources.RecordState import RecordState
	ori_execBegin = StreamService.execBegin
	StreamService.execBegin = execBegin
	
	ori_execEnd = StreamService.execEnd
	StreamService.execEnd = execEnd
	RecordState.gotRecordEvent = gotRecordEvent
	#############################
	try:
		from Components.FrontPanelLed import FrontPanelLed
		def checkRecordings(self, service=None, event=iRecordableService.evNewEventInfo):
			if not self._session:
				return
			if event in [iRecordableService.evNewEventInfo, iRecordableService.evEnd]:
				recordings = MycheckRecordings(self._session)
				if recordings:
					FrontPanelLed.recording()
					#writelog('event {0} MycheckRecordings FrontPanelLed.recording()'.format(event))
				else:
					FrontPanelLed.stopRecording()
					#writelog('event {0} MycheckRecordings FrontPanelLed.stopRecording()'.format(event))
		FrontPanelLed.checkRecordings = checkRecordings
		##from API import api
		##api.setSession(session)
		#from API import session
		#from Components.FrontPanelLed import frontPanelLed
		#frontPanelLed.init(session)
	except:
		pass
		#writeerror()
	#############################
	#from Navigation import Navigation
	#ori_getRecordings = Navigation.getRecordings
	#Navigation.getRecordings = getRecordings
	#############################

def setCurrentSelection(self, service):
	try:
		if service and service.getUnsignedData(4) == 33:
			if icamident['compare'] == service.toCompareString():
				service = eServiceReference(icamident['servicestr'])
	except:
		writeerror()
	
	self.servicelist.setCurrent(service)
	
if streamrelayconf.get('icamref', None):
	if serviceEvent not in streamingEvents:
		streamingEvents.append(serviceEvent)
	from Screens.ChannelSelection import ChannelSelectionBase
	ChannelSelectionBase.setCurrentSelection = setCurrentSelection
	
@staticmethod
def getPngName(ref, nameCache, findPicon):
	try:
		if ref and 'B:16:21' in ref:
			refstr = ref[ref.rfind('/')+1:ref.rfind(':')]
			ref = refstr.replace('%3a',':')
	except:
		writeerror()
	return ori_getPngName(ref, nameCache, findPicon)
	
if streamrelayconf.get('referencefix', None):
	from Tools.PiconResolver import PiconResolver
	ori_getPngName = PiconResolver.getPngName
	PiconResolver.getPngName = getPngName
	
def __tuneFailed(self):
	
	service = self.session.nav.getCurrentService()
	info = service and service.info()
	error = info and info.getInfo(iServiceInformation.sDVBState)
	namespace = info and info.getInfo(iServiceInformation.sNamespace)
	#sserviceref = info and info.getInfoString(iServiceInformation.sServiceref)
	
	if error == self.last_error:
		error = None
	else:
		self.last_error = error
	'''print '#'*30
	print '__tuneFailed'
	print 'sserviceref', sserviceref
	print 'self._currentRef', self._currentRef
	print 'self._isReconnect' , self._isReconnect
	print 'namespace', namespace
	print 'last_error', self.last_error
	print 'error', error
	print '#'*30'''
	#if error in [eDVBServicePMTHandler.eventNoResources, eDVBServicePMTHandler.eventTuneFailed, eDVBServicePMTHandler.eventNoPAT]:
	if self._isReconnect == False and (error in [eDVBServicePMTHandler.eventNoResources]) and namespace != 33:
		if streamingScreens:
			checkstreaming()
		self._isReconnect = True
		#self._reconnTimer.startLongTimer(1)
		#name = (info.getName() or "<n/a>").replace('\xc2\x86', '').replace('\xc2\x87', '')
		#self.setPlaybackState(self.MESSAGE_WAIT, name + ' ' +  _('Rezap'))
		self._reconnTimer.start(100,True)
		'''if error == eDVBServicePMTHandler.eventNoResources:
			self._reconnTimer.startLongTimer(1)
		else:
			self.setPlaybackState(self.STATE_RECONNECTING)
			self._reconnTimer.startLongTimer(3)'''
	else:
		self.last_error = None
		ori__tuneFailed(self)

def setPlayableIgnoreService(self, ref):
	try:
		if ref and ref.getUnsignedData(4) == 33:
			path = ref.getPath()
			if path:
				pos = path.rfind('/')
				if pos != -1:
					refstr = path[pos+1:]
					ref = eServiceReference(refstr)
	except:
		writeerror()
		
	self.is_playable_ignore = ref

if streamrelayconf.get('noresources', None):
	from Screens.InfoBarGenerics import InfoBarServiceErrorPopupSupport
	from Components.ServiceList import ServiceList
	ori__tuneFailed = InfoBarServiceErrorPopupSupport._InfoBarServiceErrorPopupSupport__tuneFailed
	InfoBarServiceErrorPopupSupport._InfoBarServiceErrorPopupSupport__tuneFailed = __tuneFailed
	ServiceList.setPlayableIgnoreService = setPlayableIgnoreService