from django.conf import settings

from django.contrib.gis import geos

from django.template.loader import render_to_string

from django.utils.safestring import mark_safe

class GoogleMapException(Exception): pass

from django.contrib.gis.maps.google.overlays import GPolygon, GPolyline, GMarker, GIcon

# The default Google Maps URL (for the API javascript)

# TODO: Internationalize for Japan, UK, etc.

GOOGLE_MAPS_URL='http://maps.google.com/maps?file=api&v=%s&key='

class GoogleMap(object):

    "A class for generating Google Maps JavaScript."

    # String constants

    onunload = mark_safe('onunload="GUnload()"') # Cleans up after Google Maps

    vml_css  = mark_safe('v\:* {behavior:url(#default#VML);}') # CSS for IE VML

    xmlns    = mark_safe('xmlns:v="urn:schemas-microsoft-com:vml"') # XML Namespace (for IE VML).

    def __init__(self, key=None, api_url=None, version=None,

                 center=None, zoom=None, dom_id='map',

                 kml_urls=[], polylines=None, polygons=None, markers=None,

                 template='gis/google/google-map.js',

                 js_module='geodjango',

                 extra_context={}):

        # The Google Maps API Key defined in the settings will be used

        # if not passed in as a parameter.  The use of an API key is

        # _required_.

        if not key:

            try:

                self.key = settings.GOOGLE_MAPS_API_KEY

            except AttributeError:

                raise GoogleMapException('Google Maps API Key not found (try adding GOOGLE_MAPS_API_KEY to your settings).')

        else:

            self.key = key

        # Getting the Google Maps API version, defaults to using the latest ("2.x"),

        # this is not necessarily the most stable.

        if not version:

            self.version = getattr(settings, 'GOOGLE_MAPS_API_VERSION', '2.x')

        else:

            self.version = version

        # Can specify the API URL in the `api_url` keyword.

        if not api_url:

            self.api_url = mark_safe(getattr(settings, 'GOOGLE_MAPS_URL', GOOGLE_MAPS_URL) % self.version)

        else:

            self.api_url = api_url

        # Setting the DOM id of the map, the load function, the JavaScript

        # template, and the KML URLs array.

        self.dom_id = dom_id

        self.extra_context = extra_context

        self.js_module = js_module

        self.template = template

        self.kml_urls = kml_urls

        # Does the user want any GMarker, GPolygon, and/or GPolyline overlays?

        overlay_info = [[GMarker, markers, 'markers'],

                        [GPolygon, polygons, 'polygons'],

                        [GPolyline, polylines, 'polylines']]

        for overlay_class, overlay_list, varname in overlay_info:

            setattr(self, varname, [])

            if overlay_list:

                for overlay in overlay_list:

                    if isinstance(overlay, overlay_class):

                        getattr(self, varname).append(overlay)

                    else:

                        getattr(self, varname).append(overlay_class(overlay))

        # If GMarker, GPolygons, and/or GPolylines are used the zoom will be

        # automatically calculated via the Google Maps API.  If both a zoom

        # level and a center coordinate are provided with polygons/polylines,

        # no automatic determination will occur.

        self.calc_zoom = False

        if self.polygons or self.polylines  or self.markers:

            if center is None or zoom is None:

                self.calc_zoom = True

        # Defaults for the zoom level and center coordinates if the zoom

        # is not automatically calculated.

        if zoom is None: zoom = 4

        self.zoom = zoom

        if center is None: center = (0, 0)

        self.center = center

    def render(self):

        """

        Generates the JavaScript necessary for displaying this Google Map.

        """

        params = {'calc_zoom' : self.calc_zoom,

                  'center' : self.center,

                  'dom_id' : self.dom_id,

                  'js_module' : self.js_module,

                  'kml_urls' : self.kml_urls,

                  'zoom' : self.zoom,

                  'polygons' : self.polygons,

                  'polylines' : self.polylines,

                  'icons': self.icons,

                  'markers' : self.markers,

                  }

        params.update(self.extra_context)

        return render_to_string(self.template, params)

    @property

    def body(self):

        "Returns HTML body tag for loading and unloading Google Maps javascript."

        return mark_safe('<body %s %s>' % (self.onload, self.onunload))

    @property

    def onload(self):

        "Returns the `onload` HTML <body> attribute."

        return mark_safe('onload="%s.%s_load()"' % (self.js_module, self.dom_id))

    @property

    def api_script(self):

        "Returns the <script> tag for the Google Maps API javascript."

        return mark_safe('<script src="%s%s" type="text/javascript"></script>' % (self.api_url, self.key))

    @property

    def js(self):

        "Returns only the generated Google Maps JavaScript (no <script> tags)."

        return self.render()

    @property

    def scripts(self):

        "Returns all <script></script> tags required with Google Maps JavaScript."

        return mark_safe('%s\n  <script type="text/javascript">\n//<![CDATA[\n%s//]]>\n  </script>' % (self.api_script, self.js))

    @property

    def style(self):

        "Returns additional CSS styling needed for Google Maps on IE."

        return mark_safe('<style type="text/css">%s</style>' % self.vml_css)

    @property

    def xhtml(self):

        "Returns XHTML information needed for IE VML overlays."

        return mark_safe('<html xmlns="http://www.w3.org/1999/xhtml" %s>' % self.xmlns)

    @property

    def icons(self):

        "Returns a sequence of GIcon objects in this map."

        return set([marker.icon for marker in self.markers if marker.icon])

class GoogleMapSet(GoogleMap):

    def __init__(self, *args, **kwargs):

        """

        A class for generating sets of Google Maps that will be shown on the

        same page together.

        Example:

         gmapset = GoogleMapSet( GoogleMap( ... ), GoogleMap( ... ) )

         gmapset = GoogleMapSet( [ gmap1, gmap2] )

        """

        # The `google-multi.js` template is used instead of `google-single.js`

        # by default.

        template = kwargs.pop('template', 'gis/google/google-multi.js')

        # This is the template used to generate the GMap load JavaScript for

        # each map in the set.

        self.map_template = kwargs.pop('map_template', 'gis/google/google-single.js')

        # Running GoogleMap.__init__(), and resetting the template

        # value with default obtained above.

        super(GoogleMapSet, self).__init__(**kwargs)

        self.template = template

        # If a tuple/list passed in as first element of args, then assume

        if isinstance(args[0], (tuple, list)):

            self.maps = args[0]

        else:

            self.maps = args

        # Generating DOM ids for each of the maps in the set.

        self.dom_ids = ['map%d' % i for i in xrange(len(self.maps))]

    def load_map_js(self):

        """

        Returns JavaScript containing all of the loading routines for each

        map in this set.

        """

        result = []

        for dom_id, gmap in zip(self.dom_ids, self.maps):

            # Backup copies the GoogleMap DOM id and template attributes.

            # They are overridden on each GoogleMap instance in the set so

            # that only the loading JavaScript (and not the header variables)

            # is used with the generated DOM ids.

            tmp = (gmap.template, gmap.dom_id)

            gmap.template = self.map_template

            gmap.dom_id = dom_id

            result.append(gmap.js)

            # Restoring the backup values.

            gmap.template, gmap.dom_id = tmp

        return mark_safe(''.join(result))

    def render(self):

        """

        Generates the JavaScript for the collection of Google Maps in

        this set.

        """

        params = {'js_module' : self.js_module,

                  'dom_ids' : self.dom_ids,

                  'load_map_js' : self.load_map_js(),

                  'icons' : self.icons,

                  }

        params.update(self.extra_context)

        return render_to_string(self.template, params)

    @property

    def onload(self):

        "Returns the `onload` HTML <body> attribute."

        # Overloaded to use the `load` function defined in the

        # `google-multi.js`, which calls the load routines for

        # each one of the individual maps in the set.

        return mark_safe('onload="%s.load()"' % self.js_module)

    @property

    def icons(self):

        "Returns a sequence of all icons in each map of the set."

        icons = set()

        for map in self.maps: icons |= map.icons

        return icons