"""

HTML Widget classes

"""

import django.utils.copycompat as copy

from itertools import chain

from django.conf import settings

from django.utils.datastructures import MultiValueDict, MergeDict

from django.utils.html import escape, conditional_escape

from django.utils.translation import ugettext

from django.utils.encoding import StrAndUnicode, force_unicode

from django.utils.safestring import mark_safe

from django.utils import datetime_safe, formats

import time

import datetime

from util import flatatt

from urlparse import urljoin

__all__ = (

    'Media', 'MediaDefiningClass', 'Widget', 'TextInput', 'PasswordInput',

    'HiddenInput', 'MultipleHiddenInput',

    'FileInput', 'DateInput', 'DateTimeInput', 'TimeInput', 'Textarea', 'CheckboxInput',

    'Select', 'NullBooleanSelect', 'SelectMultiple', 'RadioSelect',

    'CheckboxSelectMultiple', 'MultiWidget',

    'SplitDateTimeWidget',

)

MEDIA_TYPES = ('css','js')

class Media(StrAndUnicode):

    def __init__(self, media=None, **kwargs):

        if media:

            media_attrs = media.__dict__

        else:

            media_attrs = kwargs

        self._css = {}

        self._js = []

        for name in MEDIA_TYPES:

            getattr(self, 'add_' + name)(media_attrs.get(name, None))

        # Any leftover attributes must be invalid.

        # if media_attrs != {}:

        #     raise TypeError("'class Media' has invalid attribute(s): %s" % ','.join(media_attrs.keys()))

    def __unicode__(self):

        return self.render()

    def render(self):

        return mark_safe(u'\n'.join(chain(*[getattr(self, 'render_' + name)() for name in MEDIA_TYPES])))

    def render_js(self):

        return [u'<script type="text/javascript" src="%s"></script>' % self.absolute_path(path) for path in self._js]

    def render_css(self):

        # To keep rendering order consistent, we can't just iterate over items().

        # We need to sort the keys, and iterate over the sorted list.

        media = self._css.keys()

        media.sort()

        return chain(*[

            [u'<link href="%s" type="text/css" media="%s" rel="stylesheet" />' % (self.absolute_path(path), medium)

                    for path in self._css[medium]]

                for medium in media])

    def absolute_path(self, path):

        if path.startswith(u'http://') or path.startswith(u'https://') or path.startswith(u'/'):

            return path

        return urljoin(settings.MEDIA_URL,path)

    def __getitem__(self, name):

        "Returns a Media object that only contains media of the given type"

        if name in MEDIA_TYPES:

            return Media(**{str(name): getattr(self, '_' + name)})

        raise KeyError('Unknown media type "%s"' % name)

    def add_js(self, data):

        if data:

            for path in data:

                if path not in self._js:

                    self._js.append(path)

    def add_css(self, data):

        if data:

            for medium, paths in data.items():

                for path in paths:

                    if not self._css.get(medium) or path not in self._css[medium]:

                        self._css.setdefault(medium, []).append(path)

    def __add__(self, other):

        combined = Media()

        for name in MEDIA_TYPES:

            getattr(combined, 'add_' + name)(getattr(self, '_' + name, None))

            getattr(combined, 'add_' + name)(getattr(other, '_' + name, None))

        return combined

def media_property(cls):

    def _media(self):

        # Get the media property of the superclass, if it exists

        if hasattr(super(cls, self), 'media'):

            base = super(cls, self).media

        else:

            base = Media()

        # Get the media definition for this class

        definition = getattr(cls, 'Media', None)

        if definition:

            extend = getattr(definition, 'extend', True)

            if extend:

                if extend == True:

                    m = base

                else:

                    m = Media()

                    for medium in extend:

                        m = m + base[medium]

                return m + Media(definition)

            else:

                return Media(definition)

        else:

            return base

    return property(_media)

class MediaDefiningClass(type):

    "Metaclass for classes that can have media definitions"

    def __new__(cls, name, bases, attrs):

        new_class = super(MediaDefiningClass, cls).__new__(cls, name, bases,

                                                           attrs)

        if 'media' not in attrs:

            new_class.media = media_property(new_class)

        return new_class

class Widget(object):

    __metaclass__ = MediaDefiningClass

    is_hidden = False          # Determines whether this corresponds to an <input type="hidden">.

    needs_multipart_form = False # Determines does this widget need multipart-encrypted form

    is_localized = False

    def __init__(self, attrs=None):

        if attrs is not None:

            self.attrs = attrs.copy()

        else:

            self.attrs = {}

    def __deepcopy__(self, memo):

        obj = copy.copy(self)

        obj.attrs = self.attrs.copy()

        memo[id(self)] = obj

        return obj

    def render(self, name, value, attrs=None):

        """

        Returns this Widget rendered as HTML, as a Unicode string.

        The 'value' given is not guaranteed to be valid input, so subclass

        implementations should program defensively.

        """

        raise NotImplementedError

    def build_attrs(self, extra_attrs=None, **kwargs):

        "Helper function for building an attribute dictionary."

        attrs = dict(self.attrs, **kwargs)

        if extra_attrs:

            attrs.update(extra_attrs)

        return attrs

    def value_from_datadict(self, data, files, name):

        """

        Given a dictionary of data and this widget's name, returns the value

        of this widget. Returns None if it's not provided.

        """

        return data.get(name, None)

    def _has_changed(self, initial, data):

        """

        Return True if data differs from initial.

        """

        # For purposes of seeing whether something has changed, None is

        # the same as an empty string, if the data or inital value we get

        # is None, replace it w/ u''.

        if data is None:

            data_value = u''

        else:

            data_value = data

        if initial is None:

            initial_value = u''

        else:

            initial_value = initial

        if force_unicode(initial_value) != force_unicode(data_value):

            return True

        return False

    def id_for_label(self, id_):

        """

        Returns the HTML ID attribute of this Widget for use by a <label>,

        given the ID of the field. Returns None if no ID is available.

        This hook is necessary because some widgets have multiple HTML

        elements and, thus, multiple IDs. In that case, this method should

        return an ID value that corresponds to the first ID in the widget's

        tags.

        """

        return id_

    id_for_label = classmethod(id_for_label)

class Input(Widget):

    """

    Base class for all <input> widgets (except type='checkbox' and

    type='radio', which are special).

    """

    input_type = None # Subclasses must define this.

    def _format_value(self, value):

        if self.is_localized:

            return formats.localize_input(value)

        return value

    def render(self, name, value, attrs=None):

        if value is None:

            value = ''

        final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)

        if value != '':

            # Only add the 'value' attribute if a value is non-empty.

            final_attrs['value'] = force_unicode(self._format_value(value))

        return mark_safe(u'<input%s />' % flatatt(final_attrs))

class TextInput(Input):

    input_type = 'text'

class PasswordInput(Input):

    input_type = 'password'

    def __init__(self, attrs=None, render_value=True):

        super(PasswordInput, self).__init__(attrs)

        self.render_value = render_value

    def render(self, name, value, attrs=None):

        if not self.render_value: value=None

        return super(PasswordInput, self).render(name, value, attrs)

class HiddenInput(Input):

    input_type = 'hidden'

    is_hidden = True

class MultipleHiddenInput(HiddenInput):

    """

    A widget that handles <input type="hidden"> for fields that have a list

    of values.

    """

    def __init__(self, attrs=None, choices=()):

        super(MultipleHiddenInput, self).__init__(attrs)

        # choices can be any iterable

        self.choices = choices

    def render(self, name, value, attrs=None, choices=()):

        if value is None: value = []

        final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)

        id_ = final_attrs.get('id', None)

        inputs = []

        for i, v in enumerate(value):

            input_attrs = dict(value=force_unicode(v), **final_attrs)

            if id_:

                # An ID attribute was given. Add a numeric index as a suffix

                # so that the inputs don't all have the same ID attribute.

                input_attrs['id'] = '%s_%s' % (id_, i)

            inputs.append(u'<input%s />' % flatatt(input_attrs))

        return mark_safe(u'\n'.join(inputs))

    def value_from_datadict(self, data, files, name):

        if isinstance(data, (MultiValueDict, MergeDict)):

            return data.getlist(name)

        return data.get(name, None)

class FileInput(Input):

    input_type = 'file'

    needs_multipart_form = True

    def render(self, name, value, attrs=None):

        return super(FileInput, self).render(name, None, attrs=attrs)

    def value_from_datadict(self, data, files, name):

        "File widgets take data from FILES, not POST"

        return files.get(name, None)

    def _has_changed(self, initial, data):

        if data is None:

            return False

        return True

class Textarea(Widget):

    def __init__(self, attrs=None):

        # The 'rows' and 'cols' attributes are required for HTML correctness.

        default_attrs = {'cols': '40', 'rows': '10'}

        if attrs:

            default_attrs.update(attrs)

        super(Textarea, self).__init__(default_attrs)

    def render(self, name, value, attrs=None):

        if value is None: value = ''

        final_attrs = self.build_attrs(attrs, name=name)

        return mark_safe(u'<textarea%s>%s</textarea>' % (flatatt(final_attrs),

                conditional_escape(force_unicode(value))))

class DateInput(Input):

    input_type = 'text'

    format = '%Y-%m-%d'     # '2006-10-25'

    def __init__(self, attrs=None, format=None):

        super(DateInput, self).__init__(attrs)

        if format:

            self.format = format

    def _format_value(self, value):

        if self.is_localized:

            return formats.localize_input(value)

        elif hasattr(value, 'strftime'):

            value = datetime_safe.new_date(value)

            return value.strftime(self.format)

        return value

    def _has_changed(self, initial, data):

        # If our field has show_hidden_initial=True, initial will be a string

        # formatted by HiddenInput using formats.localize_input, which is not

        # necessarily the format used for this widget. Attempt to convert it.

        try:

            input_format = formats.get_format('DATE_INPUT_FORMATS')[0]

            initial = datetime.date(*time.strptime(initial, input_format)[:3])

        except (TypeError, ValueError):

            pass

        return super(DateInput, self)._has_changed(self._format_value(initial), data)

class DateTimeInput(Input):

    input_type = 'text'

    format = '%Y-%m-%d %H:%M:%S'     # '2006-10-25 14:30:59'

    def __init__(self, attrs=None, format=None):

        super(DateTimeInput, self).__init__(attrs)

        if format:

            self.format = format

    def _format_value(self, value):

        if self.is_localized:

            return formats.localize_input(value)

        elif hasattr(value, 'strftime'):

            value = datetime_safe.new_datetime(value)

            return value.strftime(self.format)

        return value

    def _has_changed(self, initial, data):

        # If our field has show_hidden_initial=True, initial will be a string

        # formatted by HiddenInput using formats.localize_input, which is not

        # necessarily the format used for this widget. Attempt to convert it.

        try:

            input_format = formats.get_format('DATETIME_INPUT_FORMATS')[0]

            initial = datetime.datetime(*time.strptime(initial, input_format)[:6])

        except (TypeError, ValueError):

            pass

        return super(DateTimeInput, self)._has_changed(self._format_value(initial), data)

class TimeInput(Input):

    input_type = 'text'

    format = '%H:%M:%S'     # '14:30:59'

    def __init__(self, attrs=None, format=None):

        super(TimeInput, self).__init__(attrs)

        if format:

            self.format = format

    def _format_value(self, value):

        if self.is_localized:

            return formats.localize_input(value)

        elif hasattr(value, 'strftime'):

            return value.strftime(self.format)

        return value

    def _has_changed(self, initial, data):

        # If our field has show_hidden_initial=True, initial will be a string

        # formatted by HiddenInput using formats.localize_input, which is not

        # necessarily the format used for this  widget. Attempt to convert it.

        try:

            input_format = formats.get_format('TIME_INPUT_FORMATS')[0]

            initial = datetime.time(*time.strptime(initial, input_format)[3:6])

        except (TypeError, ValueError):

            pass

        return super(TimeInput, self)._has_changed(self._format_value(initial), data)

class CheckboxInput(Widget):

    def __init__(self, attrs=None, check_test=bool):

        super(CheckboxInput, self).__init__(attrs)

        # check_test is a callable that takes a value and returns True

        # if the checkbox should be checked for that value.

        self.check_test = check_test

    def render(self, name, value, attrs=None):

        final_attrs = self.build_attrs(attrs, type='checkbox', name=name)