#!/usr/bin/env

__author__ = "Gustavo Sverzut Barbieri / Artur Duque de Souza"

__author_email__ = "barbieri@gmail.com / artur.souza@indt.org.br"

__license__ = "GPL"

__version__ = "0.3"

import os

import stat

import sys

import logging

import urllib

import gobject

import imp

log = logging.getLogger("gms.utils")

__all__ = ("which", "load_plugins", "PluginSet", "getHTML",

           "progress_bar", "create_tid", "list_media_files")

def which(app):

    """Function to implement which(1) unix command"""

    pl = os.environ["PATH"].split(os.pathsep)

    for p in pl:

        path = os.path.join(p, app)

        if os.path.isfile(path):

            st = os.stat(path)

            if st[stat.ST_MODE] & 0111:

                return path

    return ""

# which()

def _load_module(pathlist, name):

    fp, path, desc = imp.find_module(name, pathlist)

    try:

        module = imp.load_module(name, fp, path, desc)

        return module

    finally:

        if fp:

            fp.close()

# _load_module()

class PluginSet(object):

    def __init__(self, basetype, *items):

        self.basetype = basetype

        self.map = {}

        self.list = []

        for i in items:

            self._add(i)

        self._sort()

    # __init__()

    def _add(self, item):

        self.map[item.name] = item

        self.list.append(item)

    # _add()

    def add(self, item):

        self._add()

        self._sort()

    # add()

    def __getitem__(self, spec):

        if isinstance(spec, basestring):

            return self.map[spec]

        else:

            return self.list[spec]

    # __getitem__()

    def get(self, name, default=None):

        return self.map.get(name, default)

    # get()

    def __iter__(self):

        return self.list.__iter__()

    # __iter__()

    def __len__(self):

        return len(self.list)

    # __len__()

    def _sort(self):

        self.list.sort(lambda a, b: cmp(a.priority, b.priority))

    # _sort()

    def update(self, pluginset):

        self.map.update(pluginset.map)

        self.list.extend(pluginset.list)

        self._sort()

    # update()

    def load_from_directory(self, directory):

        for i in load_plugins(directory, self.basetype):

            self._add(i)

        self._sort()

    # load_from_directory()

    def __str__(self):

        lst = []

        for o in self.list:

            lst.append('"%s" (%s)' % (o.name, o.__name__))

        return "%s(basetype=%s, items=[%s])" % \

               (self.__class__.__name__,

                self.basetype.__name__,

                ", ".join(lst))

    # __str__()

# PluginSet

def load_plugins(directory, basetype):

    """Function to load plugins from a given directory"""

    tn = basetype.__name__

    log.debug("Loading plugins from %s, type=%s" % (directory, tn))

    plugins = []

    for d in os.listdir(directory):

        if not d.endswith(".py"):

            continue

        name = d[0: -3]

        if name == "__init__":

            continue

        directory.replace(os.path.sep, ".")

        mod = _load_module([directory], name)

        for sym in dir(mod):

            cls = getattr(mod, sym)

            if isinstance(cls, type) and issubclass(cls, basetype) and \

                cls != basetype:

                plugins.append(cls)

                log.info("Loaded %s (%s) from %s" % \

                         (cls.__name__, tn, os.path.join(directory, d)))

    return plugins

# load_plugins()

def getHTML(html_file, params={}):

    """This function parses an html file with the given

    parameters and returns a formated web-page"""

    try:

        filename = os.path.join(sys.path[0], "html", html_file + ".html")

        html = open(filename).read() % params

        return html

    except Exception, e:

        return "HTML format error. Wrong keys: %s" % e

# getHTML

def _create_html_item(opt):

    """Create an <li> item using HTML."""

    return "<li>%s</li>\n" % opt

# _create_html_item

def progress_bar(value, max, barsize):

    """Creates and displays a progressbar. By OSantana"""

    chars = int(value * barsize / float(max))

    percent = int((value / float(max)) * 100)

    sys.stdout.write("#" * chars)

    sys.stdout.write(" " * (barsize - chars + 2))

    if value >= max:

        sys.stdout.write("done.\n\n")

    else:

        sys.stdout.write("[%3i%%]\r" % (percent))

        sys.stdout.flush()

    return percent

# progress_bar() by osantana

def create_tid(last_tid):

    """Function to generate TIDs (ids for transcoders).

    At first it just do +1 on last_tid but can be implemented

    to generate more sparse TIDs"""

    tid = last_tid + 1

    return tid

# create_id()