#!/usr/bin/python

# plugin_pack.py - Helper script for obtaining info about the plugin pack
# Copyright (C) 2008 Gary Kramlich <grim@reaperworld.com>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA.

"""Usage: plugin_pack.py [OPTION...] command

Flags:

  -a  Load abusive plugins
  -d  Load default plugins
  -i  Load incomplate plugins

  -f  Load finch plugins
  -p  Load purple plugins
  -P  Load pidgin plugins

Commands:
"""

import ConfigParser
import getopt
import glob
import os.path
import string
import sys

webpage = 'http://plugins.guifications.org/'

def printerr(msg):
	print >> sys.stderr, msg

class Plugin:
	name = ''
	directory = ''
	type = ''
	depends = []
	provides = ''
	summary = ''
	description = ''
	authors = []
	introduced = ''
	notes = ''

	def __init__(self, directory, name, parser):
		self.name = name

		self.directory = directory

		self.type = parser.get(name, 'type')
		self.depends = parser.get(name, 'depends').split()
		self.provides = parser.get(name, 'provides')
		self.summary = parser.get(name, 'summary')
		self.description = parser.get(name, 'description')
		self.authors = parser.get(name, 'authors').split(',')
		self.introduced = parser.get(name, 'introduced')

		if parser.has_option(name, 'notes'):
			self.notes = parser.get(name, 'notes')

		if self.type != 'default' and self.type != 'incomplete' and self.type != 'abusive':
			printerr('\'%s\' has an unknown type of \'%s\'!' % (self.name, self.type))

	def __str__(self):
		output  = 'name: %s\n' % self.name
		output += 'authors: %s\n' % string.join(self.authors, ', ')
		output += 'type: %s\n' % self.type
		output += 'depends: %s\n' % string.join(self.depends, ' ')
		output += 'provides: %s\n' % self.provides
		output += 'directory: %s\n' % self.directory
		output += 'summary: %s\n' % self.summary
		output += 'description: %s\n' % self.description

		if self.notes:
			output += 'notes: %s\n' % self.notes

		return output

class PluginPack:
	commands = {}
	plugins = {}

	def load_plugins(self, types, depends):
		if len(types) == 0:
			types = None

		if len(depends) == 0:
			depends = None

		for file in glob.glob('*/plugins.cfg'):
			parser = ConfigParser.ConfigParser()

			try:
				parser.read(file)
			except ConfigParser.ParsingError,  msg:
				printerr('Failed to parse \'%s\':\n%s' % (file, msg))
				continue

			for plugin in parser.sections():
				p = Plugin(os.path.dirname(file), plugin, parser)

				# this is kind of hacky, but if we have types, we check to see
				# if the type is in list of types to load.
				if types and not p.type in types:
					continue
				
				# now we check if the give plugins depends match the search
				# depends
				if depends:
					if len(set(depends).intersection(set(p.depends))) == 0:
						continue

				self.plugins[p.provides] = p

	def list_type(self, type):
		list = []

		for name in self.plugins.keys():
			plugin = self.plugins[name]
			if plugin.type == type:
				list.append(plugin)

		list.sort()

		return list

	def list_dep(self, dep):
		list = []

		for name in self.plugins.keys():
			plugin = self.plugins[name]

			if dep in plugin.depends:
				list.append(plugin)

		list.sort()

		return list

	def print_names(self, list):
		names = []

		for plugin in list:
			names.append(plugin.name)

		print string.join(names, ',')

	def default_plugins(self):
		return self.list_type('default')

	def abusive_plugins(self):
		return self.list_type('abusive')

	def incomplete_plugins(self):
		return self.list_type('incomplete')

	def purple_plugins(self):
		return self.list_dep('purple')

	def finch_plugins(self):
		return self.list_dep('finch')

	def pidgin_plugins(self):
		return self.list_dep('pidgin')

	def unique_dirs(self):
		dirs = {}
		for name in self.plugins.keys():
			dirs[self.plugins[name].directory] = 1

		dirs = dirs.keys()
		dirs.sort()

		return dirs

	def help(self, args):
		"""Displays information about other commands"""
		try:
			cmd = self.commands[args[0]]
			print cmd.__doc__
		except KeyError:
			print 'command \'%s\' was not found' % args[0]
		except IndexError:
			print '%s' % (self.help.__doc__)
			print
			print 'help usage:'
			print '  help <command>'
			print
			print 'Available commands:'

			cmds = self.commands.keys()
			cmds.remove('help')
			cmds.sort()
			print '  %s' % (string.join(cmds, ' '))
	commands['help'] = help

	def dist_dirs(self, args):
		"""Displays a list of all plugin directories to included in the distribution"""
		print string.join(self.unique_dirs(), ' ')
	commands['dist_dirs'] = dist_dirs

	def build_dirs(self, args):
		"""Displays a list of the plugins that can be built"""
		if len(args) != 2:
			printerr('build_dirs expects 2 arguments:')
			printerr('\ta comma separated list of dependencies')
			printerr('\ta comma separated list of plugins to build')
			sys.exit(1)

		# store the external depedencies
		externals = args[0].split(',')

		deps = {}

		# run through the provided dependencies, setting their dependencies to
		# nothing since we know we already have them
		for d in externals:
			deps[d] = []

		# now run through the plugins adding their deps to the dictionary
		for name in self.plugins.keys():
			plugin = self.plugins[name]

			deps[plugin.provides] = plugin.depends

		# run through the requested plugins and store their plugin instance in check
		check = []
		for provides in args[1].split(','):
			try:
				if provides == 'all':
					defaults = []
					for p in self.default_plugins():
						defaults.append(p.provides)

					check += defaults

					continue

				plugin = self.plugins[provides]
				check.append(plugin.provides)
			except KeyError:
				continue

		# convert our list of plugins to check into a set to remove dupes
		#check = set(check)

		# create our list of plugins to build
		build = []

		# now define a function to check our deps
		def has_deps(provides):
			# don't add anything to build more than once
			if provides in build:
				return True

			try:
				dep_list = deps[provides]
			except KeyError:
				return False

			# now check the dependencies
			for dep in dep_list:
				if '|' in dep:
					count = 0
					for d in dep.split('|'):
						if has_deps(d):
							count += 1

					if count == 0:
						return False
				else:
					if not has_deps(dep):
						return False

			# make sure the provides isn't an external
			if not provides in externals:
				build.append(provides)

			# everything checks out!
			return True

		# check all the plugins we were told to for their dependencies
		for c in check:
			has_deps(c)

		# now create a list of all directories to build
		output = []

		for provides in build:
			plugin = self.plugins[provides]

			output.append(plugin.directory)

		output.sort()

		print "%s" % (string.join(output, ','))
	commands['build_dirs'] = build_dirs
	
	def list_plugins(self, args):
		"""Displays a list similiar to 'dpkg -l' about the plugin pack"""

		data = {}

		# create an array for the widths, we initialize it to the lengths of
		# the title strings.  We ignore summary, since that one shouldn't
		# matter.
		widths = [4, 8, 0]

		for p in self.plugins.keys():
			plugin = self.plugins[p]

			if plugin.type == 'abusive':
				type = 'a'
			elif plugin.type == 'incomplete':
				type = 'i'
			else:
				type = 'd'

			if 'finch' in plugin.depends:
				ui = 'f'
			elif 'pidgin' in plugin.depends:
				ui = 'p'
			elif 'purple' in plugin.depends:
				ui = 'r'
			else:
				ui = 'u'

			widths[0] = max(widths[0], len(plugin.name))
			widths[1] = max(widths[1], len(plugin.provides))
			widths[2] = max(widths[2], len(plugin.summary))

			data[plugin.provides] = [type, ui, plugin.name, plugin.provides, plugin.summary]

		print 'Type=Default/Incomplete/Abusive'
		print '| UI=Finch/Pidgin/puRple/Unknown'
		print '|/ Name%s Provides%s Summary' % (' ' * (widths[0] - 4), ' ' * (widths[1] - 8))
		print '++-%s-%s-%s' % ('=' * (widths[0]), '=' * (widths[1]), '=' * (widths[2]))

		# create the format var
		fmt = '%%s%%s %%-%ds %%-%ds %%s' % (widths[0], widths[1]) #, widths[2])

		# now loop through the list again, with everything formatted
		list = data.keys()
		list.sort()

		for p in list:
			d = data[p]
			print fmt % (d[0], d[1], d[2], d[3], d[4])
	commands['list'] = list_plugins

	def config_file(self, args):
		"""Outputs the contents for the file to be m4_include()'d from configure"""
		uniqdirs = self.unique_dirs()

		# add our --with-plugins option
		print 'AC_ARG_WITH(plugins,'
		print '            AC_HELP_STRING([--with-plugins], [what plugins to build]),'
		print '            ,with_plugins=all)'
		print 'if test -z $with_plugins ; then'
		print '\twith_plugins=all'
		print 'fi'

		# determine and add our output files
		print 'PP_DIST_DIRS="%s"' % (string.join(uniqdirs, ' '))
		print 'AC_SUBST(PP_DIST_DIRS)'
		print
		print 'AC_CONFIG_FILES(['
		for dir in uniqdirs:
			print '\t%s/Makefile' % (dir)
		print '])'
		print

		# setup a second call to determine the plugins to be built
		print 'PP_BUILD=`$PYTHON $srcdir/plugin_pack.py build_dirs $DEPENDENCIES $with_plugins`'
		print
		print 'PP_BUILD_DIRS=`echo $PP_BUILD | sed \'s/,/\ /g\'`'
		print 'AC_SUBST(PP_BUILD_DIRS)'
		print
		print 'PP_PURPLE_BUILD="$PYTHON $srcdir/plugin_pack.py -p show_names $PP_BUILD"'
		print 'PP_PIDGIN_BUILD="$PYTHON $srcdir/plugin_pack.py -P show_names $PP_BUILD"'
		print 'PP_FINCH_BUILD="$PYTHON $srcdir/plugin_pack.py -f show_names $PP_BUILD"'
	commands['config_file'] = config_file

	def dependency_graph(self, args):
		"""Outputs a graphviz script showing plugin dependencies"""
		def node_label(plugin):
			node = plugin.provides.replace('-', '_')
			label = plugin.name

			return node, label

		def print_plugins(list):
			for plugin in list:
				node, label = node_label(plugin)

				print '\t%s[label="%s"];' % (node, label)

		print 'digraph {'
		print '\tlabel="Dependency Graph";'
		print '\tlabelloc="t";'
		print '\tsplines=TRUE;'
		print '\toverlap=FALSE;'
		print
		print '\tnode[fontname="sans", fontsize="8", style="filled"];'
		print

		# run through the default plugins
		print '\t/* default plugins */'
		print '\tnode[fillcolor="palegreen",shape="tab"];'
		print_plugins(self.default_plugins())
		print

		# run through the incomplete plugins
		print '\t/* incomplete plugins */'
		print '\tnode[fillcolor="lightyellow1",shape="note"];'
		print_plugins(self.incomplete_plugins())
		print

		# run through the abusive plugins
		print '\t/* abusive plugins */'
		print '\tnode[fillcolor="lightpink",shape="octagon"];'
		print_plugins(self.abusive_plugins())
		print

		# run through again, this time showing the relations
		print '\t/* dependencies'
		print '\t * exteranl ones that don\'t have nodes get colored to the following'
		print '\t */'
		print '\tnode[fillcolor="powderblue", shape="egg"];'

		for name in self.plugins.keys():
			plugin = self.plugins[name]

			node, label = node_label(plugin)

			for dep in plugin.depends:
				dep = dep.replace('-', '_')
				print '\t%s -> %s;' % (node, dep)

		print '}'
	commands['dependency_graph'] = dependency_graph

	def debian_description(self, args):
		"""Outputs the description for the Debian packages"""
		print 'Description: %d useful plugins for Pidgin, Finch, and Purple' % len(self.plugins)
		print ' The Plugin Pack is a collection of many simple-yet-useful plugins for Pidgin,'
		print ' Finch, and Purple.  You will find a summary of each plugin below.  For more'
		print ' about an individual plugin, please see %s' % webpage
		print ' .'
		print ' Note: not all %d of these plugins are currently usable' % len(self.plugins)
		
		list = self.plugins.keys()
		list.sort()
		for key in list:
			plugin = self.plugins[key]
			print ' .'
			print ' %s: %s' % (plugin.name, plugin.summary)

		print ' .'
		print ' .'
		print ' Homepage: %s' % webpage
	commands['debian_description'] = debian_description

	def show_names(self, args):
		"""Displays the names of the given comma separated list of provides"""

		if len(args) == 0 or len(args[0]) == 0:
			printerr('show_names expects a comma separated list of provides')
			sys.exit(1)

		provides = args[0].split(',')
		if len(provides) == 0:
			print "none"

		line = " "

		for provide in provides:
			if not provide in self.plugins:
				continue

			name = self.plugins[provide].name

			if len(line) + len(name) + 2 > 75:
				print line.rstrip(',')
				line = ' '
			
			line += ' %s,' % name 

		if len(line) > 1:
			print line.rstrip(',')
	commands['show_names'] = show_names

	def info(self, args):
		"""Displays all information about the given plugins"""
		for p in args:
			try:
				print self.plugins[p].__str__().strip()
			except KeyError:
				print 'Failed to find a plugin that provides \'%s\'' % (p)

			print
	commands['info'] = info

	def stats(self, args):
		"""Displays stats about the plugin pack"""
		counts = {}
		
		counts['total'] = len(self.plugins)
		counts['default'] = len(self.default_plugins())
		counts['incomplete'] = len(self.incomplete_plugins())
		counts['abusive'] = len(self.abusive_plugins())
		counts['purple'] = len(self.purple_plugins())
		counts['finch'] = len(self.finch_plugins())
		counts['pidgin'] = len(self.pidgin_plugins())

		def value(val):
			return "%3d (%6.2f%%)" % (val, (float(val) / float(counts['total'])) * 100.0)

		print "Purple Plugin Pack Stats"
		print ""
		print "%d plugins in total" % (counts['total'])
		print
		print "Status:"
		print "  complete:   %s" % (value(counts['default']))
		print "  incomplete: %s" % (value(counts['incomplete']))
		print "  abusive:    %s" % (value(counts['abusive']))
		print ""
		print "Type:"
		print "  purple: %s" % (value(counts['purple']))
		print "  finch:  %s" % (value(counts['finch']))
		print "  pidgin: %s" % (value(counts['pidgin']))
	commands['stats'] = stats

def show_usage(pp, exitcode):
	print __doc__

	cmds = pp.commands.keys()
	cmds.sort()
	
	for cmd in cmds:
		print "  %-20s %s" % (cmd, pp.commands[cmd].__doc__)

	print ""

	sys.exit(exitcode)

def main():
	# create our main instance
	pp = PluginPack()

	types = []
	depends = []

	try:
		shortopts = 'adfiPp'

		opts, args = getopt.getopt(sys.argv[1:], shortopts)
	except getopt.error, msg:
		print msg
		show_usage(pp, 1)

	for o, a in opts:
		if o == '-a':
			types.append('abusive')
		elif o == '-d':
			types.append('default')
		elif o == '-i':
			types.append('incomplete')
		elif o == '-f':
			depends.append('finch')
		elif o == '-P':
			depends.append('pidgin')
		elif o == '-p':
			depends.append('purple')

	# load the plugins that have been requested, if both lists are empty, all
	# plugins are loaded
	pp.load_plugins(types, depends)

	if(len(args) == 0):
		show_usage(pp, 1)

	cmd = args[0]
	args = args[1:]

	try:
		pp.commands[cmd](pp, args)
	except KeyError:
		printerr('\'%s\' command not found' % (cmd))

if __name__ == '__main__':
	# this is a work around when we're called for a directory that isn't the
	# directory that this file is in.  This happens during distcheck, as well
	# as a few other cases that most people won't use ;)
	if os.path.dirname(__file__) != '':
		os.chdir(os.path.dirname(__file__))

	main()