from enigma import eServiceReference, eServiceCenter, iServiceInformation
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

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

try:
	from Plugins.Extensions.WebInterface.WebScreens import streamingScreens
except:
	streamingScreens = None
	
icamref = OrderedDict()
icamrefchanged = False
streamrelayconf = {}
streamrelayconf['icamref'] = False
streamrelayconf['referencefix'] = False
streamrelayconf['streamhost'] = '127.0.0.1'
streamrelayconf['nameadd'] = ''
streamrelayconf['noresources'] = False

ICAMREFDIR = resolveFilename(SCOPE_CONFIG, "icamref.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['streamhost'] != '127.0.0.1':
			tmp['streamhost'] = streamrelayconf['streamhost']
		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('streamhost'):
				streamrelayconf['streamhost'] = data['streamhost'].encode('utf-8')
			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)

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

def stopstreaming():
	try:
		if streamingScreens:
			for streaming in streamingScreens:
				if streaming.has_key("StreamService"):
					service = streaming["StreamService"].getService()
					if service:
						streaming["StreamService"].navcore.stopRecordService(service)
						#streaming["StreamService"].navcore.stopService()
				streamingScreens.remove(streaming)
	except:
		pass
		
class StreamRelaySetup(Screen, ConfigListScreen):
	#IS_DIALOG = True
	def __init__(self, session):
		Screen.__init__(self, session)
		ConfigListScreen.__init__(self, [], session=session)
		self.skinName = "Setup"

		self["key_red"] = StaticText(_("Cancel"))
		self["key_green"] = StaticText(_("Save"))

		self["actions"] = ActionMap(["SetupActions", "ColorActions", "InfobarActions"],
			{
				"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,
			})
			
		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.streamhost = NoSave(ConfigIP(default = streamrelayconf['streamhost'].split('.'), auto_jump=True))
		self.settings.nameadd = NoSave(ConfigText(default = streamrelayconf['nameadd'], fixed_size=False))
		
		self.changeicamref = streamrelayconf['icamref']
		self.changenoresources = streamrelayconf['noresources']
		self.onLayoutFinish.append(self.firststart)
		
		self._createSetup()
	
	def KeyText(self):
		curr = self["config"].getCurrent()
		if curr and curr[1] == self.settings.nameadd:
			ConfigListScreen.KeyText(self)
			
	def keyLeft(self):
		ConfigListScreen.keyLeft(self)
		curr = self["config"].getCurrent()
		if curr and curr[1] == self.settings.icamref:
			print 'keyLeft'
			self._createSetup()
	def keyRight(self):
		
		ConfigListScreen.keyRight(self)
		curr = self["config"].getCurrent()
		if curr and curr[1] == self.settings.icamref:
			print 'keyRight'
			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('Name ' + _('advanced'), self.settings.nameadd))
		entries.append(getConfigListEntry(_('No free tuner!') + ' ' + ' / ' + _('Channel Selection') + ' ' + _('Color'), self.settings.noresources))
		entries.append(getConfigListEntry('Auto Convert icamref / ' + _('Namespace') + ' (ID=33 / 0x21)', self.settings.icamref))
		if self.settings.icamref.value:
			entries.append(getConfigListEntry(_('Service') + ' ' + _('Type') + '=1 ' + _('Transponder') + ' (ID=11 / 0xB) ' + _('Network') + ' (ID=22 / 0x16)', 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['streamhost'] = self.settings.streamhost.getText()
			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']):
				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):
		global icamrefchanged
		__writeicamref__()
		self.close(True)
	
	def keyyellow(self):
		readicamref()
		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 setup(session, **kwargs):
	session.open(StreamRelaySetup)



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'], 17999, 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:
				eServiceCenterInstance = eServiceCenter.getInstance()
				info = eServiceCenterInstance.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:
				eServiceCenterInstance = eServiceCenter.getInstance()
				info = eServiceCenterInstance.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['icamref']:
		
		InfoBar.instance.onClose.append(__writeicamref__)
		orgzap = ChannelSelection.zap

		eServiceCenterInstance = 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'], 17999, servicestr))
		
		def listzap(self, nref=None, root=None):
			if not nref:
				nref = self.getCurrentSelection()
				if nref:
					info = eServiceCenterInstance.info(nref) or None
					if info:
						if streamingScreens:
							stopstreaming()
						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>'
								convertref(nref, name, servicestr)
			orgzap(self, nref, root)
			
		
		readicamref()
		ChannelSelection.zap = listzap

	
def Plugins(path, **kwargs):
	return [
		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)
		]