from enigma import *
from Screens.Screen import Screen
from Screens.MessageBox import MessageBox
from Components.ActionMap import ActionMap
from Components.Label import Label
from Components.Input import Input
from Components.GUIComponent import *
from Components.Pixmap import Pixmap
from Components.MenuList import MenuList
from Components.FileList import FileEntryComponent, FileList
from Navigation import Navigation
import NavigationInstance
from Screens.ChannelSelection import SimpleChannelSelection
from ServiceReference import ServiceReference
from Plugins.Plugin import PluginDescriptor
from Tools.Directories import resolveFilename, SCOPE_CONFIG
import xml.dom.minidom
from Tools.XMLTools import elementsWithTag

import os

alternatives = {}

def addAlternative(service1, service2):
	if not alternatives.has_key(service1):
		alternatives[service1] = []
	alternatives[service1].append(service2)
	if not alternatives.has_key(service2):
		alternatives[service2] = []
	alternatives[service2].append(service1)

def removeAlternative(service1, service2):
	alternatives[service1].remove(service2)
	alternatives[service2].remove(service1)
	if len(alternatives[service1]) == 0:
		del alternatives[service1]
	if len(alternatives[service2]) == 0:
		del alternatives[service2]
		
def loadAlternatives():
	doc = xml.dom.minidom.parse(resolveFilename(SCOPE_CONFIG, "alternatives.xml"))
	
	root = doc.childNodes[0]
	for service in elementsWithTag(root.childNodes, 'service'):
		newService = str(service.getAttribute('ref'))
		for alternative in elementsWithTag(service.childNodes, 'alternative'):
			newAlternative = str(alternative.getAttribute('ref'))
			addAlternative(newService, newAlternative)

def sortKey(x):
	return str.lower(ServiceReference(x).getServiceName().strip())
			
class AlternativeZapping(Screen):
	skin = """
		<screen position="100,100" size="560,400" title="Services alternatives setup..." >
			<widget name="red" position="0,0" size="140,40" backgroundColor="red" halign="center" valign="center" font="Regular;21" />
			<widget name="green" position="140,0" size="140,40" backgroundColor="green" halign="center" valign="center" font="Regular;21" />
			<widget name="yellow" position="280,0" size="140,40" backgroundColor="yellow" halign="center" valign="center" font="Regular;21" />
			<widget name="blue" position="420,0" size="140,40" backgroundColor="blue" halign="center" valign="center" font="Regular;21" />
			<widget name="serviceslist" position="0,40" size="280,360" scrollbarMode="showOnDemand" />
			<widget name="alternativeslist" position="280,40" size="280,360" selectionDisabled="1" scrollbarMode="showOnDemand" />
		</screen>"""
	def __init__(self, session):
		self.skin = AlternativeZapping.skin
		Screen.__init__(self, session)

		self.filename = resolveFilename(SCOPE_CONFIG, "alternatives.xml")
		
		self.red = Label("")
		self["red"] = self.red
		self.green = Label(_("Add service"))
		self["green"] = self.green
		self.yellow = Label("")
		self["yellow"] = self.yellow
		self.blue = Label("")
		self["blue"] = self.blue
		
		self.alternatives = {}
		
		self.serviceslist = []
		self.alternativeslist = []
		
		try:
			self.loadAlternatives()
		except:
			pass
		self["serviceslist"] = MenuList(self.serviceslist)
		self["alternativeslist"] = MenuList(self.alternativeslist)

		self.onShown.append(self.updateServices)
		self.onShown.append(self.updateAlternatives)

		self["actions"] = ActionMap(["DirectionActions", "OkCancelActions", "ColorActions"],
		{
			"ok": self.go,
			"cancel": self.go,
			"up": self.up,
			"down": self.down,
			"left": self.left,
			"right": self.right,
			"red": self.redKey,
			"green": self.greenKey,
			"yellow": self.yellowKey,
			"blue": self.blueKey,
		}, -1)
		
	def saveAlternatives(self):
		doc = xml.dom.minidom.Document()
		root_element = doc.createElement('alternatives')
		doc.appendChild(root_element)
		root_element.appendChild(doc.createTextNode("\n"))
		
		for alternative in self.alternatives.keys():
			t = doc.createTextNode("\t")
			root_element.appendChild(t)
			t = doc.createElement('service')
			t.setAttribute("ref", alternative)
			root_element.appendChild(t)
			t.appendChild(doc.createTextNode("\n"))
			for x in self.alternatives[alternative]:
				t.appendChild(doc.createTextNode("\t\t"))
				l = doc.createElement('alternative')
				l.setAttribute("ref", str(x))
				t.appendChild(l)
				t.appendChild(doc.createTextNode("\n"))
			t.appendChild(doc.createTextNode("\t"))
			root_element.appendChild(t)
			t = doc.createTextNode("\n")
			root_element.appendChild(t)
		file = open(self.filename, "w")
		doc.writexml(file)
		file.write("\n")
		file.close()
	
	def loadAlternatives(self):
		self.alternatives = {}
		alternatives = {}
		doc = xml.dom.minidom.parse(self.filename)
		
		root = doc.childNodes[0]
		for service in elementsWithTag(root.childNodes, 'service'):
			newService = str(service.getAttribute('ref'))
			if not self.alternatives.has_key(newService):
				self.alternatives[newService] = []
			for alternative in elementsWithTag(service.childNodes, 'alternative'):
				newAlternative = str(alternative.getAttribute('ref'))
				self.alternatives[newService].append(newAlternative)
				addAlternative(newService, newAlternative)
		
	def go(self):
		self.saveAlternatives()
		self.close()
	
	def up(self):
		self["serviceslist"].instance.moveSelection(self["serviceslist"].instance.moveUp)
		self.updateAlternatives()
		
	def down(self):
		self["serviceslist"].instance.moveSelection(self["serviceslist"].instance.moveDown)
		self.updateAlternatives()
	
	def left(self):
		pass
	
	def right(self):
		pass
	
	def redKey(self):
		for x in self.alternatives[self["serviceslist"].getCurrent()[1]]:
			removeAlternative(self["serviceslist"].getCurrent()[1], x)
		if len(self.serviceslist) > 0:
			del self.alternatives[self["serviceslist"].getCurrent()[1]]
		self.updateServices()
		self.updateAlternatives()
	
	def finishedAlternativeSelection(self, args):
		self.alternatives[self["serviceslist"].getCurrent()[1]].append(str(ServiceReference(args)))
		addAlternative(self["serviceslist"].getCurrent()[1], str(ServiceReference(args)))
		self.updateAlternatives()
	
	def updateServices(self):
		self.serviceslist = []
		keys = self.alternatives.keys()
		keys.sort(key = sortKey)
		for x in keys:
			self.serviceslist.append((ServiceReference(x).getServiceName(), x))
			
		self["serviceslist"].setList(self.serviceslist)
		if len(self.serviceslist) > 0:
			self.yellow.setText(_("Add alternative"))
			self.red.setText(_("Remove service"))
		else:
			self.yellow.setText("")
			self.red.setText("")
	
	def selectService(self, ref):
		count = 0
		for x in self["serviceslist"].list:
			if x[1] == ref:
				self["serviceslist"].instance.moveSelectionTo(count)
				return
			count += 1
			
			
	def updateAlternatives(self):
		self.alternativeslist = []
	
		if len(self.serviceslist) > 0:
			alternativelist = self.alternatives[self["serviceslist"].getCurrent()[1]]

			for x in alternativelist:
				self.alternativeslist.append((ServiceReference(x).getServiceName(), x))
			
		self["alternativeslist"].setList(self.alternativeslist)
			
	def greenKey(self):
		self.session.openWithCallback(self.finishedChannelSelection, SimpleChannelSelection, _("Select reference service"))

	def finishedChannelSelection(self, args):
		serviceString = str(ServiceReference(args))
		if not self.alternatives.has_key(serviceString):
			self.alternatives[serviceString] = []
		self.updateServices()
		self.selectService(serviceString)
		self.updateAlternatives()
		
	def yellowKey(self):
		if len(self.serviceslist) > 0:
			self.session.openWithCallback(self.finishedAlternativeSelection, SimpleChannelSelection, _("Select alternative service"))
	
	def blueKey(self):
		pass


oldPlayService = None

from Components.PerServiceDisplay import PerServiceDisplay

class ServiceChanged(PerServiceDisplay):
	def __init__(self, navcore):
		PerServiceDisplay.__init__(self, navcore,
			{
				iPlayableService.evTuneFailed: self.tuneFailed,
				iPlayableService.evStart: self.start
			})
		
		self.lastPlayAction = None
		self.nextPlayTry = 0

	def start(self):
#		print "+++++++++++++++++++++++++++++++++++++++++++++++++Start", self.lastPlayAction
		if self.lastPlayAction is not None:
			self.lastPlayAction = None

	def tuneFailed(self):
#		print "+++++++++++++++++++++++++++++++++++++++++++++++++Tuning failed!", self.lastPlayAction
		ref = self.lastPlayAction
#		print "Ref:", ref
#		print "Alternatives: failed to play service"
		if ref is not None:
			if alternatives.has_key(ref):
#					print "Alternatives: trying alternatives"
					if len(alternatives[ref]) > self.nextPlayTry:
#						print "Alternatives: trying alternative", alternatives[ref][self.nextPlayTry]
						if oldPlayService(ServiceReference(alternatives[ref][self.nextPlayTry]).ref) == 0:
								self.nextPlayTry += 1
#								print "Alternatives: Alternative found!"
						else:
								self.nextPlayTry += 1
#								print "Alternatives: Alternative doesn't play either"
								self.tuneFailed()
					else:
						self.lastPlayAction = None

					#print "Alternatives: No playable alternative found!"

servicechanged = None

def playService(self, ref):
	#print "--------------------Alternatives: trying to play service", str(ServiceReference(ref))
	if ref is not None:
		servicechanged.lastPlayAction = str(ServiceReference(ref))
	servicechanged.nextPlayTry = 0
	result = oldPlayService(ref)
	
	return result

def sessionstart(reason, session, **kwargs):
	if reason == 0:
		try:
			loadAlternatives()
		except: # FIXME, THIS IS ILLEGAL CODE AND WILL BE PROSECUTED!
			pass
		
		# attach to this sessions navigation instance.
		global oldPlayService, servicechanged
		oldPlayService = session.nav.playService
		session.nav.playService = type(session.nav.playService)(playService, NavigationInstance, Navigation)
		servicechanged = ServiceChanged(session.nav)

def AlternativeZappingSetup(session, **kwargs):
	session.open(AlternativeZapping)

def Plugins(**kwargs):
 	return [PluginDescriptor(where = PluginDescriptor.WHERE_SESSIONSTART, fnc = sessionstart),
 			PluginDescriptor(name="Alternative services setup" , description="Defines alternatives for services.", where = PluginDescriptor.WHERE_PLUGINMENU, fnc=AlternativeZappingSetup)]