from Globals import DTMLFile
from OFS.Folder import Folder
from zope.security.interfaces import Unauthorized

from trac.web.main import dispatch_request, send_project_index, get_environment
from trac.web.api import Request
from trac.perm import PermissionError

manage_addZopeTracForm = DTMLFile('dtml/manage_addZopeTracForm', globals())

def manage_addZopeTrac(self, id, tracEnvParentDir, title = '', REQUEST = {}):
	""" Add a Zope Trac Instance """
	o = ZopeTrac(id, tracEnvParentDir, title)
	self._setObject(id, o)

	if REQUEST:
		return self.manage_main(self, REQUEST)
	return ''

class ZopeTracField(object):
	def __init__(self, name, value):
		self.name = name
		self.value = value
                self.filename = None
                if hasattr(self.value, 'filename'):
                        self.filename = self.value.filename
                        self.file = self.value
		
class ZopeTracFieldStorage:
	""" Zope FieldStorage Wrapper """
	def __init__(self, req):
		self.req = req

	def keys(self):
		return self.req.form.keys()

	def has_key(self, key):
		return self.req.form.has_key(key) or self.req.has_key(key)

	def __getitem__(self, key, default=None):
		return ZopeTracField(key, self.get(key, default))
		
	def get(self, key, default=None):
		return self.req.get(key, default)

	def __setitem__(self, key, value):
		self.req.set(key, value)

class ZopeTracRequest(Request):
	""" Req implementation for Zope """

	def __init__(self, options, request, baseUrl):
		Request.__init__(self)
		self.request = request
		self.remote_addr = self.request.REMOTE_ADDR
		self.remote_user = self.request.AUTHENTICATED_USER.getUserName()
		self.server_name = self.request.SERVER_NAME
		self.server_port = self.request.SERVER_PORT
		self.method = self.request.REQUEST_METHOD
		self.scheme = self.request.URL[:self.request.URL.index(':')]
		for k, v in self.request.cookies.items():
			self.incookie[k] = v

		self.args = ZopeTracFieldStorage(self.request)
			
		self.cgi_location = '/'+baseUrl
		self.idx_location = self.cgi_location
		pi = self.request.PATH_INFO
		pIndex = pi.index(self.cgi_location)

		self.path_info = pi[pIndex + len(self.cgi_location):]
		
	def read(self, len):
		pass

	def write(self, data):
		self.request.RESPONSE.write(data)

	def get_header(self, name):
		newName = 'HTTP_'+name.replace('-', '_').upper()
		return self.request[newName]

	def send_response(self, code):
		for k, v in self.outcookie.items():
			self.request.RESPONSE.setCookie(k, v)

		self.request.RESPONSE.flush()

	def send_header(self, name, value):
		if name == 'Location':
			self.request.RESPONSE.redirect(value)
		else:
			self.request.RESPONSE.setHeader(name, value)

	def end_headers(self):
		pass

class ZopeTrac(Folder):
	""" Map a Trac Instance to a Zope Folder """

	def __init__(self, id, tracEnvParentDir = '', title = ''):
		self.id = id
		self.title = title
		self.tracEnvParentDir = tracEnvParentDir

	def get_environment(self):
		options = {}
		options['TRAC_ENV'] = self.tracEnvParentDir
		return get_environment(self.REQUEST, options)

	def dispatch_request(self):
		env = self.get_environment()
		env.config.parse_if_needed()
		req = ZopeTracRequest(env, self.REQUEST, self.virtual_url_path())
		try:
			return dispatch_request(req.path_info, req, env)
		except PermissionError:
			raise Unauthorized

	def __call__(self, *args, **kwargs):
		self.dispatch_request()

	def __bobo_traverse__(self, REQUEST, name):
		return self