import re, urllib, urllib2
from elementtree import ElementTree
 
from django.conf import settings
 
from geo.misc import yahoo_precision_to_google_zoom_mappings, GeocodingError
 
NAMESPACE_RE = re.compile(r'^\{.+\}') # To remove xml namespace declarations from tag names, as they are unhelpful here.
 
class XMLElement(object):
  """Object for storing basic XML data (represents an element in an XML document). Content and attributes can
     be stored."""
  def __init__(self, tag='', text='', attrs={}, *args, **kwargs):
    self.text = text
    self.attrs = attrs
    return super(XMLElement, self).__init__(*args, **kwargs)
  
  def __unicode__(self):
    return unicode(self.text)
  
  def __str__(self):
    return str(self.text)
  
  def __repr__(self):
    return '<XMLElement: %s: %s>' % (self.tag, self.text)
  
  def __int__(self):
    return int(self.text)
  
  def __float__(self):
    return float(self.text)
 
class Coordinates(object):
  """Basic object for storing co-ordinate data."""
  def __init__(self, latitude=0.0, longitude=0.0, elevation=0.0, granularity=0, *args, **kwargs):
    self.latitude, self.longitude, self.elevation, self.granularity = float(latitude), float(longitude), float(elevation), int(granularity)
    return super(Coordinates, self).__init__(*args, **kwargs)
  
  def __unicode__(self):
    return 'Coordinate (%s, %s, %s)' % (self.latitude, self.longitude, self.elevation)
  
  def __repr__(self):
    return '<Coordinates object for (%s, %s, %s)>' % (self.latitude, self.longitude, self.elevation)
  
  def __iter__(self):
    return iter((self.latitude, self.longitude, self.elevation))
  
  def __getitem__(self, index):
    return tuple(self)[index]
 
class XMLResponse(object):
  """Object for storing a simple representation of an XML response (not as complex as an ElementTree,
     has no concept of nesting)."""
  def __init__(self, *args, **kwargs):
    self.raw = ''
    self.coords = Coordinates()
    self.data = {}
    return super(XMLResponse, self).__init__(*args, **kwargs)
  
  def __setattr__(self, name, value):
    if not hasattr(self, name):
      try:
        self.data[name] = value
        return
      except:
        return super(XMLResponse, self).__setattr__(name, value)
    else:
      return super(XMLResponse, self).__setattr__(name, value)
 
class GeocodingResult(object):
  """Class to store geocoding response objects."""
  def __init__(self, *args, **kwargs):
    self.response = XMLResponse()
    self.query = ''
    self.coords = Coordinates()
    return super(GeocodingResult, self).__init__(*args, **kwargs)
  
  def __repr__(self):
    return '<GeocodingResult instance for \'%s\'>' % self.query
 
class XMLGeocoder(object):
  short_name = ''
  key_key = ''
  geocoder_url = ''
  query_key = ''
  default_args = {}
  default_inst_args = {
    'result': GeocodingResult(),
    'geocoder_params': {},
  }
  
  def __init__(self, location, *args, **kwargs):
    if self.__class__.__name__ is 'XMLGeocoder':
      raise NotImplementedError('You cannot instantiate XMLGeocoder directly; use on of its subclasses instead.')
    # Set some instance attributes
    self.result = GeocodingResult()
    self.geocoder_params = {unicode(self.query_key): location.name}
    self.result.query = self.geocoder_params[self.query_key]
    # Return
    return super(XMLGeocoder, self).__init__(self, *args, **kwargs)
  
  @property
  def parameters(self):
    params = self.geocoder_params
    if not self.key_key in params:
      params.update(self.key)
    for arg in self.default_args:
      if not arg in params:
        params.update({arg: self.default_args[arg]})
    return params
  
  @property
  def url(self):
    """Returns the URL to preform geocoding."""
    return u'%s?%s' % (unicode(self.geocoder_url), urllib.urlencode(self.parameters))
  
  @property
  def key(self):
    """The API key to use with this geocoder. Returns a dictionary that can be added to the geocoder
       parameter."""
    try:
      return {self.key_key: unicode(settings.GEOCODING_KEYS[self.short_name])}
    except (AttributeError, KeyError):
      # If the GEOCODING_KEYS setting isn't defined or the key isn't in there, return an
      # empty dict.
      return {}
  
  def geocode(self):
    """Let's get geocoding!"""
    self.result.response.raw = urllib2.urlopen(self.url).read()
    et = ElementTree.fromstring(self.result.response.raw)
    for el in et.getiterator():
      xml_element = XMLElement()
      # Add the element content to the xml_element
      xml_element.tag = NAMESPACE_RE.sub('', unicode(el.tag).lower().strip())
      xml_element.text = unicode(el.text).strip()
      xml_element.attrs = el.attrib
      self.result.response.data[xml_element.tag] = xml_element
    try:
      self.result = self.additional_processing(self.result)
    except:
      raise GeocodingError('The location could not be geocoded.')
    return self.result
  
  def additional_processing(self, result):
    """Performs any additional processing that needs to be done on the GeocodingResult object passed
       -- returns the modified object. Also should raise a GeocodingError if something isn't right."""
    return result
  
class YahooGeocoder(XMLGeocoder):
  """Yahoo! Maps' geocoder. Requires a 'yahoo' key in settings.GEOCODING_KEYS to work correctly."""
  geocoder_url = u'http://local.yahooapis.com/MapsService/V1/geocode'
  short_name = u'yahoo'
  key_key = u'appid'
  query_key = u'location'
  
  def additional_processing(self, result):
    result.coords = Coordinates(result.response.data['latitude'].text, result.response.data['longitude'].text, 0, yahoo_precision_to_google_zoom_mappings[result.response.data['result'].attrs['precision']])
    return result
 
class GoogleGeocoder(XMLGeocoder):
  """Google Maps' geocoder. Requires a 'google' key in settings.GEOCODING_KEYS to work correctly."""
  geocoder_url = u'http://maps.google.com/maps/geo'
  short_name = u'google',
  key_key = u'key'
  query_key = u'q'
  default_args = {u'output': u'xml'}
  
  def additional_processing(self, result):
    result.coords = Coordinates(*result.response.data['coordinates'].text.split(','))
    return result
 
class GeoNamesGeocoder(XMLGeocoder):
  """GeoNames' geocoder. Doesn't require an API key."""
  geocoder_url = u'http://ws.geonames.org/search'
  short_name = u'geonames'
  query_key = u'q'
  default_args = {u'maxRows': 1}
  
  def additional_processing(self, result):
    result.coords = Coordinates(result.response.data['lat'], result.response.data['lng'])
    return result
 
SHORT_NAME_MAPPINGS = {
  'yahoo': YahooGeocoder,
  'google': GoogleGeocoder,
  'geonames': GeoNamesGeocoder,
}