from django.core import validators

from django.core.exceptions import PermissionDenied

from django.utils.html import escape

from django.utils.safestring import mark_safe

from django.conf import settings

from django.utils.translation import ugettext, ungettext

from django.utils.encoding import smart_unicode, force_unicode

from django.utils.maxlength import LegacyMaxlength

FORM_FIELD_ID_PREFIX = 'id_'

class EmptyValue(Exception):

    "This is raised when empty data is provided"

    pass

class Manipulator(object):

    # List of permission strings. User must have at least one to manipulate.

    # None means everybody has permission.

    required_permission = ''

    def __init__(self):

        # List of FormField objects

        self.fields = []

    def __getitem__(self, field_name):

        "Looks up field by field name; raises KeyError on failure"

        for field in self.fields:

            if field.field_name == field_name:

                return field

        raise KeyError, "Field %s not found\n%s" % (field_name, repr(self.fields))

    def __delitem__(self, field_name):

        "Deletes the field with the given field name; raises KeyError on failure"

        for i, field in enumerate(self.fields):

            if field.field_name == field_name:

                del self.fields[i]

                return

        raise KeyError, "Field %s not found" % field_name

    def check_permissions(self, user):

        """Confirms user has required permissions to use this manipulator; raises

        PermissionDenied on failure."""

        if self.required_permission is None:

            return

        if user.has_perm(self.required_permission):

            return

        raise PermissionDenied

    def prepare(self, new_data):

        """

        Makes any necessary preparations to new_data, in place, before data has

        been validated.

        """

        for field in self.fields:

            field.prepare(new_data)

    def get_validation_errors(self, new_data):

        "Returns dictionary mapping field_names to error-message lists"

        errors = {}

        self.prepare(new_data)

        for field in self.fields:

            errors.update(field.get_validation_errors(new_data))

            val_name = 'validate_%s' % field.field_name

            if hasattr(self, val_name):

                val = getattr(self, val_name)

                try:

                    field.run_validator(new_data, val)

                except (validators.ValidationError, validators.CriticalValidationError), e:

                    errors.setdefault(field.field_name, []).extend(e.messages)

#            if field.is_required and not new_data.get(field.field_name, False):

#                errors.setdefault(field.field_name, []).append(ugettext_lazy('This field is required.'))

#                continue

#            try:

#                validator_list = field.validator_list

#                if hasattr(self, 'validate_%s' % field.field_name):

#                    validator_list.append(getattr(self, 'validate_%s' % field.field_name))

#                for validator in validator_list:

#                    if field.is_required or new_data.get(field.field_name, False) or hasattr(validator, 'always_test'):

#                        try:

#                            if hasattr(field, 'requires_data_list'):

#                                validator(new_data.getlist(field.field_name), new_data)

#                            else:

#                                validator(new_data.get(field.field_name, ''), new_data)

#                        except validators.ValidationError, e:

#                            errors.setdefault(field.field_name, []).extend(e.messages)

#            # If a CriticalValidationError is raised, ignore any other ValidationErrors

#            # for this particular field

#            except validators.CriticalValidationError, e:

#                errors.setdefault(field.field_name, []).extend(e.messages)

        return errors

    def save(self, new_data):

        "Saves the changes and returns the new object"

        # changes is a dictionary-like object keyed by field_name

        raise NotImplementedError

    def do_html2python(self, new_data):

        """

        Convert the data from HTML data types to Python datatypes, changing the

        object in place. This happens after validation but before storage. This

        must happen after validation because html2python functions aren't

        expected to deal with invalid input.

        """

        for field in self.fields:

            field.convert_post_data(new_data)

class FormWrapper(object):

    """

    A wrapper linking a Manipulator to the template system.

    This allows dictionary-style lookups of formfields. It also handles feeding

    prepopulated data and validation error messages to the formfield objects.

    """

    def __init__(self, manipulator, data=None, error_dict=None, edit_inline=True):

        self.manipulator = manipulator

        if data is None:

            data = {}

        if error_dict is None:

            error_dict = {}

        self.data = data

        self.error_dict = error_dict

        self._inline_collections = None

        self.edit_inline = edit_inline

    def __repr__(self):

        return repr(self.__dict__)

    def __getitem__(self, key):

        for field in self.manipulator.fields:

            if field.field_name == key:

                data = field.extract_data(self.data)

                return FormFieldWrapper(field, data, self.error_dict.get(field.field_name, []))

        if self.edit_inline:

            self.fill_inline_collections()

            for inline_collection in self._inline_collections:

                # The 'orig_name' comparison is for backwards compatibility

                # with hand-crafted forms.

                if inline_collection.name == key or (':' not in key and inline_collection.orig_name == key):

                    return inline_collection

        raise KeyError, "Could not find Formfield or InlineObjectCollection named %r" % key

    def fill_inline_collections(self):

        if not self._inline_collections:

            ic = []

            related_objects = self.manipulator.get_related_objects()

            for rel_obj in related_objects:

                data = rel_obj.extract_data(self.data)

                inline_collection = InlineObjectCollection(self.manipulator, rel_obj, data, self.error_dict)

                ic.append(inline_collection)

            self._inline_collections = ic

    def has_errors(self):

        return self.error_dict != {}

    def _get_fields(self):

        try:

            return self._fields

        except AttributeError:

            self._fields = [self.__getitem__(field.field_name) for field in self.manipulator.fields]

            return self._fields

    fields = property(_get_fields)

class FormFieldWrapper(object):

    "A bridge between the template system and an individual form field. Used by FormWrapper."

    def __init__(self, formfield, data, error_list):

        self.formfield, self.data, self.error_list = formfield, data, error_list

        self.field_name = self.formfield.field_name # for convenience in templates

    def __str__(self):

        "Renders the field"

        return unicode(self).encode('utf-8')

    def __unicode__(self):

        "Renders the field"

        return force_unicode(self.formfield.render(self.data))

    def __repr__(self):

        return '<FormFieldWrapper for "%s">' % self.formfield.field_name

    def field_list(self):

        """

        Like __str__(), but returns a list. Use this when the field's render()

        method returns a list.

        """

        return self.formfield.render(self.data)

    def errors(self):

        return self.error_list

    def html_error_list(self):

        if self.errors():

            return mark_safe('<ul class="errorlist"><li>%s</li></ul>' % '</li><li>'.join([escape(e) for e in self.errors()]))

        else:

            return mark_safe('')

    def get_id(self):

        return self.formfield.get_id()

class FormFieldCollection(FormFieldWrapper):

    "A utility class that gives the template access to a dict of FormFieldWrappers"

    def __init__(self, formfield_dict):

        self.formfield_dict = formfield_dict

    def __str__(self):

        return unicode(self).encode('utf-8')

    def __unicode__(self):

        return unicode(self.formfield_dict)

    def __getitem__(self, template_key):

        "Look up field by template key; raise KeyError on failure"

        return self.formfield_dict[template_key]

    def __repr__(self):

        return "<FormFieldCollection: %s>" % self.formfield_dict

    def errors(self):

        "Returns list of all errors in this collection's formfields"

        errors = []

        for field in self.formfield_dict.values():

            if hasattr(field, 'errors'):

                errors.extend(field.errors())

        return errors

    def has_errors(self):

        return bool(len(self.errors()))

    def html_combined_error_list(self):

        return mark_safe(''.join([field.html_error_list() for field in self.formfield_dict.values() if hasattr(field, 'errors')]))

class InlineObjectCollection(object):

    "An object that acts like a sparse list of form field collections."

    def __init__(self, parent_manipulator, rel_obj, data, errors):

        self.parent_manipulator = parent_manipulator

        self.rel_obj = rel_obj

        self.data = data

        self.errors = errors

        self._collections = None

        self.name = rel_obj.name

        # This is the name used prior to fixing #1839. Needs for backwards

        # compatibility.

        self.orig_name = rel_obj.opts.module_name

    def __len__(self):

        self.fill()

        return self._collections.__len__()

    def __getitem__(self, k):

        self.fill()

        return self._collections.__getitem__(k)

    def __setitem__(self, k, v):

        self.fill()

        return self._collections.__setitem__(k,v)

    def __delitem__(self, k):

        self.fill()

        return self._collections.__delitem__(k)

    def __iter__(self):

        self.fill()

        return iter(self._collections.values())

    def items(self):

        self.fill()

        return self._collections.items()

    def fill(self):

        if self._collections:

            return

        else:

            var_name = self.rel_obj.opts.object_name.lower()

            collections = {}

            orig = None

            if hasattr(self.parent_manipulator, 'original_object'):

                orig = self.parent_manipulator.original_object

            orig_list = self.rel_obj.get_list(orig)

            for i, instance in enumerate(orig_list):

                collection = {'original': instance}

                for f in self.rel_obj.editable_fields():

                    for field_name in f.get_manipulator_field_names(''):

                        full_field_name = '%s.%d.%s' % (var_name, i, field_name)

                        field = self.parent_manipulator[full_field_name]

                        data = field.extract_data(self.data)

                        errors = self.errors.get(full_field_name, [])

                        collection[field_name] = FormFieldWrapper(field, data, errors)

                collections[i] = FormFieldCollection(collection)

            self._collections = collections

class FormField(object):

    """Abstract class representing a form field.

    Classes that extend FormField should define the following attributes:

        field_name

            The field's name for use by programs.

        validator_list

            A list of validation tests (callback functions) that the data for

            this field must pass in order to be added or changed.

        is_required

            A Boolean. Is it a required field?

    Subclasses should also implement a render(data) method, which is responsible

    for rending the form field in XHTML.

    """

    # Provide backwards compatibility for the maxlength attribute and

    # argument for this class and all subclasses.

    __metaclass__ = LegacyMaxlength

    def __str__(self):

        return unicode(self).encode('utf-8')

    def __unicode__(self):

        return self.render(u'')

    def __repr__(self):

        return 'FormField "%s"' % self.field_name

    def prepare(self, new_data):

        "Hook for doing something to new_data (in place) before validation."

        pass

    def html2python(data):

        "Hook for converting an HTML datatype (e.g. 'on' for checkboxes) to a Python type"

        return data

    html2python = staticmethod(html2python)

    def render(self, data):

        raise NotImplementedError

    def get_member_name(self):

        if hasattr(self, 'member_name'):

            return self.member_name

        else:

            return self.field_name

    def extract_data(self, data_dict):

        if hasattr(self, 'requires_data_list') and hasattr(data_dict, 'getlist'):

            data = data_dict.getlist(self.get_member_name())

        else:

            data = data_dict.get(self.get_member_name(), None)

        if data is None:

            data = ''

        return data

    def convert_post_data(self, new_data):

        name = self.get_member_name()

        if self.field_name in new_data:

            d = new_data.getlist(self.field_name)

            try:

                converted_data = [self.__class__.html2python(data) for data in d]

            except ValueError:

                converted_data = d

            new_data.setlist(name, converted_data)

        else:

            try:

                #individual fields deal with None values themselves

                new_data.setlist(name, [self.__class__.html2python(None)])

            except EmptyValue:

                new_data.setlist(name, [])

    def run_validator(self, new_data, validator):

        if self.is_required or new_data.get(self.field_name, False) or hasattr(validator, 'always_test'):

            if hasattr(self, 'requires_data_list'):

                validator(new_data.getlist(self.field_name), new_data)

            else:

                validator(new_data.get(self.field_name, ''), new_data)

    def get_validation_errors(self, new_data):

        errors = {}

        if self.is_required and not new_data.get(self.field_name, False):

            errors.setdefault(self.field_name, []).append(ugettext('This field is required.'))

            return errors

        try:

            for validator in self.validator_list:

                try:

                    self.run_validator(new_data, validator)

                except validators.ValidationError, e:

                    errors.setdefault(self.field_name, []).extend(e.messages)

        # If a CriticalValidationError is raised, ignore any other ValidationErrors

        # for this particular field

        except validators.CriticalValidationError, e:

            errors.setdefault(self.field_name, []).extend(e.messages)

        return errors

    def get_id(self):

        "Returns the HTML 'id' attribute for this form field."

        return FORM_FIELD_ID_PREFIX + self.field_name

####################

# GENERIC WIDGETS  #

####################

class TextField(FormField):

    input_type = "text"

    def __init__(self, field_name, length=30, max_length=None, is_required=False, validator_list=None, member_name=None):

        if validator_list is None: validator_list = []

        self.field_name = field_name

        self.length, self.max_length = length, max_length

        self.is_required = is_required

        self.validator_list = [self.isValidLength, self.hasNoNewlines] + validator_list

        if member_name != None:

            self.member_name = member_name

    def isValidLength(self, data, form):

        if data and self.max_length and len(smart_unicode(data)) > self.max_length:

            raise validators.ValidationError, ungettext("Ensure your text is less than %s character.",

                "Ensure your text is less than %s characters.", self.max_length) % self.max_length

    def hasNoNewlines(self, data, form):

        if data and '\n' in data:

            raise validators.ValidationError, ugettext("Line breaks are not allowed here.")

    def render(self, data):

        if data is None:

            data = u''

        max_length = u''

        if self.max_length:

            max_length = u'maxlength="%s" ' % self.max_length

        return mark_safe(u'<input type="%s" id="%s" class="v%s%s" name="%s" size="%s" value="%s" %s/>' % \

            (self.input_type, self.get_id(), self.__class__.__name__, self.is_required and u' required' or '',

            self.field_name, self.length, escape(data), max_length))

    def html2python(data):

        return data

    html2python = staticmethod(html2python)

class PasswordField(TextField):

    input_type = "password"

class LargeTextField(TextField):

    def __init__(self, field_name, rows=10, cols=40, is_required=False, validator_list=None, max_length=None):

        if validator_list is None: validator_list = []

        self.field_name = field_name

        self.rows, self.cols, self.is_required = rows, cols, is_required

        self.validator_list = validator_list[:]

        if max_length:

            self.validator_list.append(self.isValidLength)

            self.max_length = max_length

    def render(self, data):

        if data is None:

            data = ''

        return mark_safe(u'<textarea id="%s" class="v%s%s" name="%s" rows="%s" cols="%s">%s</textarea>' % \

            (self.get_id(), self.__class__.__name__, self.is_required and u' required' or u'',

            self.field_name, self.rows, self.cols, escape(data)))

class HiddenField(FormField):

    def __init__(self, field_name, is_required=False, validator_list=None, max_length=None):

        if validator_list is None: validator_list = []

        self.field_name, self.is_required = field_name, is_required

        self.validator_list = validator_list[:]

    def render(self, data):

        return mark_safe(u'<input type="hidden" id="%s" name="%s" value="%s" />' % \

            (self.get_id(), self.field_name, escape(data)))

class CheckboxField(FormField):

    def __init__(self, field_name, checked_by_default=False, validator_list=None, is_required=False):

        if validator_list is None: validator_list = []

        self.field_name = field_name

        self.checked_by_default = checked_by_default

        self.is_required = is_required

        self.validator_list = validator_list[:]

    def render(self, data):

        checked_html = ''

        if data or (data is '' and self.checked_by_default):

            checked_html = ' checked="checked"'

        return mark_safe(u'<input type="checkbox" id="%s" class="v%s" name="%s"%s />' % \

            (self.get_id(), self.__class__.__name__,

            self.field_name, checked_html))

    def html2python(data):

        "Convert value from browser ('on' or '') to a Python boolean"

        if data == 'on':

            return True

        return False

    html2python = staticmethod(html2python)

class SelectField(FormField):

    def __init__(self, field_name, choices=None, size=1, is_required=False, validator_list=None, member_name=None):

        if validator_list is None: validator_list = []

        if choices is None: choices = []

        choices = [(k, smart_unicode(v, strings_only=True)) for k, v in choices]

        self.field_name = field_name

        # choices is a list of (value, human-readable key) tuples because order matters

        self.choices, self.size, self.is_required = choices, size, is_required

        self.validator_list = [self.isValidChoice] + validator_list

        if member_name != None:

            self.member_name = member_name

    def render(self, data):

        output = [u'<select id="%s" class="v%s%s" name="%s" size="%s">' % \

            (self.get_id(), self.__class__.__name__,

             self.is_required and u' required' or u'', self.field_name, self.size)]

        str_data = smart_unicode(data) # normalize to string

        for value, display_name in self.choices:

            selected_html = u''

            if smart_unicode(value) == str_data:

                selected_html = u' selected="selected"'

            output.append(u'    <option value="%s"%s>%s</option>' % (escape(value), selected_html, force_unicode(escape(display_name))))

        output.append(u'  </select>')

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

    def isValidChoice(self, data, form):

        str_data = smart_unicode(data)

        str_choices = [smart_unicode(item[0]) for item in self.choices]

        if str_data not in str_choices:

            raise validators.ValidationError, ugettext("Select a valid choice; '%(data)s' is not in %(choices)s.") % {'data': str_data, 'choices': str_choices}

class NullSelectField(SelectField):

    "This SelectField converts blank fields to None"

    def html2python(data):

        if not data:

            return None

        return data

    html2python = staticmethod(html2python)

class RadioSelectField(FormField):

    def __init__(self, field_name, choices=None, ul_class='', is_required=False, validator_list=None, member_name=None):

        if validator_list is None: validator_list = []

        if choices is None: choices = []

        choices = [(k, smart_unicode(v)) for k, v in choices]

        self.field_name = field_name

        # choices is a list of (value, human-readable key) tuples because order matters

        self.choices, self.is_required = choices, is_required