#!/usr/bin/env python
 __copyright__ = 'Copyright 2012, Edward Langley'
 
 import imp, os.path
 import cgi
 import urlparse
 from twisted.web.resource import Resource
 import sys
 
 import openid
 from openid.consumer import consumer
 from openid.oidutil import appendArgs
 from openid.extensions import pape, sreg
 
 import mako.template
 from openidmongodb import MongoDBStore
 from zope.interface import Interface, Attribute, implements
 from twisted.python.components import registerAdapter
 from twisted.web.server import Session
 from twisted.web.resource import Resource
 import collections
 
 ################### Customization hooks
 class EventHandler(object):

 	external_port = None

 	url = None

 	@property
 	def store(self):
 		self.__class__.store= MongoDBStore()
 		return self.store

 
 	def __init__(self, resource):
 		self.resource = resource
 
 	@property
 	def template(self):
 		with file(get_filename('twisted_openid', 'page.mako')) as f:
 			return mako.template.Template(f.read())
 
 	def cancel(self, *args, **kwargs):
 		pass
 
 	def fail(self, *args, **kwargs):
 		pass
 
 	def setup_needed(self, *args, **kwargs):
 		pass
 
 	def success(self, *args, **kwargs):
 		pass
 
 #################################################
 
 def get_filename(package, resource=None):
    """Get the absolute path to a file inside a given Python package"""
    d = sys.modules[package].__file__
    if resource:
       d = os.path.dirname(d)
       d = os.path.abspath(d)
       return os.path.join(d, resource)
    return d
 
 def quoteattr(s):
 	qs = cgi.escape(s, 1)
 	return '"%s"' % (qs,)
 
 
 
 
 # Used with an OpenID provider affiliate program.
 OPENID_PROVIDER_NAME = 'MyOpenID'
 OPENID_PROVIDER_URL ='https://www.myopenid.com/affiliate_signup?affiliate_id=39'
 
 
 
 class OpenIDResource(Resource):
 	"""Request handler that knows how to verify an OpenID identity."""
 	SESSION_COOKIE_NAME = 'pyoidconsexsid'
 
 	eventhandler = EventHandler
 	session = None
 	isLeaf = True
 
 
 	def __init__(self, *args, **kw):
 		Resource.__init__(self, *args, **kw)
 		self.eventhandler = self.eventhandler(self)
 
 	def getConsumer(self, txrequest, stateless=False):
 		if stateless:
 				store = None
 		else:
 				store = self.eventhandler.store
 		return consumer.Consumer(IOID_Session(txrequest.getSession()), store)
 
 
 	def render(self, txrequest):
 		"""Dispatching logic. There are three paths defined:
 
 			/ - Display an empty form asking for an identity URL to
 				verify
 			/verify - Handle form submission, initiating OpenID verification
 			/process - Handle a redirect from an OpenID server
 
 		Any other path gets a 404 response. This function also parses
 		the query parameters.
 
 		If an exception occurs in this function, a traceback is
 		written to the requesting browser.
 		"""
 		o_txrequest_write = txrequest.write
 		def txrequest_write(msg, *a, **kw):
 			if isinstance(msg, unicode): msg = msg.encode('utf-8')
 			return o_txrequest_write(msg, *a, **kw)
 		txrequest.write = txrequest_write
 		try:
 				self.parsed_uri = urlparse.urlparse(txrequest.uri)
 
 				path = '/%s' % '/'.join(txrequest.postpath)
 				print path
 				if path == '/':
 					self.renderPage(txrequest)
 				elif path == '/verify':
 					self.doVerify(txrequest)
 				elif path == '/process':
 					self.doProcess(txrequest)
 				elif path == '/affiliate':
 					self.doAffiliate(txrequest)
 				elif path == '/favicon.ico':
 					return ''
 				else:
 					self.notFound(txrequest)
 
 		except (KeyboardInterrupt, SystemExit):
 				raise

 		finally:

 				txrequest.setResponseCode(500)

 				txrequest.setHeader('Content-type', 'text/html')
 				txrequest.getSession()
 		return ''
 
 	def doVerify(self, txrequest):
 		"""Process the form submission, initating OpenID verification.
 		"""
 
 		# First, make sure that the user entered something
 		openid_url = txrequest.args.get('openid_identifier')
 		if not openid_url:
 				self.renderPage(txrequest, 'Enter an OpenID Identifier to verify.',
 								css_class='error', form_contents=openid_url)
 				return
 		else:
 			openid_url = openid_url[0]
 
 		immediate = 'immediate' in txrequest.args
 		use_stateless = 'use_stateless' in txrequest.args
 
 		oidconsumer = self.getConsumer(txrequest, stateless = use_stateless)
 		try:
 				request = oidconsumer.begin(openid_url)
 		except consumer.DiscoveryFailure, exc:
 				fetch_error_string = 'Error in discovery: %s' % (cgi.escape(str(exc[0])))
 				self.renderPage(txrequest, fetch_error_string, css_class='error', form_contents=openid_url)
 		else:
 				if request is None:
 					msg = 'No OpenID services found for <code>%s</code>' % (
 						cgi.escape(openid_url),)
 					self.renderPage(txrequest, msg, css_class='error', form_contents=openid_url)
 				else:

 					trust_root = 'http://%s' % self.eventhandler.url

 					if self.eventhandler.external_port and self.eventhandler.external_port != 80:
 						trust_root += ':%s' % self.eventhandler.external_port

 					return_to = 'http:' + self.buildURL(txrequest, 'process')

 
 					if request.shouldSendRedirect():
 						redirect_url = request.redirectURL(trust_root, return_to, immediate=immediate)
 						txrequest.redirect(redirect_url)
 					else:
 						form_html = request.htmlMarkup(
 								trust_root, return_to,
 								form_tag_attrs={'id':'openid_message'},
 								immediate=immediate)
 
 						txrequest.write(form_html)

 		print 'verify done!'

 
 	def requestRegistrationData(self, request):
 		sreg_request = sreg.SRegRequest(
 				required=['nickname'], optional=['fullname', 'email'])
 		request.addExtension(sreg_request)
 
 	def requestPAPEDetails(self, request):
 		pape_request = pape.Request([pape.AUTH_PHISHING_RESISTANT])
 		request.addExtension(pape_request)
 
 	def doProcess(self, txrequest):
 		"""Handle the redirect from the OpenID server.
 		"""
 		oidconsumer = self.getConsumer(txrequest)
 
 		# Ask the library to check the response that the server sent
 		# us.	Status is a code indicating the response type. info is
 		# either None or a string containing more information about
 		# the return type.
 		url = 'http://'+txrequest.getHeader('Host')+txrequest.path
 		query = { k: a[0] if len(a) == 1 else a for k,a in txrequest.args.iteritems() }
 		info = oidconsumer.complete(query, url)
 
 		sreg_resp = None
 		pape_resp = None
 		css_class = 'error'
 		display_identifier = info.getDisplayIdentifier()
 
 		message = None
 		cb = None
 		kwargs = {}
 		if info.status == consumer.FAILURE and display_identifier:
 			txrequest.getSession().expire()
 			cb = self.eventhandler.fail
 		elif info.status == consumer.SUCCESS:
 			kwargs['canonicalID'] = info.endpoint.canonicalID
 			kwargs['display_identifier'] = display_identifier
 			kwargs['identity_url'] = info.identity_url
 			session = IOID_Session(txrequest.getSession())
 			print 'id(session.items)', id(session)
 			session.update(kwargs)
 			cb = self.eventhandler.success
 		elif info.status == consumer.CANCEL:
 			txrequest.getSession().expire()
 			cb = self.eventhandler.cancel
 		elif info.status == consumer.SETUP_NEEDED:
 			cb = self.eventhandler.setup_needed
 		else:
 			txrequest.getSession().expire()
 			message = 'Verification failed.'
 
 		if cb is not None:
 			cb(txrequest, message, **kwargs)
 		else:
 			self.renderPage(txrequest, message, display_identifier,
 						sreg_data=sreg_resp, pape_data=pape_resp)

 		print 'process done!'

 
 #### Untested !!!
 #	def doAffiliate(self):
 #		"""Direct the user sign up with an affiliate OpenID provider."""
 #		sreg_req = sreg.SRegRequest(['nickname'], ['fullname', 'email'])
 #		href = sreg_req.toMessage().toURL(OPENID_PROVIDER_URL)
 #
 #		message = """Get an OpenID at <a href=%s>%s</a>""" % (
 #				quoteattr(href), OPENID_PROVIDER_NAME)
 #		self.renderPage(txrequest, message)
 #
 #	def renderSREG(self, sreg_data, txrequest):
 #		if not sreg_data:
 #				txrequest.write('<div class="alert">No registration data was returned</div>')
 #		else:
 #				sreg_list = sreg_data.items()
 #				sreg_list.sort()
 #				txrequest.write(
 #					'<h2>Registration Data</h2>'
 #					'<table class="sreg">'
 #					'<thead><tr><th>Field</th><th>Value</th></tr></thead>'
 #					'<tbody>')
 #
 #				odd = ' class="odd"'
 #				for k, v in sreg_list:
 #					field_name = sreg.data_fields.get(k, k)
 #					value = cgi.escape(v.encode('UTF-8'))
 #					txrequest.write(
 #						'<tr%s><td>%s</td><td>%s</td></tr>' % (odd, field_name, value))
 #					if odd:
 #						odd = ''
 #					else:
 #						odd = ' class="odd"'
 #
 #				txrequest.write('</tbody></table>')
 
 	def renderPAPE(self, pape_data, txrequest):
 		if not pape_data:
 				txrequest.write(
 					'<div class="alert">No PAPE data was returned</div>')
 		else:
 				txrequest.write('<div class="alert">Effective Auth Policies<ul>')
 
 				for policy_uri in pape_data.auth_policies:
 					txrequest.write('<li><tt>%s</tt></li>' % (cgi.escape(policy_uri),))
 
 				if not pape_data.auth_policies:
 					txrequest.write('<li>No policies were applied.</li>')
 
 				txrequest.write('</ul></div>')
 

 	def buildURL(self, txrequest, action='', **query):

 		"""Build a URL relative to the server base_url, with the given
 		query parameters added."""

 		base = '//%s/%s/' % (self.eventhandler.url, '/'.join(txrequest.prepath))

 		if not base:
 			a  = urlparse.urlparse(txrequest.prePathURL()+'/')
 
 			port = a.port
 			if self.eventhandler.external_port:
 				port = self.eventhandler.external_port
 			if port == 80:
 				port = ''
 			else:
 				port = ':%s' % port
 
 			url = urlparse.SplitResult(
 				a.scheme,
 				'%s:%s@%s%s' % (
 					a.username,
 					a.password,
 					a.hostname,
 					port
 				),
 				a.path,
 				a.query,
 				a.fragment)
 
 			base = url.geturl()

 		if action:

 			base = urlparse.urljoin(base, action)

 		print 'buildURL', base

 		return appendArgs(base, query)
 

 	def notFound(self, txrequest):

 		"""Render a page with a 404 return code and a message."""
 		fmt = 'The path <q>%s</q> was not understood by this server.'
 		msg = fmt % (self.path,)
 		openid_url = txrequest.args.get('openid_identifier')
 		self.renderPage(txrequest, msg, 'error', openid_url, status=404)
 
 	def renderPage(self, txrequest, message=None, css_class='alert', form_contents=None,
 					status=200, title="Python OpenID Consumer Example",
 					sreg_data=None, pape_data=None):
 		"""Render a page."""
 		form_contents = form_contents or ''
 
 		txrequest.setResponseCode(status)
 		session = txrequest.getSession()
 		print 'id(session)', id(session)
 		print 'session id:', session.uid
 		counter = IOID_Session(session)
 		print 'id(session.items)', id(counter)
 
 		result = self.eventhandler.template.render(**dict(
 			css_class = css_class,
 			action = quoteattr(self.buildURL(txrequest, 'verify')),
 			openid = quoteattr(form_contents),
 			message = message or 'session details: %s' % counter.items,
 		))
 		txrequest.write(result);
 
 ################################# Twisted Session Management #######################################
 
 class IOID_Session(Interface):
 	items = Attribute("An int value which counts up once per page view.")
 
 
 class OID_Session(collections.MutableMapping):
 	implements(IOID_Session)
 	def __init__(self, session):
 		self.items = {}
 	def __len__(self):
 		return len(self.items)
 	def __iter__(self):
 		return iter(self.items)
 	def __getitem__(self, name):
 		return self.items[name]
 	def __setitem__(self, name, value):
 		self.items[name] = value
 	def __delitem__(self, name):
 		del self.items[name]
 	def get(self, name, default=None):
 		return self.items.get(name, default)
 
 
 registerAdapter(OID_Session, Session, IOID_Session)