import pickle

from django.db.models import Field, BLANK_CHOICE_DASH
from django.utils.translation import ugettext_lazy, string_concat
from django.utils.encoding import smart_unicode
from django.utils.functional import curry

class PickledManyToManyField(Field):
    def __init__(self, to, to_field=None, **kwargs):
        to_field = to_field or to._meta.pk.name
        kwargs['verbose_name'] = kwargs.get('verbose_name', None)
        self.my_rel = PickledManyToManyRel(to, to_field,
            num_in_admin=kwargs.pop('num_in_admin', 0),
            filter_interface=kwargs.pop('filter_interface', None),
            limit_choices_to=kwargs.pop('limit_choices_to', None),
            raw_id_admin=kwargs.pop('raw_id_admin', False))
        if self.my_rel.raw_id_admin:
            kwargs.setdefault('validator_list', []).append(self.isValidIDList)
        super(PickledManyToManyField, self).__init__(**kwargs)

        if self.my_rel.raw_id_admin:
            msg = ugettext_lazy('Separate multiple IDs with commas.')
        else:
            msg = ugettext_lazy('Hold down "Control", or "Command" on a Mac, to select more than one.')
        self.help_text = string_concat(self.help_text, ' ', msg)

    def get_attname(self):
        return '%s_%ss' % (self.name, self.my_rel.to._meta.pk.name)

    def set_attributes_from_rel(self):
        self.name = self.name or self.get_attname()
        self.verbose_name = self.verbose_name or self.my_rel.to._meta.verbose_name
        self.my_rel.field_name = self.my_rel.field_name or self.my_rel.to._meta.pk.name

    def contribute_to_class(self, cls, name):
        super(PickledManyToManyField, self).contribute_to_class(cls, name)
        self.set_attributes_from_rel()
        self.related_query_name = lambda self: opts.object_name.lower()
        setattr(cls, self.name, PickledManyRelatedObjectDescriptor(self))
        standard_init = cls.__init__
        def unpickling_init(slf, *args, **kwargs):
            standard_init(slf, *args, **kwargs)
            value = getattr(slf, self.attname)
            if not isinstance(value, set):
                value = pickle.loads(value)
                setattr(slf, self.attname, value)
        cls.__init__ = unpickling_init

    def db_type(self):
        return 'text'

    def to_python(self, value):
        return pickle.loads(value)

    def get_db_prep_save(self, value):
        return pickle.dumps(value)

    ###############################################
    # this is just copy-pasted from ManyToManyField
    def get_manipulator_field_objs(self):
        from django import oldforms
        if self.my_rel.raw_id_admin:
            return [oldforms.RawIdAdminField]
        else:
            choices = self.get_choices_default()
            return [curry(oldforms.SelectMultipleField,
                          size=min(max(len(choices), 5), 15),
                          choices=choices)]

    def get_choices_default(self):
        return self.get_choices(include_blank=False)

    def get_choices(self, include_blank=True, blank_choice=BLANK_CHOICE_DASH):
        "Returns a list of tuples used as SelectField choices for this field."
        first_choice = include_blank and blank_choice or []
        if self.choices:
            return first_choice + list(self.choices)
        rel_model = self.my_rel.to
        if hasattr(self.my_rel, 'get_related_field'):
            lst = [(getattr(x, self.my_rel.get_related_field().attname), smart_unicode(x))
                   for x in rel_model._default_manager.complex_filter(self.my_rel.limit_choices_to)]
        else:
            lst = [(x._get_pk_val(), smart_unicode(x))
                   for x in rel_model._default_manager.complex_filter(self.my_rel.limit_choices_to)]
        return first_choice + lst

    def isValidIDList(self, field_data, all_data):
        "Validates that the value is a valid list of foreign keys"
        mod = self.my_rel.to
        try:
            pks = map(int, field_data.split(','))
        except ValueError:
            # the CommaSeparatedIntegerField validator will catch this error
            return
        objects = mod._default_manager.in_bulk(pks)
        if len(objects) != len(pks):
            badkeys = [k for k in pks if k not in objects]
            raise validators.ValidationError, ungettext("Please enter valid %(self)s IDs. The value %(value)r is invalid.",
                    "Please enter valid %(self)s IDs. The values %(value)r are invalid.", len(badkeys)) % {
                'self': self.verbose_name,
                'value': len(badkeys) == 1 and badkeys[0] or tuple(badkeys),
            }

    # end of copy-past
    ##################



class PickledManyRelatedObjectDescriptor(object):
    def __init__(self, field_with_rel):
        self.field = field_with_rel

    def __get__(self, instance, instance_type=None):
        if instance is None:
            raise AttributeError, "%s must be accessed via instance" % self.field.name

        self.field.renew_attfield(instance)
        val = getattr(instance, self.field.attname)

        rel_model = self.field.my_rel.to
        superclass = rel_model._default_manager.__class__
        RelatedManager = create_pickled_many_related_manager(superclass)

        manager = RelatedManager(
            model=rel_model,
            core_filters={'%s__in' % self.field.my_rel.field_name: val},
            instance=instance,
            attname=self.field.attname,
            )

        return manager

    def __set__(self, instance, value):
        if instance is None:
            raise AttributeError, "%s must be accessed via instance" % self._field.name
        # Set the value of the related field
        val = set()
        for obj in value:
            try:
                val.add(getattr(obj, self.field.my_rel.get_related_field().attname))
            except AttributeError:
                pass
        setattr(instance, self.field.attname, val)

        # Clear the cache, if it exists
        try:
            delattr(instance, self.field.get_cache_name())
        except AttributeError:
            pass


class PickledManyToManyRel(object):
    def __init__(self, to, field_name, num_in_admin=0, filter_interface=None, limit_choices_to=None, raw_id_admin=False):
        self.to = to
        self.field_name = field_name
        self.num_in_admin = num_in_admin
        self.filter_interface = filter_interface
        if limit_choices_to is None:
            limit_choices_to = {}
        self.limit_choices_to = limit_choices_to
        self.edit_inline = False
        self.raw_id_admin = raw_id_admin
        self.multiple = True

        self.related_name = '%s_%s_set' % (to._meta.pk.name, field_name)

        assert not (self.raw_id_admin and self.filter_interface), "ManyToManyRels may not use both raw_id_admin and filter_interface"

    # get_related_field = ManyToOneRel.get_related_field
    def get_related_field(self):
        "Returns the Field in the 'to' object to which this relationship is tied."
        return self.to._meta.get_field(self.field_name)


def create_pickled_many_related_manager(superclass):
    class RelatedManager(superclass):
        def __init__(self, model=None, core_filters=None, instance=None, attname=None):
            super(RelatedManager, self).__init__()
            self.model = model
            self.core_filters = core_filters
            self.instance = instance
            self.attname = attname

        def get_query_set(self):
            return superclass.get_query_set(self).filter(**(self.core_filters))

        def add(self, *objs):
            obj_pks = (obj.pk for obj in objs)
            setattr(self.instance, self.attname, getattr(self.instance, self.attname).union(obj_pks))
        add.alters_data = True

        def remove(self, *objs):
            obj_pks = (obj.pk for obj in objs)
            setattr(self.instance, self.attname, getattr(self.instance, self.attname).difference(obj_pks))
        remove.alters_data = True

        def clear(self):
            setattr(self.instance, self.attname, set())
        clear.alters_data = True

        def create(self, **kwargs):
            new_obj = self.model(**kwargs)
            new_obj.save()
            self.add(new_obj)
            return new_obj
        create.alters_data = True
    return RelatedManager