#!/usr/bin/env python
# ***** BEGIN LICENSE BLOCK *****
# Version: MPL 1.1/GPL 2.0/LGPL 2.1
# 
# The contents of this file are subject to the Mozilla Public License
# Version 1.1 (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.mozilla.org/MPL/
# 
# Software distributed under the License is distributed on an "AS IS"
# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
# License for the specific language governing rights and limitations
# under the License.
# 
# The Original Code is Komodo code.
# 
# The Initial Developer of the Original Code is ActiveState Software Inc.
# Portions created by ActiveState Software Inc are Copyright (C) 2000-2007
# ActiveState Software Inc. All Rights Reserved.
# 
# Contributor(s):
#   ActiveState Software Inc
# 
# Alternatively, the contents of this file may be used under the terms of
# either the GNU General Public License Version 2 or later (the "GPL"), or
# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
# in which case the provisions of the GPL or the LGPL are applicable instead
# of those above. If you wish to allow use of your version of this file only
# under the terms of either the GPL or the LGPL, and not to allow others to
# use your version of this file under the terms of the MPL, indicate your
# decision by deleting the provisions above and replace them with the notice
# and other provisions required by the GPL or the LGPL. If you do not delete
# the provisions above, a recipient may use your version of this file under
# the terms of any one of the MPL, the GPL or the LGPL.
# 
# ***** END LICENSE BLOCK *****

import os
import sys
import types
import threading
import Queue
import logging
import which
from xpcom import components, nsError, ServerException, COMException
from xpcom._xpcom import PROXY_SYNC, PROXY_ALWAYS, PROXY_ASYNC, getProxyForObject
from xpcom.server import WrapObject, UnwrapObject
import koprocessutils


log = logging.getLogger('koFeatureStatusService')
##log.setLevel(logging.DEBUG)


#---- component implementation

class KoFeatureStatus:
    _com_interfaces_ = [components.interfaces.koIFeatureStatus]
    _reg_clsid_ = "{62DA2673-1653-4CC6-9A06-8FDBFE39F025}"
    _reg_contractid_ = "@activestate.com/koFeatureStatus;1"
    _reg_desc_ = "The status of a particular Komodo feature."

    def __init__(self, featureName, status, reason=None):
        self.featureName = featureName
        self.status = status
        self.reason = reason


class KoFeatureStatusService:
    """Listen for a "feature_status_request" notifications to initiate
    status retrieval in a separate thread and then return the result in
    a "feature_status_result".
    
    Currently this is used exclusively by Komodo's Start Page.
    
    Implementation Notes:
        This service currently will startup a background thread only when
        necessary to avoid having a thread always sitting there to
        gather data that is very infrequently gathered. This thread is
        smart enough to keep going if requests for status on multiple
        features come in in quick succession.
        
        This setup makes the code a little bit more complex than it would
        be with just a single long running thread.
    """
    _com_interfaces_ = [components.interfaces.koIFeatureStatusService,
                        components.interfaces.nsIObserver]
    _reg_clsid_ = "{46A0BD16-D67C-4DCD-AE19-5C9CECB6A669}"
    _reg_contractid_ = "@activestate.com/koFeatureStatusService;1"
    _reg_desc_ = "Give functional status info for features in Komodo."

    def __init__(self):
        self._fsLock = threading.Lock()
        # A queue of feature names for which the status has been requested.
        self._fsQueue = Queue.Queue()
        # A thread to gather the status of the features named in the Queue.
        self._fsThread = None
        self._fsThreadExiting = threading.Event()

        # Get a schwack of services and components and proxy them all.
        self._observerSvc = components.classes["@mozilla.org/observer-service;1"].\
            getService(components.interfaces.nsIObserverService)
        self._observerProxy = getProxyForObject(1,
                                components.interfaces.nsIObserverService,
                                self._observerSvc,
                                PROXY_ALWAYS | PROXY_ASYNC)

        self._lastErrorSvc = components.classes["@activestate.com/koLastErrorService;1"].\
            getService(components.interfaces.koILastErrorService)
        self._lastErrorProxy = getProxyForObject(1,
                                components.interfaces.koILastErrorService,
                                self._lastErrorSvc,
                                PROXY_ALWAYS | PROXY_SYNC)

        self._prefSvc = components.classes["@activestate.com/koPrefService;1"].\
            getService(components.interfaces.koIPrefService)
        self._prefProxy = getProxyForObject(1,
                                components.interfaces.koIPrefService,
                                self._prefSvc,
                                PROXY_ALWAYS | PROXY_SYNC)

        self._perlInfoEx = components.classes["@activestate.com/koAppInfoEx?app=Perl;1"].\
            createInstance(components.interfaces.koIAppInfoEx)
        self._phpInfoEx = components.classes["@activestate.com/koAppInfoEx?app=PHP;1"].\
            createInstance(components.interfaces.koIAppInfoEx)
        self._pythonInfoEx = components.classes["@activestate.com/koAppInfoEx?app=Python;1"].\
            getService(components.interfaces.koIAppInfoEx)
        self._python3InfoEx = components.classes["@activestate.com/koAppInfoEx?app=Python3;1"].\
            getService(components.interfaces.koIAppInfoEx)
        self._rubyInfoEx = components.classes["@activestate.com/koAppInfoEx?app=Ruby;1"].\
            createInstance(components.interfaces.koIAppInfoEx)

        self._userPath = koprocessutils.getUserEnv()["PATH"].split(os.pathsep)

        self._observer = WrapObject(self, components.interfaces.nsIObserver)
        self._observerSvc.addObserver(self._observer, 'xpcom-shutdown', 1)
        self._observerSvc.addObserver(self._observer, "feature_status_request",0)
        self._ignoreExceptions = 0

    def finalize(self):
        log.info("finalize")
        try:
            self._observerProxy.removeObserver(self, "feature_status_request")
        except:
            log.error("Unable to remove observer feature_status_request")
        # Would like to .join() on the acquirer thread but that results
        # in deadlock because while the main thread is waiting on the
        # join the proxied services being used in the acquirer thread
        # are trying to use the main thread. Sol'n: just let the
        # acquirer thread run its course but tell it to ignore
        # exceptions.
        self._ignoreExceptions = 1
        # XXX Would like to make self._fsQueue a priority Queue and
        #     insert a high priority __exit__ directive on finalize.
        #     No need to process remaining requests.

    def observe(self, dummy, topic, featureName):
        if topic == "feature_status_request":
            log.info("request status of feature '%s'", featureName)
            # Queue up that feature name.
            self._fsQueue.put(featureName)
            # Start up the background thread if there is not already one
            # running.
            self._fsLock.acquire()
            if self._fsThread is None:
                self._fsThread = threading.Thread(target=self._fsAcquirer)
                self._fsThreadExiting.clear()
                self._fsThread.start()
            elif self._fsThreadExiting.isSet():
                self._fsThread.join()
                self._fsThread = threading.Thread(target=self._fsAcquirer)
                self._fsThreadExiting.clear()
                self._fsThread.start()
            self._fsLock.release()
        elif topic == "xpcom-shutdown":
            self.finalize()
        else:
            errmsg = "Unexpected nsIObserver topic: '%s'" % topic
            log.error(errmsg)
            raise ServerException(nsError.NS_ERROR_UNEXPECTED)

    def _fsAcquirer(self):
        """Acquire status for all the features named in self._fsQueue and
        send notifications with the results until the queue is empty.
        """
        log.info("start feature status acquirer thread")
        while 1:
            self._fsLock.acquire()
            try:
                try:
                    featureName = self._fsQueue.get_nowait()
                except Queue.Empty:
                    log.info("status acquirer thread exiting")
                    self._fsThreadExiting.set()
                    break
            finally:
                self._fsLock.release()
                
            try:
                status = "Status Unknown"
                reason = None
                if featureName == "Perl Syntax Checking":
                    if self._haveSufficientPerl():
                        status = "Ready"
                    else:
                        status = "Not Functional"
                        reason = self._lastErrorProxy.getLastErrorMessage()
                elif featureName == "PHP Syntax Checking":
                    if self._haveSufficientPHP(minVersion="4.0.5"):
                        status = "Ready"
                    else:
                        status = "Not Functional"
                        reason = self._lastErrorProxy.getLastErrorMessage()
                elif featureName == "Python Syntax Checking":
                    if self._haveSufficientPython():
                        status = "Ready"
                    else:
                        status = "Not Functional"
                        reason = self._lastErrorProxy.getLastErrorMessage()
                elif featureName == "Python3 Syntax Checking":
                    if self._haveSufficientPython3():
                        status = "Ready"
                    else:
                        status = "Not Functional"
                        reason = self._lastErrorProxy.getLastErrorMessage()
                elif featureName == "Ruby Syntax Checking":
                    if self._haveSufficientRuby():
                        status = "Ready"
                    else:
                        status = "Not Functional"
                        reason = self._lastErrorProxy.getLastErrorMessage()

                else:
                    errmsg = "Unexpected feature name: %s" % featureName
                    log.error(errmsg)
                    raise ServerException(nsError.NS_ERROR_UNEXPECTED, errmsg)
                
                log.info("status of %r feature: %s (%s)", featureName, status,
                         reason)
                st = KoFeatureStatus(featureName, status, reason)
                try:
                    self._observerProxy.notifyObservers(st, "feature_status_ready",
                                                        featureName)
                except COMException, ex:
                    # do nothing: Notify sometimes raises an exception if
                    # receivers are not registered?
                    log.warn("exception notifying 'feature_status_ready': %s", ex)
                    pass
            except:
                if not self._ignoreExceptions:
                    raise

    def _isSufficientPerl(self, perlInfoEx, minVersion=None,
                          isActivePerl=None, minActivePerlBuild=None,
                          haveModules=[]):
        """Return true iff the given perl installation meets the given
        criteria.
            "perlInfoEx" is a koPerlInfoEx instance loaded with the perl
                installation to check.

        If false is returned, then the last error (see koILastErrorService)
        is set with a reason why.
        """
        installDir = perlInfoEx.installationPath
        exePath = perlInfoEx.executablePath
        log.info("%s: is sufficient perl?", installDir)

        if not os.path.exists(exePath):
            log.info("%s: does not exist", exePath)
            self._lastErrorProxy.setLastError(0,
                "Perl installation does not exist: \"%s\"" % exePath)
            return 0
        else:
            log.info("%s: exists", exePath)

        if minVersion is not None:
            try:
                version = perlInfoEx.version
            except COMException:
                log.info("%s: couldn't get version", installDir)
                self._lastErrorProxy.setLastError(0,
                    "Could not determine Perl version: %s. " % installDir)
                return 0
            else:
                if version < minVersion:
                    log.info("%s: %s < %s", installDir, version, minVersion)
                    self._lastErrorProxy.setLastError(0,
                        "Insufficient Perl version (\"%s\" is version %s). "\
                        "Require at least version %s."\
                        % (installDir, version, minVersion))
                    return 0
                else:
                    log.info("%s: %s >= %s", installDir, version, minVersion)
        
        buildNumber = None
        if isActivePerl is not None or minActivePerlBuild is not None:
            try:
                buildNumber = perlInfoEx.buildNumber
            except COMException, ex:
                log.info("%s: not ActivePerl", installDir)
                self._lastErrorProxy.setLastError(0,
                    "Perl installation is not ActivePerl: %s" % installDir)
                return 0
            else:
                log.info("%s: is ActivePerl", installDir)

        if minActivePerlBuild is not None:
            if buildNumber is None:
                log.info("%s: couldn't determine ActivePerl build number",
                         installDir)
                self._lastErrorProxy.setLastError(0,
                    "Could not determine ActivePerl build number: %s"\
                    % installDir)
                return 0
            elif buildNumber < minActivePerlBuild:
                log.info("%s: build %s < build %s", installDir, buildNumber,
                         minActivePerlBuild)
                self._lastErrorProxy.setLastError(0,
                    "Insufficient ActivePerl build (\"%s\" is build %s). "\
                    "Require at least version %s."\
                    % (installDir, buildNumber, minActivePerlBuild))
                return 0
            else:
                log.info("%s: build %s >= build %s", installDir, buildNumber,
                         minActivePerlBuild)

        if haveModules:
            if not perlInfoEx.haveModules(haveModules):
                log.info("%s: does not have all of the following modules: %r",
                         installDir, haveModules)
                self._lastErrorProxy.setLastError(0,
                    "Perl installation at '%s' does not have all of the "\
                    "following modules: %s"\
                    % (installDir, ','.join(haveModules)))
                return 0
            else:
                log.info("%s: has required modules: %r", installDir,
                         haveModules)

        return 1

    def _haveSufficientPerl(self, stopOnFirst=1, minVersion=None,
                            isActivePerl=None, minActivePerlBuild=None,
                            haveModules=[]):
        """Return true iff a Perl installation meeting the above conditions
        can be found.
            "stopOnFirst" is a boolean indicating if the search should stop
                on the "first" found interpreter. This is because things like
                syntax checking are just going to use this
                one anyway. Default is true.

        If false is returned, then the last error (see koILastErrorService)
        is set with a reason why.
        """
        # Try the user's selected perl interpreter.
        perlDefaultInterp = self._prefProxy.prefs.getStringPref("perlDefaultInterpreter")
        if perlDefaultInterp:
            self._perlInfoEx.installationPath =\
                self._perlInfoEx.getInstallationPathFromBinary(perlDefaultInterp)
            if self._isSufficientPerl(self._perlInfoEx, minVersion,
                                      isActivePerl, minActivePerlBuild,
                                      haveModules):
                return 1
            elif stopOnFirst:
                return 0
            
        # Look on PATH.
        if sys.platform.startswith('win'):
            exts = ['.exe']
        else:
            exts = None
        perls = which.whichall('perl', exts=exts, path=self._userPath)
        for perl in perls:
            self._perlInfoEx.installationPath =\
                self._perlInfoEx.getInstallationPathFromBinary(perl)
            if self._isSufficientPerl(self._perlInfoEx, minVersion,
                                      isActivePerl, minActivePerlBuild,
                                      haveModules):
                return 1
            elif stopOnFirst:
                return 0
        
        errmsg = "Could not find a suitable Perl installation."
        self._lastErrorProxy.setLastError(0, errmsg)
        return 0

    def _isSufficientPHP(self, phpInfoEx, minVersion=None):
        """Return true iff the given php installation meets the given
        criteria.
            "phpInfoEx" is a koPHPInfoEx instance loaded with the
                php installation to check.

        If false is returned, then the last error (see koILastErrorService)
        is set with a reason why.
        """
        installDir = phpInfoEx.installationPath
        exePath = phpInfoEx.executablePath
        log.info("%s: is sufficient php?", installDir)
        
        if not os.path.exists(exePath):
            log.info("%s: does not exist", exePath)
            self._lastErrorProxy.setLastError(0,
                "PHP installation does not exist: \"%s\"" % exePath)
            return 0
        else:
            log.info("%s: exists", exePath)

        if minVersion is not None:
            version = phpInfoEx.version
            if version < minVersion:
                log.info("%s: %s < %s", installDir, version, minVersion)
                self._lastErrorProxy.setLastError(0,
                    "Insufficient PHP version (\"%s\" is version %s). "\
                    "Require at least version %s."\
                    % (installDir, version, minVersion))
                return 0
            else:
                log.info("%s: %s >= %s", installDir, version, minVersion)
        
        return 1

    def _haveSufficientPHP(self, stopOnFirst=1, minVersion=None):
        """Return true iff a PHP installation meeting the above conditions
        can be found.
            "stopOnFirst" is a boolean indicating if the search should stop
                on the "first" found interpreter. This is because things like
                syntax checking are just going to use this
                one anyway. Default is true.

        If false is returned, then the last error (see koILastErrorService)
        is set with a reason why.
        """
        # Try the user's selected php interpreter.
        phpDefaultInterp = self._prefProxy.prefs.getStringPref("phpDefaultInterpreter")
        if phpDefaultInterp:
            self._phpInfoEx.installationPath =\
                self._phpInfoEx.getInstallationPathFromBinary(phpDefaultInterp)
            if self._isSufficientPHP(self._phpInfoEx, minVersion):
                return 1
            elif stopOnFirst:
                return 0
            
        # Look on PATH.
        if sys.platform.startswith('win'):
            exts = ['.exe']
        else:
            exts = None
        phps = which.whichall('php', exts=exts, path=self._userPath) + \
               which.whichall('php-cgi', exts=exts, path=self._userPath) + \
               which.whichall('php4', exts=exts, path=self._userPath) + \
               which.whichall('php-cli', exts=exts, path=self._userPath)
        for php in phps:
            self._phpInfoEx.installationPath =\
                self._phpInfoEx.getInstallationPathFromBinary(php)
            if self._isSufficientPHP(self._phpInfoEx, minVersion):
                return 1
            elif stopOnFirst:
                return 0
        
        errmsg = "Could not find a suitable PHP installation."
        self._lastErrorProxy.setLastError(0, errmsg)
        return 0

    def _haveSufficientPython(self, stopOnFirst=1, minVersion=None):
        """Return true iff a Python installation meeting the above conditions
        can be found.
            "stopOnFirst" is a boolean indicating if the search should stop
                on the "first" found interpreter. This is because things like
                syntax checking are just going to use this
                one anyway. Default is true.

        If false is returned, then the last error (see koILastErrorService)
        is set with a reason why.
        """
        # Try the user's selected python interpreter.
        if self._pythonInfoEx.executablePath:
            return 1
        errmsg = "Could not find a suitable Python installation."
        self._lastErrorProxy.setLastError(0, errmsg)
        return 0

    def _haveSufficientPython3(self, stopOnFirst=1, minVersion=None):
        """Return true iff a Python3 installation meeting the above conditions
        can be found.

        If false is returned, then the last error (see koILastErrorService)
        is set with a reason why.
        """
        # Try the user's selected python3 interpreter.
        if self._python3InfoEx.executablePath:
            return 1
        errmsg = "Could not find a suitable Python3 installation."
        self._lastErrorProxy.setLastError(0, errmsg)
        return 0

    def _isSufficientRuby(self, rubyInfoEx, minVersion=None):
        """Return true iff the given ruby installation meets the given
        criteria.
            "rubyInfoEx" is a koRubyInfoEx instance loaded with the
                ruby installation to check.

        If false is returned, then the last error (see koILastErrorService)
        is set with a reason why.
        """
        installDir = rubyInfoEx.installationPath
        exePath = rubyInfoEx.executablePath
        log.info("%s: is sufficient ruby?", installDir)
        
        if not os.path.exists(exePath):
            log.info("%s: does not exist", exePath)
            self._lastErrorProxy.setLastError(0,
                "Ruby installation does not exist: \"%s\"" % exePath)
            return 0
        else:
            log.info("%s: exists", exePath)

        if minVersion is not None:
            version = rubyInfoEx.version
            try:
                versionToCompare = map(int, version.split('.'))
                minVersionToCompare = map(int, minVersion.split('.'))
            except ValueError:
                log.warn("couldn't process Ruby version as expected for "
                         "comparison: version check may be inaccurate: "
                         "version=%r, minVersion=%r", version, minVersion)
                versionToCompare = version
                minVersionToCompare = minVersion
            if versionToCompare < minVersionToCompare:
                log.info("%s: %s < %s", exePath, version, minVersion)
                self._lastErrorProxy.setLastError(0,
                    "Insufficient Ruby version: require version >=%s, "
                    "'%s' is %s" % (minVersion, exePath, version))
                return 0
            else:
                log.info("%s: %s >= %s", installDir, version, minVersion)
        
        return 1

    def _haveSufficientRuby(self, stopOnFirst=1, minVersion=None):
        """Return true iff a Ruby installation meeting the above conditions
        can be found.
            "stopOnFirst" is a boolean indicating if the search should stop
                on the "first" found interpreter. This is because things like
                syntax checking are just going to use this
                one anyway. Default is true.

        If false is returned, then the last error (see koILastErrorService)
        is set with a reason why.
        """
        # Try the user's selected ruby interpreter.
        rubyDefaultInterp = self._prefProxy.prefs.getStringPref("rubyDefaultInterpreter")
        if rubyDefaultInterp:
            self._rubyInfoEx.installationPath =\
                self._rubyInfoEx.getInstallationPathFromBinary(rubyDefaultInterp)
            if self._isSufficientRuby(self._rubyInfoEx, minVersion):
                return 1
            elif stopOnFirst:
                return 0
            
        # Look on PATH.
        if sys.platform.startswith('win'):
            exts = ['.exe']
        else:
            exts = None
        rubys = which.whichall('ruby', exts=exts, path=self._userPath)
        for ruby in rubys:
            self._rubyInfoEx.installationPath =\
                self._rubyInfoEx.getInstallationPathFromBinary(ruby)
            if self._isSufficientRuby(self._rubyInfoEx, minVersion):
                return 1
            elif stopOnFirst:
                return 0
        
        errmsg = "Could not find a suitable Ruby installation."
        self._lastErrorProxy.setLastError(0, errmsg)
        return 0

