from agent_util import Plugin
import logging
import os
import sys
import traceback
import tempfile
import tarfile
import zipfile
try:
    from hashlib import sha1
except:
    from sha import sha as sha1
try:
    # Python 2.x
    import urllib2
except:
    import urllib.request as urllib2
# In case of python 3
try:
    import ConfigParser as configparser
except:
    import configparser

def execfile3(filepath, globals=None, locals=None):
    if globals is None:
        globals = {}
    globals.update({
        "__file__": filepath,
        "__name__": "__main__",
    })
    f = open(filepath, 'rb')
    exec(compile(f.read(), filepath, 'exec'), globals, locals)
    f.close()


class PluginManager(object):
    def __init__(self, db, config_file, *directories):
        self.log = logging.getLogger(self.__class__.__name__)
        self.db = db
        self.config_file = config_file
        self.directories = directories
        self.plugins = self._load_plugins(directories)

        # Internal container for metadata so we can avoid repeatedly regenerating it
        self._metadata = None
        self._hashed_metadata = None

        # now we load all the plugin-specific configs and map them to
        # self.config
        self.config = {}
        if os.path.exists(self.config_file):
            config_file = configparser.ConfigParser()
            config_file.read(self.config_file)
            for textkey in config_file.sections():
                try: debug = config_file.get('agent', 'debug')
                except: debug = False
                self.config[textkey] = {'debug': debug}
                for k, v in config_file.items(textkey):
                    self.config[textkey][k] = v

    def add_dem_wifi_results(self, wifi_results):
        dem_config = self.config.get('dem', None)
        if dem_config:
            dem_config['wifi_results'] = wifi_results

    def install_remote_plugins(self, url):
        """
        Grab the remote url and extract the contents, putting them in the
        appropiate plugin folder.
        """
        base_custom_plugin_dir = self.directories[-1]
        f = tempfile.NamedTemporaryFile(delete=False)
        num_installed = 0
        ext = url.split(".")[-1]
        fname = url.split("/")[-1]
        try:
            r = urllib2.urlopen(url)
            if "content-disposition" in r.info():
                ext = r.info().getheader("content-disposition").split(".")[-1]
            f.write(r.read())
            f.close()
        except Exception:
            self.log.error("Unable to download URL: %s" % traceback.format_exc())
            return

        if ext in ("tar", "tgz"):
            try:
                t = tarfile.open(f.name)
                for file in t.getnames():
                    if file.endswith(".py"):
                        self.log.info("  Installing plugin %s" % file)
                        t.extract(file, base_custom_plugin_dir)
                        num_installed += 1
            except Exception:
                self.log.error("Unable to extract tar contents: %s" % traceback.format_exc())
        elif ext == "zip":
            try:
                z = zipfile.ZipFile(f.name)
                for file in z.namelist():
                    if file.endswith(".py"):
                        self.log.info("  Installing plugin %s" % file)
                        z.extract(file, base_custom_plugin_dir)
                        num_installed += 1
            except Exception:
                self.log.error("Unable to extract zip contents: %s" % traceback.format_exc())
        elif ext == "py":
            self.log.info("  Installing plugin %s" % fname)
            os.system("cp %s %s" % (f.name, os.path.join(base_custom_plugin_dir, fname)))
            num_installed += 1
        else:
            self.log.error("Unable to install Agent Plugin, unknown extension: %s" % ext)

        if num_installed:
            self.log.info("\nInstalled %s Agent plugins" % num_installed)

        os.system("rm -f %s" % f.name)

    # run a specific plugin
    def check(self, schedule):
        try:
            self_key = self.config.get('agent', {}).get('server_key')
            container = None
            if getattr(schedule, 'server_key', None) and schedule.server_key != self_key:
                container_id = schedule.server_key.split(":")[-1]
                try:
                    container = self.db["docker_containers"][container_id]
                except:
                    if schedule.plugin_textkey == "docker" \
                            and schedule.resource_textkey == "status.running":
                        # Special handling of "container is running" metrics.
                        # Pass in a phony value to treat it as gone.
                        container = {"State": "deleted"}
                    else:
                        self.log.error("Could not find container with id %s", container_id)
                        return None

            plugin = self.plugins[schedule.plugin_textkey](schedule)
            config = self.config.get(schedule.plugin_textkey, {})

            scale = config.get('scale', 1.0)

            if container:
                value = plugin.check_docker(container, schedule.resource_textkey, schedule.option, config)
            else:
                value = plugin.check(schedule.resource_textkey, schedule.option, config)
            
            if value is not None: value *= scale

        except Exception:
            self.log.exception(
                '%s/%s check failed: %s' % 
                (schedule.plugin_textkey, schedule.resource_textkey, traceback.format_exc())
            )
            return None

        return value

    def _load_plugins(self, directories):
        plugins = {}
        plugin_blacklist = ''

        if os.path.exists(self.config_file):
            config_file = configparser.ConfigParser()
            config_file.read(self.config_file)

            try:
                plugin_blacklist = config_file.get('agent', 'plugin_blacklist')
            except:
                plugin_blacklist = ''

            if plugin_blacklist:
                plugin_blacklist = list(map(str.strip, plugin_blacklist.split(',')))

        def plugin_file_checker():
            for plugin_dir in directories:
                self.log.info('Looking in directory %r', plugin_dir)
                for name in os.listdir(plugin_dir):
                    try:
                        if name[-3:] != '.py' or name == '__init__.py':
                            continue

                        plugin_file = os.path.join(plugin_dir, name)

                        # We've registed sys.modules['agent'] to equal THIS
                        # module, so this exec has the effect of 'importing' the
                        # plugin, and resolving 'import agent' to import this
                        # module. This is so we never have to change the plugins
                        # in order to whitelabel.
                        f_globals = {}
                        f_locals = {}
                        if sys.version_info[0] == 3:
                            execfile3(plugin_file, f_globals, f_globals)
                        else:
                            execfile(plugin_file, f_globals, f_globals)

                        for obj in list(f_globals.values()):
                            yield obj
                        self.log.debug('Loaded %r', plugin_file)

                    except Exception:
                        t, e = sys.exc_info()[:2]
                        self.log.info('Error importing plugin %s, skipping',
                                           name)
                        self.log.debug(e)
                        continue
                self.log.info('Loaded %d plugins', len(plugins))

        for obj in plugin_file_checker():
            if isinstance(obj, type):
                if issubclass(obj, Plugin) and hasattr(obj, 'textkey') and obj.textkey not in plugin_blacklist:
                    if obj.textkey != "TEMPLATE_PLUGIN":
                        plugins[obj.textkey] = obj

        return plugins

    # returns all the values needed to describe the plugins and their resources
    # in a json-serializable way.  Uses local cache of values to avoid recomputing.
    @property
    def metadata(self):
        if self._metadata == None:
            # We haven't previously built the metadata - go do that and cache for later
            metadata = {}
            for plugin in list(self.plugins.values()):
                # get the config and push it up with the metadata
                config = self.config.get(plugin.textkey, {})
                try:
                    meta = format_metadata(plugin.get_metadata(config))
                except:
                    self.log.exception('error getting metadata from %r', plugin.textkey)
                    continue
                self.log.info('got %d textkeys for %r', len(list(meta.keys())), plugin.textkey)
                label = getattr(plugin, 'label', plugin.textkey)
                metadata[plugin.textkey] = (label, meta)

            self._metadata = metadata

        return self._metadata

    # returns the metadata hash, used for comparing whether or not our metadata
    # has changed since we last pushed.  Uses local cache of values to avoid recomputing.
    def hashed_metadata(self):
        if self._hashed_metadata == None:
            flat_data = []

            for textkey, (label, plugin_metadata) in list(self.metadata.items()):
                plugin_options = []
                for resource_name, resource_metadata in list(plugin_metadata.items()):
                    resource_meta = sorted(repr(resource_metadata))
                    plugin_options.append(repr((resource_name, resource_metadata)))

                plugin_options.sort()
                flat_data.append(repr((textkey, plugin_options, label)))

            flat_data.sort()
            self._hashed_metadata = sha1(repr(flat_data).encode()).hexdigest()

        return self._hashed_metadata

    def is_metadata_stale(self):
        self.log.info('comparing metadata hashes %r with %r',
                      self.hashed_metadata(), self.db['last_metadata'])
        return self.db['last_metadata'] != self.hashed_metadata()


def format_metadata(metadata):
    """
    Go over the metadata entry and make sure the option resources
    are matching to the new style of dictionaries if they
    are a string.
    """
    for resource, entry in metadata.items():
        options = entry['options']
        new_options = []
        if not options:
            continue
        for option in options:
            if sys.version_info[0] == 3:
                if type(option) == str:  # TODO Verify that unicode is present on old python installs.
                    new_options.append({'resource': option})
            else:
                if type(option) in (str, unicode):  # TODO Verify that unicode is present on old python installs.
                    new_options.append({'resource': option})

        if new_options:
            entry['options'] = new_options
        if not entry.get('options_schema'):
            entry['options_schema'] = {'resource': 'string'}
    return metadata