import json
from logging import getLogger

from django.core.management import BaseCommand
from django.core.exceptions import ValidationError

from books.models import Chapter, ObjectiveGroupSnapshot, Snapshot, ContentBlockSnapshot, ChapterSnapshot
from books.models import ContentBlock
from books.models import Module
from objectives.models import ObjectiveSnapshot, Objective, ObjectiveGroup

logger = getLogger(__name__)

class Command(BaseCommand):
    def handle(self, *args, **options):
        ContentBlock.objects.filter(title__startswith="TESTOBJECTIVE").delete()
        ContentBlock.objects.filter(title__startswith="CUSTOM").delete()
        Chapter.objects.filter(title__startswith="TESTOBJECTIVE").delete()
        ContentBlock.objects.filter(title__startswith="XXX").delete()
        Chapter.objects.filter(title__startswith="XXX").delete()

        migrate_objectives_to_content()

def migrate_objectives_to_content():
        created_content_blocks = 0

        failed_modules = []

        # This dict stores all content blocks that have been created for a set of objectives
        # In this way we can reuse content blocks for the same set of objectives
        created_default_content_blocks = {}

        for module in Module.objects.all():
            try:
                chapter = create_chapter_from_objective_group(module)

                for objective_group in module.objective_groups.all().order_by('title'):
                    default_objectives = list(objective_group.objectives.filter(owner__isnull=True, )
                                              .exclude(objectivesnapshot__isnull=False).order_by('order'))

                    default_objectives_ids = tuple(objective.id for objective in default_objectives)

                    # Create "Verlagsinhalte" content block if it does not exist yet
                    if default_objectives_ids not in created_default_content_blocks:
                        default_content_block = create_default_content(objective_group, chapter)
                        created_default_content_blocks[default_objectives_ids] = default_content_block
                    else:
                        default_content_block = created_default_content_blocks[default_objectives_ids]

                    custom_objectives_by_owner = get_objectives_by_owner(objective_group)

                    if default_objectives or custom_objectives_by_owner:
                        contentblocks_by_merged_objectives_ids = {}

                        # cor custom objectives iterate over owners,
                        # - one ownsers custom objectives must not be changed by another owner
                        # - visibility is set per class
                        for owner, owner_objectives in custom_objectives_by_owner.items():
                            print(f"Owner: {owner}")
                            print(f"      Objectives: ")

                            visible_default_objectives_by_class = remove_hidden_objectives(default_objectives, owner)

                            for school_class in visible_default_objectives_by_class.keys():
                                custom_content_block = None

                                print(f"      School class: {school_class}")
                                # merge "Verlagsinhalte" and "benutzerdefinierte Inhalte"
                                visible_owner_objectives = [objective for objective in owner_objectives if not objective.is_hidden_for_class(school_class)]

                                merged_objectives = visible_default_objectives_by_class[school_class] + visible_owner_objectives
                                merged_objectives_ids = tuple(objective.id for objective in merged_objectives)

                                if merged_objectives_ids == default_objectives_ids:
                                    print(f"             Objective: Reuse default content block")
                                    # custom_content_block = default_content_block

                                # Create content block if that set of objectives has not been created yet
                                if merged_objectives_ids not in contentblocks_by_merged_objectives_ids and merged_objectives_ids != default_objectives_ids:
                                    for objective in merged_objectives:
                                        print(f"            Objective: {objective}   {objective.owner}")

                                    if merged_objectives_ids:
                                        custom_content_block = create_content_block_from_objective(objective_group,
                                                                                                   chapter,
                                                                                                   owner=owner,
                                                                                                   prefix=f"CUSTOM  {owner.username} ")
                                        contentblocks_by_merged_objectives_ids[
                                            merged_objectives_ids] = custom_content_block
                                        create_text_in_content_block(merged_objectives, custom_content_block)
                                        created_content_blocks += 1
                                else:
                                    if merged_objectives_ids != default_objectives_ids:
                                        print(f"             Objective: Reuse content block")
                                        custom_content_block = contentblocks_by_merged_objectives_ids[
                                            merged_objectives_ids]
                                    else:
                                        print(f"             Objective: Reuse default content block")

                                # set visibility
                                # hide default objectives if custom objectives exist
                                if custom_content_block:
                                    default_content_block.hidden_for.add(school_class)
                                    default_content_block.save_revision().publish()
                                    default_content_block.save()

                                    custom_content_block.visible_for.add(school_class)
                                    custom_content_block.save_revision().publish()
                                    custom_content_block.save()

                                if objective_group.hidden_for.filter(id=school_class.id).exists():
                                    default_content_block.hidden_for.add(school_class)
                                    default_content_block.save_revision().publish()
                                    default_content_block.save()


            except ValidationError as e:
                print(f"Error with module {module}")
                logger.error(e)
                failed_modules.append(module)

        print(f"Created {created_content_blocks} content blocks")
        print(f"Failed modules: {len(failed_modules)}")

        for module in failed_modules:
            print(f"Faile module: {module}")


def create_default_content(objective_group, chapter):
    """Create Verlagsinhalt Lernziele"""
    print(f"   Objective group: {objective_group}")
    print("      Default objectives:")

    default_objectives = list(
        objective_group.objectives.filter(owner__isnull=True, objectivesnapshot__isnull=True).order_by('id'))

    default_content_block = create_content_block_from_objective(objective_group, chapter, prefix="XXX YYY ")
    create_text_in_content_block(default_objectives, default_content_block)

    for objective in default_objectives:
        print(f"      Objective: {objective}   {objective.owner}")

    return default_content_block


def remove_hidden_objectives(objectives, user):
    school_classes = user.school_classes.all()
    visible_objectives = {}
    for school_class in school_classes:
        if school_class not in visible_objectives:
            visible_objectives[school_class] = []
        objectives_vis = [objective for objective in objectives if not objective.is_hidden_for_class(school_class)]
        visible_objectives[school_class].extend(objectives_vis)
    return visible_objectives


def get_objectives_by_owner(objective_group, exclude_snapshots=True):
    custom_objectives = objective_group.objectives.filter(owner__isnull=False).exclude(
        objectivesnapshot__isnull=False).order_by('order')
    custom_objectives_by_owner = {}

    for objective in custom_objectives:
        owner = objective.owner

        if owner not in custom_objectives_by_owner:
            custom_objectives_by_owner[owner] = []

        custom_objectives_by_owner[owner].append(objective)

    # add owners with hidden default objectives to custom objectives, needed for further processing
    hidden_default_objectives = list(
        objective_group.objectives.filter(owner__isnull=True, objectivesnapshot__isnull=True, hidden_for__isnull=False))

    for hidden_default_objective in hidden_default_objectives:
        for school_class in hidden_default_objective.hidden_for.all():
            for teacher in school_class.get_teachers():
                if teacher not in custom_objectives_by_owner:
                    custom_objectives_by_owner[teacher] = []

    return custom_objectives_by_owner


def create_chapter_from_objective_group(module, prefix="XXX "):
    chapter = Chapter(title=f"Lernziele")

    first_sibling = module.get_first_child()
    if first_sibling is not None:
        first_sibling.add_sibling(instance=chapter, pos='left')

    chapter.save_revision().publish()
    chapter.save()
    return chapter


def create_chapter_snapshot_from_objective_group(module, snapshot, prefix="XXX "):
    chapter = Chapter.objects.filter(parent=module, title=f"Lernziele").first()
    chapter_snapshot = ChapterSnapshot(title=f"Lernziele", snapshot=snapshot)

    first_sibling = module.get_first_child()
    if first_sibling is not None:
        first_sibling.add_sibling(instance=chapter_snapshot, pos='left')
    return chapter


def create_content_block_from_objective(objective_group, chapter, owner=None, prefix="XXX "):
    content_block = ContentBlock(
        title=f"{objective_group.get_title_display()}",
        type="normal",
        owner=owner,
        user_created=owner is not None,
        original_creator=owner
    )
    chapter.add_child(instance=content_block)
    return content_block


def create_content_block_snapshot_from_objective(objective_group, chapter, snapshot, owner=None, prefix="XXX "):
    content_block_snapshot = ContentBlockSnapshot(
        title=f"{objective_group.get_title_display()}",
        type="normal",
        owner=owner,
        user_created=owner is not None,
        snapshot=snapshot
    )

    chapter.add_child(instance=content_block_snapshot)
    return content_block_snapshot


def create_text_in_content_block(objectives, content_block, get_or_create=False):
    objectives = list(objectives)
    content_block.contents = create_content_block_contents(objectives)

    if get_or_create:
        content_block_qs = ContentBlock.objects.filter(title=content_block.title,
                                    owner=content_block.owner,
                                    user_created=content_block.user_created,
                                    contents=content_block.contents)
        if content_block_qs.exists():
            content_block = content_block_qs.first()

    content_block.save_revision().publish()
    return content_block

def create_content_block_contents(objectives):
    objectives = list(objectives)
    objective_li = [f"<li>{objective.text}</li>" for objective in objectives if objective.text]

    texts = [{'type': 'text_block',
              'value': {
                  'text': f"<ul>{''.join(str(i) for i in objective_li)}</ul>"
              }}]

    contents = json.dumps(texts)
    return contents

def analyze():
    print(f"""
    OjectiveGroups: {ObjectiveGroup.objects.count()}
    Objectives: {Objective.objects.count()}

    ObjectiveGroupSnapshots: {ObjectiveGroupSnapshot.objects.count()}
    ObjectivesSnapshots: {ObjectiveSnapshot.objects.filter(hidden=True).count()}


    ObjectiveGroups: {ObjectiveGroup.objects.filter(objectivegroupsnapshot__isnull=True).count()}
    Objectives: {Objective.objects.filter(objectivesnapshot__isnull=True).count()}

    Snapshot: {Snapshot.objects.count()}
    """)


def clean_snapshots():
    """ utility function to clean up snapshots """
    emails = ["mia.teacher", "simone.gerber", "pascal.sigg", "dario.aebersold", "steph-teacher"]
    for snapshot in Snapshot.objects.all():
        for email in emails:
            if email in snapshot.creator.email:
                print(f"Deleting snapshot of user {email}")
                snapshot.delete()