from Screens.Screen import Screen
from Plugins.Plugin import PluginDescriptor
from Components.ActionMap import ActionMap
from Components.ServiceEventTracker import ServiceEventTracker
from Components.config import config, ConfigInteger, getConfigListEntry, ConfigSelection, ConfigYesNo, ConfigSubsection
from Components.ConfigList import ConfigList, ConfigListScreen
from Components.MenuList import MenuList
from enigma import iPlayableService, iServiceInformation, eServiceCenter, eServiceReference, iFrontendInformation, eTimer
from Components.Label import Label
from ServiceReference import ServiceReference
from Screens.MessageBox import MessageBox
from Components.Sources.StaticText import StaticText
from enigma import eConsoleAppContainer
from Tools.Directories import fileExists

config.plugins.JaduCAM = ConfigSubsection()
config.plugins.JaduCAM.enable = ConfigYesNo(default=False)
config.plugins.JaduCAM.player = ConfigSelection(default="exteplayer3", choices = [
                    ("exteplayer3", _("Exteplayer3")),
				])

def trace_error():
    import sys
    import traceback
    try:
        traceback.print_exc(file=sys.stdout)
        traceback.print_exc(file=open('/tmp/JaduCAM.log', 'a'))
    except:
        pass


def getversioninfo():
    import os
    currversion = '1.4'
    version_file = '/usr/lib/enigma2/python/Plugins/Extensions/JaduCAM/version'
    if os.path.exists(version_file):
        try:
            fp = open(version_file, 'r').readlines()
            for line in fp:
                if 'version' in line:
                    currversion = line.split('=')[1].strip()
        except:
            pass
    return (currversion)


Ver = getversioninfo()


REDC = '\033[31m'
ENDC = '\033[m'


def cprint(text):
    print(REDC+text+ENDC)


class JaduCAM(Screen):

    def __init__(self, session):
        Screen.__init__(self, session)
        self.session = session
        self.__event_tracker = ServiceEventTracker(screen=self, eventmap={
            iPlayableService.evStart: self.__evStart,
            iPlayableService.evTunedIn: self.__evStart,
            iPlayableService.evEnd: self.__evEnd,
            iPlayableService.evStopped: self.__evEnd,
        })
        self.Timer = eTimer()
        self.Timer.callback.append(self.get_channel)
        self.container = eConsoleAppContainer()
        self.ip_sat = False


    def getPlaylist(self):
        import json
        if fileExists('/etc/enigma2/jaducam.json'):
            with open('/etc/enigma2/jaducam.json', 'r')as f:
                try:
                    return json.loads(f.read())
                except ValueError:
                    trace_error()
        else:
            return None

    def current_channel(self, channel,lastservice):
        playlist = self.getPlaylist()
        player = config.plugins.JaduCAM.player.value
        if channel and playlist:
            for ch in playlist['playlist']:
                if channel == ch['channel'].strip():
                    if not self.ip_sat:
                        self.session.nav.stopService()
                        cmd = '{} {}'.format(player,ch['url'])
                        self.container.execute(cmd)
                        self.session.nav.playService(lastservice)
                        self.ip_sat = True


    def get_channel(self):
        service = self.session.nav.getCurrentService()
        if service:
            info = service and service.info()
            if info:
                FeInfo = service and service.frontendInfo()
                if FeInfo:
                    SNR = FeInfo.getFrontendInfo(iFrontendInformation.signalQuality) / 655
                    isCrypted = info and info.getInfo(iServiceInformation.sIsCrypted)
                    if isCrypted and SNR > 10:
                        lastservice = self.session.nav.getCurrentlyPlayingServiceReference()
                        channel_name = ServiceReference(lastservice).getServiceName()
                        self.current_channel(channel_name,lastservice)
                    else:
                        if self.ip_sat:
                            self.container.sendCtrlC()
                            self.ip_sat = False

    def __evStart(self):
        self.Timer.start(1000)
                            
    def __evEnd(self):
        self.Timer.stop()
        if self.ip_sat:
            self.container.sendCtrlC()
            self.ip_sat = False


def autostart(reason, **kwargs):
    if reason == 0:
        if config.plugins.JaduCAM.enable.value:
            session = kwargs["session"]
            JaduCAM(session)


def jaducamSetup(session, **kwargs):
    session.open(JaduCAMSetup)


def Plugins(**kwargs):
    Descriptors = []
    Descriptors.append(PluginDescriptor(where=[PluginDescriptor.WHERE_SESSIONSTART], fnc=autostart))
    return Descriptors