# -*- coding: utf-8 -*-
import logging, os, time
import commands
import subprocess
import ConfigParser
import urllib2
config_file = "mv_config"
data_config = __import__(config_file, globals(), locals(), [])

module_config = ConfigParser.RawConfigParser()
try:
    module_config.read('/etc/mythvantage.cfg')
except:
    logging.info("couldn't read mythvantage.cfg")

class config_extra_reader(object):
    def __init__(self,url):
        self.url=url
        self.Config = ConfigParser.ConfigParser()
        req = urllib2.Request(url)
        response = urllib2.urlopen(req)
        self.Config.readfp(response)

    def print_url(self):
        print self.url


    def print_sections(self):
        print self.Config.sections()


    def read_config(self,data):
        rvalue = True
        section = "extra"
        try:
            rvalue = self.Config.get(section, data)
            if rvalue == "False":
                rvalue = False
            if rvalue == "no":
                rvalue = False
        except:
            logging.debug("Couldn't read config_file")
            rvalue = True

        return rvalue



def read_config(module_config,data):
    rvalue = True
    section = "mythvantage"
    try:
        rvalue = module_config.get(section, data)
        if rvalue == "False":
            rvalue = False
        if rvalue == "no":
            rvalue = False


    except:
        logging.debug("Couldn't read mythvantage.cfg")
        rvalue = True

    return rvalue


def runcmd_bg(cmd):
    subprocess.Popen(cmd)

def runcmd(cmd):
    if data_config.NOOPDEBUG=="FALSE":
        pass
    else:
        cmd = "echo "+cmd
    logging.debug("    %s",cmd)
    cmdout = commands.getstatusoutput(cmd)
    logging.debug("    %s",cmdout)
    return cmdout[0]

def runcmd_output(cmd):
    if data_config.NOOPDEBUG=="FALSE":
        pass
    else:
        cmd = "echo "+cmd
    logging.debug("    %s",cmd)
    cmdout = commands.getstatusoutput(cmd)
    logging.debug("    %s",cmdout)
    return cmdout[1]

def services(systemconfig):
    logging.debug("______Start of services______")
    logging.debug("__End services")

def cp_and_log(srcfile,destfile):
    #return
    if not os.path.exists(srcfile):
        logging.info("%s is not present, skipping...",srcfile)
    else:
        cmd = ("rsync -arhp %s %s") %(srcfile,destfile)
        runcmd(cmd)

def link_file(srcfile,link_name):
    logging.info("    Trying to link %s ->  %s",srcfile,link_name)
    if not os.path.exists(srcfile):
        logging.info("    %s is not present, skipping...",srcfile)
    elif os.path.exists(link_name):
        logging.info("    %s is present, skipping...",link_name)
    else:
        try:
            os.symlink(srcfile, link_name)
        except:
            logging.info("    Problem linking files occured")

    return

def mkdir_mythhome(mythhome,user,grp=1000):
     if not os.path.exists(mythhome+"/.mythtv"):
        logging.debug("    Creating %s/.mythtv",mythhome)
        try:
            os.mkdir(mythhome+"/.mythtv")
        except:
            logging.debug("   Couldn't create .mythtv ")

        try:
            #os.chown(mythhome+"/.mythtv", int(user), int(grp))
            #logging.debug("*    Couldn't chown of %s", mythhome)

            cmd = ''' chown -R %s %s/.mythtv''' %(user,mythhome)
            runcmd(cmd)
            cmd = ''' chgrp -R %s %s/.mythtv''' %(grp,mythhome)
            runcmd(cmd)
        except:
            logging.debug("*    Couldn't chown of %s", mythhome)
            pass



def add_service(daemon):
    logging.info("    Adding service %s",daemon)
    cmd = "add_service.sh %s" %daemon
    runcmd(cmd)

def remove_service(daemon):
    logging.info("    Removing service %s",daemon)
    stop_service(daemon)
    cmd = "remove_service.sh %s" %daemon
    runcmd(cmd)

def start_service(daemon):
    logging.info("    start service %s",daemon)
    cmd = "sv start %s" %daemon
    runcmd(cmd)

def stop_service(daemon):
    logging.info("    stop service %s",daemon)
    cmd = "sv stop %s" %daemon
    runcmd(cmd)

def restart_service(daemon):
    logging.info("    Restarting service %s",daemon)
    if daemon == "lcdd":
        stop_service(daemon)
        logging.debug("    killing all lcdd")
        cmd = "killall -9 LCDd"
        runcmd(cmd)
        time.sleep(2)
        start_service(daemon)
    else:
        cmd = "sv restart %s" %daemon
        runcmd(cmd)

def check_service(daemon):
    logging.info("    Checking status of service %s",daemon)
    cmd = "sv status %s" %daemon
    results = runcmd_output(cmd)
    status = results.split()[0]
    if status == "run:":
        return True
    else:
        return False

def hup_service(daemon):
    logging.info("    hup service %s",daemon)
    cmd = "sv hup %s" %daemon
    runcmd(cmd)



def pkg_blacklist_check(pkg):
    cmd = '''grep -q %s /etc/blacklist.package''' %pkg
    rc = runcmd(cmd)
    if rc == 0:
        return True
    else:
        return False

def pkg_installed_check(pkg):
    logging.debug("    Checking if %s is installed",pkg)
    cmd = "pacman -Q %s " %pkg
    rc = runcmd(cmd)
    if rc == 0:
        return True
    else:
        return False


def pacinstall(pkg):
    logging.info("    Checking %s for install",pkg)
    #extra pkg check
    if pkg == "xine":
        pacinstall("xine-ui")
    elif pkg == "dvdcss":
        pacinstall("libdvdcss")
    elif pkg == "webmin":
        add_service("webmin")
    elif pkg == "fuppes":
        pacinstall("fuppes-svn")
    elif pkg == "mupen64":
        pacinstall("mupen64plus")
    elif pkg == "dolphinemu":
        pacinstall("dolphin-emu")
    elif pkg == "webonlinhes":
        pacinstall("web-on-linhes")
    elif pkg == "xbmc":
        pacinstall("xbmc-pvr-addons")
    elif pkg == "kodi":
        pacinstall("kodi-addon-pvr-mythtv-git")
    elif pkg == "plexhometheater":
        pacinstall("openpht")
    elif pkg == "plexmediaserver":
        pacinstall("plex-media-server")
    elif pkg == "mame":
         pacinstall("sdlmame")
    elif pkg == "foldingathome":
         add_service("fah")

    elif pkg == "xymonclient":
        if os.path.exists('/home/xymon/client'):
            cmd='''pacman --noconfirm --dbonly -Sdd xymonclient'''
            runcmd(cmd)

    if  not pkg_blacklist_check(pkg):
        if pkg_installed_check(pkg):
            logging.info("    %s is already installed, will not install",pkg)
        else:
            logging.info("    Installing %s",pkg)
            cmd ='''pacman --noconfirm -S %s ''' %pkg
            runcmd(cmd)
    else:
        logging.info("    %s is blacklisted, will not install",pkg)

def pacremove(pkg):
    logging.info("    Checking %s for removal",pkg)
    if pkg == "xine":
        pacremove("xine-ui")
    elif pkg == "dvdcss":
        pacremove("libdvdcss")
    elif pkg == "webmin":
        remove_service("webmin")
    elif pkg == "fuppes":
        pacremove("fuppes-svn")
    elif pkg == "mupen64":
        pacremove("mupen64plus")
    elif pkg == "dolphinemu":
        pacremove("dolphin-emu")
    elif pkg == "webonlinhes":
        pacremove("web-on-linhes")
    elif pkg == "xbmc":
        pacremove("xbmc-pvr-addons")
    elif pkg == "kodi":
        pacremove("kodi-addon-pvr-mythtv-git")
    elif pkg == "plexhometheater":
        pacremove("openpht")
    elif pkg == "plexmediaserver":
        pacremove("plex-media-server")
    elif pkg == "mame":
        pacremove("sdlmame")
    elif pkg == "foldingathome":
        remove_service("fah")


    if  not pkg_blacklist_check(pkg):
        if not pkg_installed_check(pkg):
            logging.info("    %s is not installed, will not remove",pkg)
        else:
            logging.info("    Removing %s",pkg)
            cmd ='''pacman --noconfirm -R  %s ''' %pkg
            runcmd(cmd)
    else:
        logging.info("    %s is blacklisted, will not remove",pkg)

def getpid(process):
    return commands.getoutput('pidof %s' % process)

def remove_file(filename):
    logging.debug("    Removing %s", filename)
    try:
        os.remove(filename)
    except:
        logging.debug("*     Could not remove %s", filename)


def restartLCD(RESTART_LCD):
    if  RESTART_LCD :
        logging.info("    Restarting lcd server")
        cmd = "killall -9 mythlcdserver"
        runcmd(cmd)
    else:
        logging.debug("    Not restarting MYTHLCD server")


def reloadfe(dbhost,RESTART_LCD):
    logging.debug("____Start of reloadfe____")
    if data_config.SYSTEMTYPE == "MythVantage":
        logging.info("    Clearing Backend cache")
        cmd = '''/usr/bin/backend_control.sh  clearcache  behost %s''' %dbhost
        runcmd(cmd)

    restartLCD(RESTART_LCD)
#    for pid in getpid("mythfrontend"):
    pid = getpid("mythfrontend")
    cmd = ''' kill -s USR1 %s ''' %pid
    runcmd(cmd)
    logging.info("    Reloading frontend with pid of %s",pid)

    logging.debug("__End of reloadfe\n")


def restartfe(RESTART_LCD):
    logging.debug("____Start of restartfe____")
    if data_config.SYSTEMTYPE=="LinHES":
        logging.debug("    LinHES seems to be running will not restartfe")
        return
    logging.info("    Restarting frontend")
    restartLCD(RESTART_LCD)
    cmd="killall -9 mythfrontend"
    runcmd(cmd)
    cmd="killall -9 welcome"
    runcmd(cmd)
    logging.debug("__End of restartfe\n")


def udev_trigger():
    logging.info("    Triggering udev")
    cmd = "udevadm settle"
    runcmd(cmd)
    cmd = "udevadm trigger"
    runcmd(cmd)
    cmd = "udevadm settle"
    runcmd(cmd)
    cmd = "udevadm trigger"
    runcmd(cmd)


