import logging
import uuid

from django.apps import apps
from django.core.exceptions import ValidationError
from django.db import models, transaction

logger = logging.getLogger(__name__)

class ProtocolManager(models.Manager):
    #TODO: check id must be the same
    #TODO: check owner must be the same
    @transaction.atomic
    def create_new_revision(self, protocol_id, revision_def, app):
        # lock the protocol
        owner = revision_def.get('owner', None)
        if not owner:
            raise ValidationError("Must have an owner")

        last_revision_modified = False

        if protocol_id is None:
            protocol = self.model(app=app, owner=owner)
            protocol.save()
            protocol_revision_model = apps.get_model(app_label='protocols', model_name='ProtocolRevision')
            last_revision = protocol_revision_model(protocol=protocol)
            last_revision_modified = True
        else:
            protocol = self.select_for_update().get(ext_id=protocol_id, app=app)
            revision_nb = revision_def.get('version')
            last_revision = protocol.last_revision()
            if last_revision is not None and (revision_nb is None or revision_nb != last_revision.version):
                raise ValidationError("Bad protocol revision number when creating new revision")


        # create new protocol revision update protocol revision title and description

        title = revision_def.get('title', None)
        description = revision_def.get('description', None)

        last_revision_modified = last_revision_modified or \
            (title != last_revision.title or description != last_revision.description)

        metacategory_model = apps.get_model(app_label='protocols', model_name='Metacategory')
        new_metacategories = [metacategory_model.objects.get_or_create_revision(app, **metacategory_def) for metacategory_def in revision_def.get('metacategories', [])]

        if not last_revision_modified:
            new_metacategories_ids = { mc.ext_id for mc in new_metacategories }
            old_metacategories_ids = { mc.ext_id for mc in last_revision.metacategories.all() }

            last_revision_modified = (new_metacategories_ids != old_metacategories_ids )

            if last_revision_modified:
                logger.debug("metacategaories modified %r, %r", new_metacategories_ids, old_metacategories_ids)


        if last_revision_modified:
            last_revision.pk = None
            last_revision.ext_id = uuid.uuid4()
            if title is not None:
                last_revision.title = title
            if description is not None:
                last_revision.description = description
            last_revision.save()

            last_revision.metacategories.add(*new_metacategories)

        return last_revision

    @transaction.atomic
    def create_from_default(self, title, description, owner, app):
        metacategory_model = apps.get_model(app_label='protocols', model_name='Metacategory')
        default_metacategories = metacategory_model.objects.filter(is_default=True, app=app)

        protocol = self.create(app=app, owner=owner)

        protocol_revision_model = apps.get_model(app_label='protocols', model_name='ProtocolRevision')

        protocol_revision = protocol_revision_model.objects.create(protocol=protocol, title=title, description=description)

        protocol_revision.metacategories.set([mc.revisions.all().last() for mc in default_metacategories])
        protocol_revision.save()

        return protocol


class MetacategoryManager(models.Manager):


    @transaction.atomic
    def create_with_revision(self, *args, **kwargs):
        instance = self.create(*args, **kwargs)
        metacategory_revision_model = apps.get_model(app_label='protocols', model_name='MetacategoryRevision')
        revision = metacategory_revision_model.objects.create(base=instance, **{k : kwargs.get(k) for k in ['title', 'label', 'description', 'color', 'has_comment']})

        return instance


    @transaction.atomic
    def get_or_create_revision(self, app, **kwargs):

        # cases :
        # id: none, base: none
        #   -> create metacategory + revision
        # id: <>, base: none
        #   -> error
        # id: <>, base: <>
        #   -> compare filed values
        #   -> if same : return current instance, if not same : create new revision
        # id: none, base: <>
        #   -> compare to last revision. if different, create new revision else return revision
        id = kwargs.get('id')
        base = kwargs.get('base')

        if id is not None and base is None:
            raise ValidationError("Id is not empty and base is empty")

        metacategory = None
        metacategory_created = False
        if base is None:
            metacategory_created = True
            metacategory = self.model(
                app=app,
                title=kwargs.get('title'),
                label=kwargs.get('label'),
                description=kwargs.get('description'),
                color=kwargs.get('color'),
                has_comment=kwargs.get('has_comment', False),
                is_default=False
            )
            metacategory.save()
        else:
            metacategory = self.get(ext_id=base, app=app)

        revision = None
        metacategory_revision_model = apps.get_model(app_label='protocols', model_name='MetacategoryRevision')

        if id is None and not metacategory_created:
            revision = metacategory.last_revision()
        elif not metacategory_created:
            revision = metacategory_revision_model.objects.get(ext_id=id)

        must_create_revision = (revision is None)
        if revision is not None:
            must_create_revision = \
                (revision.title != kwargs.get('title')) or \
                (revision.label != kwargs.get('label')) or \
                (revision.description != kwargs.get('description')) or \
                (revision.color != kwargs.get('color')) or \
                (revision.has_comment != kwargs.get('has_comment', False))

        if must_create_revision:
            revision = metacategory_revision_model.objects.create(
                base=metacategory,
                title=kwargs.get('title'),
                label=kwargs.get('label'),
                description=kwargs.get('description'),
                color=kwargs.get('color'),
                has_comment=kwargs.get('has_comment', False)
            )

        return revision