from django import forms, template

from django.forms.formsets import all_valid

from django.forms.models import modelform_factory, modelformset_factory, inlineformset_factory

from django.forms.models import BaseInlineFormSet

from django.contrib.contenttypes.models import ContentType

from django.contrib.admin import widgets

from django.contrib.admin import helpers

from django.contrib.admin.util import unquote, flatten_fieldsets, get_deleted_objects, model_ngettext, model_format_dict

from django.core.exceptions import PermissionDenied

from django.db import models, transaction

from django.db.models.fields import BLANK_CHOICE_DASH

from django.http import Http404, HttpResponse, HttpResponseRedirect

from django.shortcuts import get_object_or_404, render_to_response

from django.utils.datastructures import SortedDict

from django.utils.functional import update_wrapper

from django.utils.html import escape

from django.utils.safestring import mark_safe

from django.utils.functional import curry

from django.utils.text import capfirst, get_text_list

from django.utils.translation import ugettext as _

from django.utils.translation import ungettext, ugettext_lazy

from django.utils.encoding import force_unicode

try:

    set

except NameError:

    from sets import Set as set     # Python 2.3 fallback

HORIZONTAL, VERTICAL = 1, 2

# returns the <ul> class for a given radio_admin field

get_ul_class = lambda x: 'radiolist%s' % ((x == HORIZONTAL) and ' inline' or '')

class IncorrectLookupParameters(Exception):

    pass

# Defaults for formfield_overrides. ModelAdmin subclasses can change this

# by adding to ModelAdmin.formfield_overrides.

FORMFIELD_FOR_DBFIELD_DEFAULTS = {

    models.DateTimeField: {

        'form_class': forms.SplitDateTimeField,

        'widget': widgets.AdminSplitDateTime

    },

    models.DateField:    {'widget': widgets.AdminDateWidget},

    models.TimeField:    {'widget': widgets.AdminTimeWidget},

    models.TextField:    {'widget': widgets.AdminTextareaWidget},

    models.URLField:     {'widget': widgets.AdminURLFieldWidget},

    models.IntegerField: {'widget': widgets.AdminIntegerFieldWidget},

    models.CharField:    {'widget': widgets.AdminTextInputWidget},

    models.ImageField:   {'widget': widgets.AdminFileWidget},

    models.FileField:    {'widget': widgets.AdminFileWidget},

}

class BaseModelAdmin(object):

    """Functionality common to both ModelAdmin and InlineAdmin."""

    raw_id_fields = ()

    fields = None

    exclude = None

    fieldsets = None

    form = forms.ModelForm

    filter_vertical = ()

    filter_horizontal = ()

    radio_fields = {}

    prepopulated_fields = {}

    formfield_overrides = {}

    def __init__(self):

        self.formfield_overrides = dict(FORMFIELD_FOR_DBFIELD_DEFAULTS, **self.formfield_overrides)

    def formfield_for_dbfield(self, db_field, **kwargs):

        """

        Hook for specifying the form Field instance for a given database Field

        instance.

        If kwargs are given, they're passed to the form Field's constructor.

        """

        request = kwargs.pop("request", None)

        # If the field specifies choices, we don't need to look for special

        # admin widgets - we just need to use a select widget of some kind.

        if db_field.choices:

            return self.formfield_for_choice_field(db_field, request, **kwargs)

        # ForeignKey or ManyToManyFields

        if isinstance(db_field, (models.ForeignKey, models.ManyToManyField)):

            # Combine the field kwargs with any options for formfield_overrides.

            # Make sure the passed in **kwargs override anything in

            # formfield_overrides because **kwargs is more specific, and should

            # always win.

            if db_field.__class__ in self.formfield_overrides:

                kwargs = dict(self.formfield_overrides[db_field.__class__], **kwargs)

            # Get the correct formfield.

            if isinstance(db_field, models.ForeignKey):

                formfield = self.formfield_for_foreignkey(db_field, request, **kwargs)

            elif isinstance(db_field, models.ManyToManyField):

                formfield = self.formfield_for_manytomany(db_field, request, **kwargs)

            # For non-raw_id fields, wrap the widget with a wrapper that adds

            # extra HTML -- the "add other" interface -- to the end of the

            # rendered output. formfield can be None if it came from a

            # OneToOneField with parent_link=True or a M2M intermediary.

            if formfield and db_field.name not in self.raw_id_fields:

                formfield.widget = widgets.RelatedFieldWidgetWrapper(formfield.widget, db_field.rel, self.admin_site)

            return formfield

        # If we've got overrides for the formfield defined, use 'em. **kwargs

        # passed to formfield_for_dbfield override the defaults.

        for klass in db_field.__class__.mro():

            if klass in self.formfield_overrides:

                kwargs = dict(self.formfield_overrides[klass], **kwargs)

                return db_field.formfield(**kwargs)

        # For any other type of field, just call its formfield() method.

        return db_field.formfield(**kwargs)

    def formfield_for_choice_field(self, db_field, request=None, **kwargs):

        """

        Get a form Field for a database Field that has declared choices.

        """

        # If the field is named as a radio_field, use a RadioSelect

        if db_field.name in self.radio_fields:

            # Avoid stomping on custom widget/choices arguments.

            if 'widget' not in kwargs:

                kwargs['widget'] = widgets.AdminRadioSelect(attrs={

                    'class': get_ul_class(self.radio_fields[db_field.name]),

                })

            if 'choices' not in kwargs:

                kwargs['choices'] = db_field.get_choices(

                    include_blank = db_field.blank,

                    blank_choice=[('', _('None'))]

                )

        return db_field.formfield(**kwargs)

    def formfield_for_foreignkey(self, db_field, request=None, **kwargs):

        """

        Get a form Field for a ForeignKey.

        """

        if db_field.name in self.raw_id_fields:

            kwargs['widget'] = widgets.ForeignKeyRawIdWidget(db_field.rel)

        elif db_field.name in self.radio_fields:

            kwargs['widget'] = widgets.AdminRadioSelect(attrs={

                'class': get_ul_class(self.radio_fields[db_field.name]),

            })

            kwargs['empty_label'] = db_field.blank and _('None') or None

        return db_field.formfield(**kwargs)

    def formfield_for_manytomany(self, db_field, request=None, **kwargs):

        """

        Get a form Field for a ManyToManyField.

        """

        # If it uses an intermediary model, don't show field in admin.

        if db_field.rel.through is not None:

            return None

        if db_field.name in self.raw_id_fields:

            kwargs['widget'] = widgets.ManyToManyRawIdWidget(db_field.rel)

            kwargs['help_text'] = ''

        elif db_field.name in (list(self.filter_vertical) + list(self.filter_horizontal)):

            kwargs['widget'] = widgets.FilteredSelectMultiple(db_field.verbose_name, (db_field.name in self.filter_vertical))

        return db_field.formfield(**kwargs)

    def _declared_fieldsets(self):

        if self.fieldsets:

            return self.fieldsets

        elif self.fields:

            return [(None, {'fields': self.fields})]

        return None

    declared_fieldsets = property(_declared_fieldsets)

class ModelAdmin(BaseModelAdmin):

    "Encapsulates all admin options and functionality for a given model."

    __metaclass__ = forms.MediaDefiningClass

    list_display = ('__str__',)

    list_display_links = ()

    list_filter = ()

    list_select_related = False

    list_per_page = 100

    list_editable = ()

    search_fields = ()

    date_hierarchy = None

    save_as = False

    save_on_top = False

    ordering = None

    inlines = []

    # Custom templates (designed to be over-ridden in subclasses)

    change_form_template = None

    change_list_template = None

    delete_confirmation_template = None

    object_history_template = None

    # Actions

    actions = []

    action_form = helpers.ActionForm

    actions_on_top = True

    actions_on_bottom = False

    def __init__(self, model, admin_site):

        self.model = model

        self.opts = model._meta

        self.admin_site = admin_site

        self.inline_instances = []

        for inline_class in self.inlines:

            inline_instance = inline_class(self.model, self.admin_site)

            self.inline_instances.append(inline_instance)

        if 'action_checkbox' not in self.list_display and self.actions is not None:

            self.list_display = ['action_checkbox'] +  list(self.list_display)

        if not self.list_display_links:

            for name in self.list_display:

                if name != 'action_checkbox':

                    self.list_display_links = [name]

                    break

        super(ModelAdmin, self).__init__()

    def get_urls(self):

        from django.conf.urls.defaults import patterns, url

        def wrap(view):

            def wrapper(*args, **kwargs):

                return self.admin_site.admin_view(view)(*args, **kwargs)

            return update_wrapper(wrapper, view)

        info = self.model._meta.app_label, self.model._meta.module_name

        urlpatterns = patterns('',

            url(r'^$',

                wrap(self.changelist_view),

                name='%s_%s_changelist' % info),

            url(r'^add/$',

                wrap(self.add_view),

                name='%s_%s_add' % info),

            url(r'^(.+)/history/$',

                wrap(self.history_view),

                name='%s_%s_history' % info),

            url(r'^(.+)/delete/$',

                wrap(self.delete_view),

                name='%s_%s_delete' % info),

            url(r'^(.+)/$',

                wrap(self.change_view),

                name='%s_%s_change' % info),

        )

        return urlpatterns

    def urls(self):

        return self.get_urls()

    urls = property(urls)

    def _media(self):

        from django.conf import settings

        js = ['js/core.js', 'js/admin/RelatedObjectLookups.js']

        if self.actions is not None:

            js.extend(['js/getElementsBySelector.js', 'js/actions.js'])

        if self.prepopulated_fields:

            js.append('js/urlify.js')

        if self.opts.get_ordered_objects():

            js.extend(['js/getElementsBySelector.js', 'js/dom-drag.js' , 'js/admin/ordering.js'])

        return forms.Media(js=['%s%s' % (settings.ADMIN_MEDIA_PREFIX, url) for url in js])

    media = property(_media)

    def has_add_permission(self, request):

        "Returns True if the given request has permission to add an object."

        opts = self.opts

        return request.user.has_perm(opts.app_label + '.' + opts.get_add_permission())

    def has_change_permission(self, request, obj=None):

        """

        Returns True if the given request has permission to change the given

        Django model instance.

        If `obj` is None, this should return True if the given request has

        permission to change *any* object of the given type.

        """

        opts = self.opts

        return request.user.has_perm(opts.app_label + '.' + opts.get_change_permission())

    def has_delete_permission(self, request, obj=None):

        """

        Returns True if the given request has permission to change the given

        Django model instance.

        If `obj` is None, this should return True if the given request has

        permission to delete *any* object of the given type.

        """

        opts = self.opts

        return request.user.has_perm(opts.app_label + '.' + opts.get_delete_permission())

    def get_model_perms(self, request):

        """

        Returns a dict of all perms for this model. This dict has the keys

        ``add``, ``change``, and ``delete`` mapping to the True/False for each

        of those actions.

        """

        return {

            'add': self.has_add_permission(request),

            'change': self.has_change_permission(request),

            'delete': self.has_delete_permission(request),

        }

    def queryset(self, request):

        """

        Returns a QuerySet of all model instances that can be edited by the

        admin site. This is used by changelist_view.

        """

        qs = self.model._default_manager.get_query_set()

        # TODO: this should be handled by some parameter to the ChangeList.

        ordering = self.ordering or () # otherwise we might try to *None, which is bad ;)

        if ordering:

            qs = qs.order_by(*ordering)

        return qs

    def get_fieldsets(self, request, obj=None):

        "Hook for specifying fieldsets for the add form."

        if self.declared_fieldsets:

            return self.declared_fieldsets

        form = self.get_form(request, obj)

        return [(None, {'fields': form.base_fields.keys()})]

    def get_form(self, request, obj=None, **kwargs):

        """

        Returns a Form class for use in the admin add view. This is used by

        add_view and change_view.

        """

        if self.declared_fieldsets:

            fields = flatten_fieldsets(self.declared_fieldsets)

        else:

            fields = None

        if self.exclude is None:

            exclude = []

        else:

            exclude = list(self.exclude)

        # if exclude is an empty list we pass None to be consistant with the

        # default on modelform_factory

        defaults = {

            "form": self.form,

            "fields": fields,

            "exclude": (exclude + kwargs.get("exclude", [])) or None,

            "formfield_callback": curry(self.formfield_for_dbfield, request=request),

        }

        defaults.update(kwargs)

        return modelform_factory(self.model, **defaults)

    def get_changelist_form(self, request, **kwargs):

        """

        Returns a Form class for use in the Formset on the changelist page.

        """

        defaults = {

            "formfield_callback": curry(self.formfield_for_dbfield, request=request),

        }

        defaults.update(kwargs)

        return modelform_factory(self.model, **defaults)

    def get_changelist_formset(self, request, **kwargs):

        """

        Returns a FormSet class for use on the changelist page if list_editable

        is used.

        """

        defaults = {

            "formfield_callback": curry(self.formfield_for_dbfield, request=request),

        }

        defaults.update(kwargs)

        return modelformset_factory(self.model,

            self.get_changelist_form(request), extra=0,

            fields=self.list_editable, **defaults)

    def get_formsets(self, request, obj=None):

        for inline in self.inline_instances:

            yield inline.get_formset(request, obj)

    def log_addition(self, request, object):

        """

        Log that an object has been successfully added.

        The default implementation creates an admin LogEntry object.

        """

        from django.contrib.admin.models import LogEntry, ADDITION

        LogEntry.objects.log_action(

            user_id         = request.user.pk,

            content_type_id = ContentType.objects.get_for_model(object).pk,

            object_id       = object.pk,

            object_repr     = force_unicode(object),

            action_flag     = ADDITION

        )

    def log_change(self, request, object, message):

        """

        Log that an object has been successfully changed.

        The default implementation creates an admin LogEntry object.

        """

        from django.contrib.admin.models import LogEntry, CHANGE

        LogEntry.objects.log_action(