#!/usr/bin/python

# -----------------------------------------------------------------------
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
# -----------------------------------------------------------------------

import os
import sys
import string
import subprocess
import re
import zipfile
import platform

class DuccPropertiesException(Exception):
    def __init__(self, msg):
        self.msg = msg

    def __str__(self):
        return repr(self.msg)

class DuccProperties:
    def __init__(self):
        self.props = {}

    #
    # Expand all ${} values from env or from this properties file itself
    # The search order is:
    #    1 look in this properties file
    #    2 look in the environment
    #
    def do_subst(self, st):
        key = None
        p = re.compile("\\$\\{[a-zA-Z0-9_\\.\\-]+\\}")
        ndx = 0
        response = st.strip()
        m = p.search(response, ndx)    
        while ( m != None ):
            key = m.group()[2:-1]
            
            val = None
            if ( self.has_key(key) ):
                val = self.get(key)

            if ( val != None ):    
                response = string.replace(response, m.group() , val)
            ndx = m.start()+1
            m = p.search(response, ndx)
        
        return response

    def mkitem(self, line):
        ndx = line.find('#')   # remove comments - like the java DuccProperties
        if ( ndx >= 0 ):
            line = line[0:ndx]     # strip the comment
        ndx = line.find('//')   # remove comments - like the java DuccProperties
        if ( ndx >= 0 ):
            line = line[0:ndx]     # strip the comment
        line = line.strip()    # clear leading and trailing whitespace
        if ( line == '' ):     # empty line?
            return

        mobj = re.search('[ =:]+', line)
        if ( mobj ):
            key = line[:mobj.start()].strip()
            val = line[mobj.end():].strip()
            #print 'NEXT', mobj.start(), 'END', mobj.end(), 'KEY', key, 'VAL', val
            # val = self.do_subst(val)   # we'll do lazy subst on get instead
            self.props[key] = val
        else:
            self.props[line] = None

    #
    # Load reads a properties file and adds it contents to the
    # hash.  It may be called several times; each call updates
    # the internal has, thus building it up.  The input file is
    # in the form of a java-like properties file.
    #
    def load(self, propsfile, ducchome=None):
        if ( not os.path.exists(propsfile) ):
            raise DuccPropertiesException(propsfile +  ' does not exist and cannot be loaded.')

        if (ducchome != None):
            self.props['DUCC_HOME'] = ducchome
        f = open(propsfile);
        for line in f:
            self.mkitem(line.strip())
        f.close()

    def load_from_manifest(self, jarfile):
        z = zipfile.ZipFile(jarfile)
        items = z.read('META-INF/MANIFEST.MF').split('\n')
        for item in items:
            self.mkitem(item)

    #
    # Try to load a properties file.  Just be silent if it doesn't exist.
    #
    def load_if_exists(self, propsfile):
        if ( os.path.exists(propsfile) ):
            return self.load(propsfile)
        
    #
    # Put something into the hash.
    #
    def put(self, key, value):
        self.props[key] = value

    #
    # Get something from the hash.
    #
    def get(self, key):
        if ( self.props.has_key(key) ):
            return self.do_subst(self.props[key])   # we'll do lazy subst on get instead
        return None

    #
    # Remove an item if it exists
    #
    def delete(self, key):
        if ( self.props.has_key(key) ):
            del self.props[key]
    #
    # Write the has as a Java-like properties file
    #
    def write(self, propsfile):
        f = open(propsfile, 'w')
        items = self.props.items()
        for (k, v) in items:
            #print 'WRITING', k, '=', v
            f.write(k + ' = ' + str(v) + '\n')
        f.close()

    #
    # return a shallow copy of the dictionary
    #
    def copy_dictionary(self):
        return self.props.copy()

    #
    # return the entries in the dictionary
    #
    def items(self):
        return self.props.items()

    #
    # check to see if the key exists in the dictionary
    #
    def has_key(self, key):
        return self.props.has_key(key)

    #
    # Return the length of the dictionary
    #
    def __len__(self):
        return len(self.props)
    
class DuccBase:


    def read_properties(self):

        self.ducc_properties = DuccProperties()
        self.ducc_properties.load(self.propsfile, self.DUCC_HOME)

        self.webserver_node = self.ducc_properties.get('ducc.ws.node')
        self.jvm            = self.ducc_properties.get('ducc.jvm')

    def java(self):
        return self.jvm
        
    def java_home(self):
        if ( os.environ.has_key('DUCC_POST_INSTALL') ):
            return 'JAVA_HOME'   # avoid npe during first-time setup

        if ( self.system == 'Darwin' ):
            self.jvm_home = "/Library/Java/Home"
        else:
            ndx = self.jvm.rindex('/')
            ndx = self.jvm.rindex('/', 0, ndx)
            self.jvm_home = self.jvm[:ndx]

        return self.jvm_home
        
    def version(self):
        lines = self.popen(self.jvm, ' org.apache.uima.ducc.utils.Version')
        line = lines.readline().strip()
        return "DUCC Version", line
        
    # simply spawn-and-forget using Python preferred mechanism
    def spawn(self, *CMD):
        cmd = ' '.join(CMD)
        # print '**** spawn', cmd, '****'
        ducc = subprocess.Popen(cmd, shell=True)
        pid = ducc.pid
        try:
            status = os.waitpid(pid, 0)
        except KeyboardInterrupt:
            print 'KeyboardInterrupt'
        except:
            print "Unexpected exception: ", sys.exc_info()[0]
        return pid

    def popen(self, *CMD):
        cmd = ' '.join(CMD)
        #print 'POPEN:', cmd
        proc = subprocess.Popen(cmd, bufsize=0, stdout=subprocess.PIPE, shell=True, stderr=subprocess.STDOUT)
        return proc.stdout

    def format_classpath(self, cp):
        strings = cp.split(':')
        for s in strings:
            print s

    def set_classpath(self):
        ducc_home = self.DUCC_HOME
        LIB       = ducc_home + '/lib'
        
        CLASSPATH = LIB + '/ducc-submit.jar'
        os.environ['CLASSPATH'] = CLASSPATH

    def which(self, file):
        for p in os.environ["PATH"].split(":"):
            if os.path.exists(p + "/" + file):
                return p + "/" + file            
        return None

    def mkargs(self, args):
        '''
            The cli needs to insure all args are fully quoted so the shell doesn't
            lose the proper tokenization.  This quotes everything.
        '''
        answer = []
        for a in args:
            arg = '"' + a + '"'
            answer.append(arg)
        return answer

    def __init__(self):

        # Infer DUCC_HOME from our location - no longer use a (possibly inaccurate) environment variable
        me = os.path.abspath(__file__)    
        ndx = me.rindex('/')
        ndx = me.rindex('/', 0, ndx)
        self.DUCC_HOME = me[:ndx]          # split from 0 to ndx

        self.system = platform.system()
        self.jvm = None
        self.webserver_node = 'localhost'
        self.propsfile = self.DUCC_HOME + '/resources/ducc.properties'
        self.localhost = os.uname()[1]                
        self.read_properties()       

        os.environ['JAVA_HOME'] = self.java_home()

        self.set_classpath()

if __name__ == "__main__":
    base = DuccBase()