from django.conf import settings

from django.contrib.contenttypes.models import ContentType

from django.db import models

from django.db.models import signals

from django.db.models.base import ModelBase

from django.utils.functional import curry

from modeltranslation.fields import TranslationField 

from modeltranslation.utils import TranslationFieldDescriptor, build_localized_fieldname

class AlreadyRegistered(Exception):

    pass

class NotRegistered(Exception):

    pass

class TranslationOptions(object):

    """

    The TranslationOptions object is used to specify the fields to translate.

    The options are registered in combination with a model class at the

    ``modeltranslation.translator.translator`` instance.

    It caches the content type of the translated model for faster lookup later

    on.

    """

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

        # self.translation_model = None        

        self.model_ct = None

        self.localized_fieldnames = list()

#def get_localized_fieldnames(model):

def add_localized_fields(model):

    """

    Monkey patchs the original model class to provide additional fields for 

    every language. Only do that for fields which are defined in the 

    translation options of the model.

    Returns a dict mapping the original fieldname to a list containing the names 

    of the localized fields created for the original field.

    """

    localized_fields = dict()

    translation_opts = translator.get_options_for_model(model)

    for field_name in translation_opts.fields:                

        localized_fields[field_name] = list()

        for l in settings.LANGUAGES:            

            # Construct the name for the localized field

            localized_field_name = build_localized_fieldname(field_name, l[0])

            # Check if the model already has a field by that name 

            if hasattr(model, localized_field_name):

                raise ValueError("Error adding translation field. The model "\

                                 "'%s' already contains a field named '%s'. "\

                                 % (instance.__class__.__name__, localized_field_name))

            # This approach implements the translation fields as full valid

            # django model fields and therefore adds them via add_to_class

            localized_field = model.add_to_class(localized_field_name,

                                                 TranslationField(model._meta.get_field(field_name), 

                                                                  l[0]))             

            localized_fields[field_name].append(localized_field_name)

    return localized_fields        

    # model.add_to_class('current_language', CurrentLanguageField())        

#def translated_model_initialized(field_names, instance, **kwargs):

    #print "translated_model_initialized instance:", instance, ", field:", field_names

    #for field_name in field_names:

        #initial_val = getattr(instance, field_name)

        #print "  field: %s, initialval: %s" % (field_name, initial_val)

        #setattr(instance.__class__, field_name, TranslationFieldDescriptor(field_name,

                                                                           #initial_val))

#def translated_model_initializing(sender, args, kwargs, **signal_kwargs):

    #print "translated_model_initializing", sender, args, kwargs    

    #trans_opts = translator.get_options_for_model(sender)

    #for field_name in trans_opts.fields:

        #setattr(sender, field_name, TranslationFieldDescriptor(field_name))

class Translator(object):

    """

    A Translator object encapsulates an instance of a translator. Models are

    registered with the Translator using the register() method.

    """

    def __init__(self):

        self._registry = {} # model_class class -> translation_opts instance

    def register(self, model_or_iterable, translation_opts, **options):

        """

        Registers the given model(s) with the given translation options.

        The model(s) should be Model classes, not instances.

        If a model is already registered for translation, this will raise 

        AlreadyRegistered.

        """

        # Don't import the humongous validation code unless required

        if translation_opts and settings.DEBUG:

            from django.contrib.admin.validation import validate

        else:

            validate = lambda model, adminclass: None

        #if not translation_opts:

            #translation_opts = TranslationOptions                    

        if isinstance(model_or_iterable, ModelBase):

            model_or_iterable = [model_or_iterable]

        for model in model_or_iterable:

            if model in self._registry:

                raise AlreadyRegistered('The model %s is already registered for translation' % model.__name__)

            # If we got **options then dynamically construct a subclass of

            # translation_opts with those **options.

            if options:

                # For reasons I don't quite understand, without a __module__

                # the created class appears to "live" in the wrong place,

                # which causes issues later on.

                options['__module__'] = __name__

                translation_opts = type("%sAdmin" % model.__name__, (translation_opts,), options)

            # Validate (which might be a no-op)

            #validate(translation_opts, model)

            # Store the translation class associated to the model

            self._registry[model] = translation_opts    

            # Get the content type of the original model and store it on the

            # translation options for faster lookup later on.

            translation_opts.model_ct = ContentType.objects.get_for_model(model)                    

            # Add the localized fields to the model and store the names of these

            # fields in the model's translation options for faster lookup later

            # on.                                       

            translation_opts.localized_fieldnames = add_localized_fields(model)

            # Create a reverse dict mapping the localized_fieldnames to the 

            # original fieldname

            rev_dict = dict()

            for orig_name, loc_names in translation_opts.localized_fieldnames.items():

                for ln in loc_names:

                    rev_dict[ln] = orig_name

            translation_opts.localized_fieldnames_rev = rev_dict                    

        # print "Applying descriptor field for model %s" % model                        

        for field_name in translation_opts.fields:

            setattr(model, field_name, TranslationFieldDescriptor(field_name))

        #signals.pre_init.connect(translated_model_initializing, sender=model, weak=False)                        

    def unregister(self, model_or_iterable):

        """

        Unregisters the given model(s).

        If a model isn't already registered, this will raise NotRegistered.

        """

        if isinstance(model_or_iterable, ModelBase):

            model_or_iterable = [model_or_iterable]

        for model in model_or_iterable:

            if model not in self._registry:

                raise NotRegistered('The model "%s" is not registered for translation' % model.__name__)

            del self._registry[model]

    def get_options_for_model(self, model):

        """

        Returns the translation options for the given ``model``. If the 

        ``model`` is not registered a ``NotRegistered`` exception is raised.

        """

        try:

            return self._registry[model]

        except KeyError:

            raise NotRegistered('The model "%s" is not registered for translation' % model.__name__)

# This global object represents the singleton translator object

translator = Translator()