#!?usr/local/bin/python

import gtk
import ConfigParser
import os.path
import re
import Creddy

from policy import policy

from principal_tree import principal_issued_tree, \
	principal_assigned_tree, principal_attribute_tree, \
	principal_rules_tree, principal_action_tree, action_principal_tree

from new_credential import add_credential_dialog, add_principal_dialog, \
	mark_action_dialog

class window(gtk.Window):
    '''
    The main GUI class.  It presents the various TreeViews and menus to
    save/load/add, to add credentials, identities and actions and to change the
    policy translation variable.  It keeps its current size and location in the
    .abac_policy_tool.cfg file in the user's home.
    '''

    # Definition of the menus
    ui_def = '''
    <ui>
	<menubar>
	    <menu action="FileMenu">
		<menuitem name="New" action="FileNew"/>
		<menuitem name="Load" action="FileLoad"/>
		<menuitem name="Append" action="FileAppend"/>
		<menuitem name="Save" action="FileSave"/>
		<menuitem name="Quit" action="FileQuit"/>
	    </menu>
	    <menu action="EditMenu">
		<menuitem action="EditAddCred"/>
		<menuitem action="EditAddPrincipal"/>
		<menuitem action="EditMarkAction"/>
	    </menu>
	    <menu action="ViewMenu">
		<menu action="Translation">
		    <menuitem name="ViewSet" action="ViewSet"/>
		    <menuitem name="ViewRole description" action="ViewRole"/>
		    <menuitem name="ViewNames" action="ViewName"/>
		    <menuitem name="ViewRaw" action="ViewRaw"/>
		</menu>
	    </menu>
	</menubar>
    </ui>
    '''
    # Path to the configuration
    cfg_path = os.path.join(os.path.expanduser('~'), '.abac_policy_tool.cfg')

    @staticmethod
    def wrapit(widget):
	'''
	Put widget into a ScrolledWindow with automatic scrollbars on both
	directions, and return the ScrolledWindow.
	'''
	sw = gtk.ScrolledWindow()
	sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
	sw.add(widget)
	return sw

    def report_error(self, message):
	'''
	Put a MessageDialog up with the given message.  This is a member method
	so that it can be centered on the window.
	'''
	md = gtk.MessageDialog(self, gtk.DIALOG_MODAL, 
		gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, 
		message)
	md.run()
	md.destroy()

    def __init__(self, policy):
	'''
	Initialize all the GTK hooks for menus, put the various TreeViews up
	(connected to the policy) and read teh configuration for current
	position.
	'''
	gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
	self.policy = policy
	self.set_title('ABAC Policy Tool')
	self.connect('destroy', self.quit)
	self.connect('show', self.shown)
	self.connect('configure-event', self.changed)
	self.pos = (0,0)
	self.size = (500, 500)
	# These are the TreeViews that will change when policy changes
	self.pages = [ ]
	# These are the TreeViews that change when policy translation changes
	self.translated = [ ]

	self.read_config()

	# Hook up thr TreeViews
	nb = gtk.Notebook()
	p = action_principal_tree(policy)
	nb.append_page(self.wrapit(p), 
		gtk.Label("Principals by action permitted"))
	self.pages.append(p)
	self.translated.append(p)

	p = principal_action_tree(policy)
	nb.append_page(self.wrapit(p), 
		gtk.Label("Actions perimtted to principals"))
	self.pages.append(p)
	self.translated.append(p)

	p = principal_issued_tree(policy)
	nb.append_page(self.wrapit(p), gtk.Label("Attributes Directly Issued"))
	self.pages.append(p)

	p = principal_rules_tree(policy)
	nb.append_page(self.wrapit(p), gtk.Label("Rules declared"))
	self.pages.append(p)
	self.translated.append(p)

	p = principal_assigned_tree(policy)
	nb.append_page(self.wrapit(p), gtk.Label("Attributes Directly Held"))
	self.pages.append(p)

	p = principal_attribute_tree(policy)
	nb.append_page(self.wrapit(p), gtk.Label("All Attributes"))
	self.pages.append(p)
	self.translated.append(p)

	# Make the Menus real
	ui = gtk.UIManager()
	ag = gtk.ActionGroup('action')
	ag.add_actions((
	    ('FileMenu', None, 'File'),
	    ('FileNew', gtk.STOCK_NEW, None, None, None, self.new),
	    ('FileSave', gtk.STOCK_SAVE, None, None, None, self.save),
	    ('FileQuit', gtk.STOCK_QUIT, None, None, None, self.quit),
	    ('EditMenu', None, 'Edit'),
	    ('EditAddCred', None, "Add Credential", None, None, self.add_cred),
	    ('EditAddPrincipal', None, "Add Principal", None, None, 
		self.add_principal),
	    ('EditMarkAction', None, "Mark Action", None, None, 
		self.mark_action),
	    ('ViewMenu', None, 'View'),
	    ('Translation', None, 'Translate Credentials'),
	    ))
	# load and append call the same method with different user data -
	# whether to clear current policy or not.
	ag.add_actions((
	    ('FileLoad', gtk.STOCK_OPEN, None, None, None, self.load),
	    ), True)
	ag.add_actions((
	    ('FileAppend', gtk.STOCK_ADD, None, None, None, self.load),
	    ), False)
	ag.add_radio_actions([
	    ('ViewSet', None, 'Set based descriptions', None, None, 0), 
	    ('ViewRole', None, 'Role based descriptions', None, None, 1), 
	    ('ViewName', None, 'ABAC with symbolic names', None, None, 2), 
	    ('ViewRaw', None, 'Raw ABAC', None, None, 3),], 
	    2, self.translation_change)

	ui.insert_action_group(ag, -1)
	ui.add_ui_from_string(window.ui_def)

	# Put it all together and show it.
	mb = ui.get_widget('ui/menubar')
	vb = gtk.VBox()
	vb.pack_start(mb, False, False, 0)
	vb.pack_start(nb, True, True, 0)

	self.add(vb)
	self.show_all()
    
    def quit(self, widget=None, data=None):
	'''
	Called from File->Quit in the menu.  Save location/size and exit
	'''
	self.save_config()
	gtk.main_quit()

    def save(self, widget=None, data=None):
	'''
	Save the current state to a file.  Wrangle the FileChooserDialog to
	pick the file and write to it.
	'''
	d = gtk.FileChooserDialog('Save file as', self, 
		gtk.FILE_CHOOSER_ACTION_SAVE, (
	    gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
	    gtk.STOCK_OK, gtk.RESPONSE_OK))
	fil = gtk.FileFilter()
	fil.set_name('Zip files')
	fil.add_pattern('*.zip')
	d.set_select_multiple(False)
	d.set_current_folder('.')
	d.set_do_overwrite_confirmation(True)
	d.add_filter(fil)
	# If the policy has been saved, start at that file.
	if self.policy.filename is not None:
	    d.set_filename(self.policy.filename)
	# Display the chooser
	rv = d.run()
	d.hide()
	# Write if the user wants to do it.
	if rv == gtk.RESPONSE_OK:
	    self.policy.write_zip(d.get_filename())
	d.destroy()

    def new(self, widget=None, data=None):
	'''
	Called when the user asks for a blank policy.  Put up a confirmation
	and clear if confirmed.
	'''
	d = gtk.MessageDialog(self, gtk.DIALOG_MODAL, 
		gtk.MESSAGE_ERROR, gtk.BUTTONS_OK_CANCEL, 
		"Clear this policy?")
	rv = d.run()
	if rv == gtk.RESPONSE_OK:
	    self.policy.clear()
	    # After clearing, tell the TreeViews
	    for p in self.pages:
		p.recalc()
	d.destroy()

    def load(self, widget=None, data=None):
	'''
	Called to either load or append to the loaded policy.  data is the
	clearit parameter to the load call.  Other than that, just put up a
	requester and do the thing.
	'''
	d = gtk.FileChooserDialog('Load file', self, 
		gtk.FILE_CHOOSER_ACTION_OPEN, (
	    gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
	    gtk.STOCK_OK, gtk.RESPONSE_OK))
	fil = gtk.FileFilter()
	fil.set_name('Zip files')
	fil.add_pattern('*.zip')
	d.set_select_multiple(False)
	d.set_current_folder('.')
	d.set_do_overwrite_confirmation(True)
	d.add_filter(fil)
	if self.policy.filename is not None:
	    d.set_filename(self.policy.filename)
	rv = d.run()
	d.hide()
	if rv == gtk.RESPONSE_OK:
	    self.policy.read_zip(d.get_filename(), data)
	    # Tell the TreeViews to update.
	    for p in self.pages:
		p.recalc()
	d.destroy()

    def add_principal(self, widget=None, data=None):
	'''
	Called to add a principal with a user-supplied mnemonic name to the
	current policy.  Do not allow duplicate mnemonic names.
	'''
	while True:
	    # Ask for a name
	    d = add_principal_dialog(self)
	    rv = d.run()
	    d.hide()
	    if rv == gtk.RESPONSE_OK:
		# Build the certificate
		name = d.pname.get_text() 
		if name not in self.policy.principal_names():
		    try:
			cid = Creddy.ID(name, 5 * 3600 * 24 * 365)
		    except RuntimeError, e:
			# Note this retries on failure
			self.report_error('Cannot create principal: %s' % e)
			continue
		    # Identity to policy
		    self.policy.add_identity(cid)
		    # Update the trees
		    for p in self.pages:
			p.recalc()
		    # clean up the dialog
		    d.destroy()
		    return
		else:
		    # Duplicate, retry
		    d.destroy()
		    self.report_error('Cannot overwrite name: %s' % name)
	    else:
		# Cancel leave this function
		d.destroy()
		return

    def add_cred(self, widget=None, data=None):
	'''
	Create a new credential and add it to the policy.  Most of the work is
	parsing the data out of teh add credential dialog which may be
	reporting a request for one of three kinds of credential.
	'''
	# Ask the user what they want
	d = add_credential_dialog(self, self.policy)
	rv = d.run()
	d.hide()
	if rv == gtk.RESPONSE_OK:
	    # The name and issuer are always teh same
	    iname = d.issuer.get_active_text()
	    issuer = self.policy.issuers[self.policy.name_to_keyid(iname)]
	    role = re.sub('\.', '_', d.role.get_text())
	    cred = None
	    try: 
		# Base credential
		cred = Creddy.Attribute(issuer, role, 5 * 365 * 3600 * 24)
	    except RuntimeError, e:
		print e
		pass

	    if cred is None:
		self.report_error("Missing or invalid role")
		d.destroy()
		return

	    mode = d.mechanism.get_active_text()
	    # Principal is always in the results
	    p = d.subject_principal.get_text()
	    p = self.policy.name_to_keyid(p)
	    # Collect the dependent components
	    if p is None:
		self.report_error("Missing or invalid subject principal")
		d.destroy()
		return
	    if mode == 'Direct delegation' or mode == 'Delegation to role':
		r = d.subject_role.get_text()
		if r is None or r == '':
		    self.report_error("Missing or invalid subject role")
		    d.destroy()
		    return
	    if mode == 'Delegation to role':
		l = d.subject_link.get_text()
		if l is None or l == '':
		    self.report_error("Missing or invalid subject linking role")
		    d.destroy()
		    return
	    # Build that sucker
	    if mode == 'Direct assignment': cred.principal(p)
	    elif mode == 'Direct delegation': cred.role(p, r)
	    else: cred.linking_role(p, l, r)

	    try:
		# Actual creation
		cred.bake()
	    except:
		self.report_error("Could not create credential?!")
		d.destroy()
		return
	    # Add to policy
	    self.policy.add_credential(cred)
	    # Update the TreeViews
	    for p in self.pages:
		p.recalc()
	    d.destroy()

    def mark_action(self, widget=None, data=None):
	'''
	Mark an action. Collect the user's request and propagate it.
	'''
	d = mark_action_dialog(self, self.policy)
	rv = d.run()
	d.hide()
	if rv == gtk.RESPONSE_OK:
	    action = d.get_value()
	    if action is not None:
		self.policy.add_action(action)
	    # Tell the TreeViews
	    for p in self.pages:
		p.recalc()
	d.destroy()


    def shown(self, w):
	'''
	Handles an event where the window appears.  Move to the saved position
	and size.
	'''
	self.move(*self.pos)
	self.resize(*self.size)

    def changed(self, w, e):
	'''
	Handles an event where the window changes (resizes or moves).  Remember
	the size and position.
	'''
	self.pos = self.get_position()
	self.size = self.get_size()

    def translation_change(self, ra, c, user=None):
	'''
	Called from any of the menu items that request a translation change.
	They're radio buttons, so each one unsets the last.  Translate the
	radio value into the right policy string, set the translation value and
	update the TreeViews that depend on translation.
	'''
	cv = c.get_current_value()
	if cv == 0: self.policy.translate = 'sets'
	elif cv == 1: self.policy.translate = 'roles'
	elif cv == 2: self.policy.translate = 'keyids'
	elif cv == 3: self.policy.translate = 'none'
	else: print >>sys.stderr, 'Unknown translation type!?'

	for p in self.translated:
	    p.recalc()

    def get_intpair(self, sect, opt):
	'''
	Utility to pull a pair of integers from a configuration file.  The size
	and position are thsi kind of data, so this is used a couple places.
	'''
	if not self.cfg.has_section(sect):
	    self.cfg.add_section(sect)

	if self.cfg.has_option(sect, opt):
	    try:
		return [int(x) for x in self.cfg.get(sect, opt).split(',', 1)]
	    except ValueError:
		return None
	else:
	    return None

    def read_config(self):
	'''
	Get the saved size and position from the config file, if any
	'''
	self.cfg = ConfigParser.SafeConfigParser()
	self.cfg.read(window.cfg_path)

	self.pos = self.get_intpair('geom', 'pos') or ( 0, 0)
	self.size = self.get_intpair('geom', 'size') or ( 500, 500)


    def save_config(self):
	'''
	Save the current postion to the default config file.
	'''
	self.cfg.set('geom', 'pos', '%d,%d' % self.pos)
	self.cfg.set('geom', 'size', '%d,%d' % self.size)
	try:
	    f = open(window.cfg_path, 'w')
	    self.cfg.write(f)
	    f.close()
	except EnvironmentError, e:
	    pass