from django.db import models
from django.db.models.loading import BaseAppCache
from django.utils.module_loading import import_by_path


class ProjectState(object):
    """
    Represents the entire project's overall state.
    This is the item that is passed around - we do it here rather than at the
    app level so that cross-app FKs/etc. resolve properly.
    """

    def __init__(self, models=None):
        self.models = models or {}
        self.app_cache = None

    def clone(self):
        "Returns an exact copy of this ProjectState"
        return ProjectState(
            models = dict((k, v.copy()) for k, v in self.models.items())
        )

    def render(self):
        "Turns the project state into actual models in a new AppCache"
        if self.app_cache is None:
            self.app_cache = BaseAppCache()
            for model in self.model.values:
                model.render(self.app_cache)
        return self.app_cache

    @classmethod
    def from_app_cache(cls, app_cache):
        "Takes in an AppCache and returns a ProjectState matching it"
        models = {}
        for model in app_cache.get_models():
            model_state = ModelState.from_model(model)
            models[(model_state.app_label, model_state.name.lower())] = model_state
        return cls(models)


class ModelState(object):
    """
    Represents a Django Model. We don't use the actual Model class
    as it's not designed to have its options changed - instead, we
    mutate this one and then render it into a Model as required.
    """

    def __init__(self, app_label, name, fields=None, options=None, bases=None):
        self.app_label = app_label
        self.name = name
        self.fields = fields or []
        self.options = options or {}
        self.bases = bases or (models.Model, )

    @classmethod
    def from_model(cls, model):
        """
        Feed me a model, get a ModelState representing it out.
        """
        # Deconstruct the fields
        fields = []
        for field in model._meta.local_fields:
            name, path, args, kwargs = field.deconstruct()
            field_class = import_by_path(path)
            fields.append((name, field_class(*args, **kwargs)))
        # Make our record
        return cls(
            model._meta.app_label,
            model._meta.object_name,
            fields,
            {},
            None,
        )

    def clone(self):
        "Returns an exact copy of this ModelState"
        return self.__class__(
            app_label = self.app_label,
            name = self.name,
            fields = self.fields,
            options = self.options,
            bases = self.bases,
        )

    def render(self, app_cache):
        "Creates a Model object from our current state into the given app_cache"
        # First, make a Meta object
        meta_contents = {'app_label': self.app_label, "app_cache": app_cache}
        meta_contents.update(self.options)
        meta = type("Meta", tuple(), meta_contents)
        # Then, work out our bases
        # TODO: Use the actual bases
        if self.bases:
            raise NotImplementedError("Custom bases not quite done yet!")
        else:
            bases = [models.Model]
        # Turn fields into a dict for the body, add other bits
        body = dict(self.fields)
        body['Meta'] = meta
        body['__module__'] = "__fake__"
        # Then, make a Model object
        return type(
            self.name,
            tuple(bases),
            body,
        )