#!/usr/bin/python

import subprocess

import web

import netifaces

import argparse

import thread

import time

import os

import sys

import ConfigParser

import logging

from passwordreceiver import *

MINOPTS = { "Main" : ["LogFile", "LogLevel", "MountScript", "UmountScript", "InitScript", "GetDevicesScript", "Keyfile"]}

#CONFIG_FILE="/etc/encryptionprovider/encryptionprovider.cfg"

CONFIG_FILE="/home/spawn/workspace_python/encryptionprovider/config/encryptionprovider.cfg"

CONFIG_NOT_READABLE = "Configfile is not readable"

CONFIG_WRONG = "Something is wrong with the config"

CONFIG_MISSING = "Section: \"%s\" Option: \"%s\" in configfile is missing"

def checkMinimumOptions (config):

    for section, options in MINOPTS.iteritems ():

        for option in options:

            if (config.has_option(section, option) == False):

                print (CONFIG_MISSING % (section, option))

                exit (129)

def loadConfig ():

    configfile = CONFIG_FILE

    config = ConfigParser.SafeConfigParser ()

    if ((os.path.exists (configfile) == False) or (os.path.isfile (configfile) == False) or (os.access (configfile, os.R_OK) == False)):

        print (CONFIG_NOT_READABLE)

        exit (1)

    try:

        config.read (CONFIG_FILE)

    except Exception, e:

        print (CONFIG_WRONG)

        print ("Error: %s" % (e))

        exit (1)

    checkMinimumOptions (config)

    return config

def initLog (config):

    global LOG

    logfile = config.get("Main", "LogFile")

    numeric_level = getattr(logging, config.get("Main", "LogLevel").upper(), None)

    if not isinstance(numeric_level, int):

        raise ValueError('Invalid log level: %s' % loglevel)

    # ToDo move log level and maybe other things to config file

    logging.basicConfig(

                        level = numeric_level,

                        format = "%(asctime)s %(name)-12s %(funcName)-15s %(levelname)-8s %(message)s",

                        datefmt = "%Y-%m-%d %H:%M:%S",

                        filename = logfile,

                        filemode = "a+",

    )

    LOG = logging.getLogger("fuse_main")

def runExternalScripts (command):

    LOG.debug ("Run external Script: %s" %(command,))

    if (os.path.isfile (command[0]) == False):

        LOG.error ("File does not exist: %s" %((command[0]),))

        sys.stderr.write("File does not exist: %s\n" %((command[0]),))

        exit (1)

    process = subprocess.Popen( command, stdout=subprocess.PIPE, stderr=subprocess.PIPE )

    retcode = process.wait()

    ( stdout, stderr ) = process.communicate()

    return { "retcode" : retcode, "stdout" : stdout, "stderr" : stderr }

def getDevices (script):

    command = [script];

    result = runExternalScripts (command);

    if (result["retcode"] != 0):

        LOG.error ("Retcode: %s" %(result["retcode"],))

        LOG.error ("stdout: %s" %(result["stdout"],))

        LOG.error ("stderr: %s" %(result["stderr"],))

        sys.stderr.write("%s" %(result["stderr"],))

        exit (1)

    #print ("%s" %(result["stdout"],))

    # don't use print here, because of the extra newline

    sys.stdout.write ("%s" %(result["stdout"],))

def umountDevice (script, device):

    command = [script, device];

    result = runExternalScripts (command);

    if (result["retcode"] != 0):

        LOG.error ("Retcode: %s" %(result["retcode"],))

        LOG.error ("stdout: %s" %(result["stdout"],))

        LOG.error ("stderr: %s" %(result["stderr"],))

        sys.stderr.write("%s" %(result["stderr"],))

        exit (1)

    #print ("%s" %(result["stdout"],))

    # don't use print here, because of the extra newline

    sys.stdout.write ("%s" %(result["stdout"],))

def mountDevice (script, interface, port, device, mountpoint, keyfilepath):    

    listener = MyRestListener (opensecurity_urls, globals(), script = script, device = device, mountpoint = mountpoint, tries = 3, keyfilepath = keyfilepath)

    thread.start_new_thread(listener.run, (interface, port,))

    #command = [script, device, mountpoint, password];

    #result = runExternalScripts (command);

    close = False

    while (close == False):

        time.sleep(1)

        if (os.path.ismount(mountpoint) == True):

            close = True

            LOG.info ("Stick \"%s\" was mounted sucessfully to \"%s\"" %(device, mountpoint,))

            sys.exit(0)

        if (os.path.exists(device) == False):

            close = True

            LOG.error ("Stick \"%s\" removed -> exit" %(device,))

            sys.exit(1)

if __name__ == "__main__":

    parser = argparse.ArgumentParser(epilog='--mount, --umount and --initialize are mutually exclusive')

    group = parser.add_mutually_exclusive_group(required=True)

    group.add_argument('-m', '--mount', action='store', nargs=4, dest='mount', help='Mounts an encrypted device.', metavar=("interface", "port", "tcfile", "mountpoint"))

    group.add_argument('-u', '--umount', action='store', nargs=1, dest='umount', help='Unmounts an encrypted device', metavar="tcfile")

    group.add_argument('-i', '--initialize', action='store', nargs=4, dest='initialize', help='Initialize an device.', metavar=("interface", "port", "tcfile", "mountpoint"))

    group.add_argument('-g', '--getdevices', action='store_true', dest="getdevices", help='Returns a list of all mounted encrypted devices')

    arguments = parser.parse_args()

    config = loadConfig ()

    initLog (config)

    if (arguments.getdevices):

        getDevices (config.get ("Main", "GetDevicesScript"))

    if (arguments.umount):

        umountDevice (config.get ("Main", "UmountScript"), arguments.umount[0])

    if (arguments.mount):

        mountDevice (config.get ("Main", "MountScript"), arguments.mount[0], int(arguments.mount[1]), arguments.mount[2], arguments.mount[3], config.get ("Main", "Keyfile"))

    if (arguments.initialize):

        print ("Init: %s" %(arguments.initialize,))