from django.shortcuts import render, get_object_or_404, redirect
from django.http import HttpResponseRedirect
from django.core.urlresolvers import reverse
from django.contrib import messages

from decorators import superuser_only
from functions import slugify_unique

from units.models import Unit

from pages.models import (
    Page, Theme, SelfAssessment, PageStatic, Page360, Page360Selection, PageRateActivity, PageRateActivitySummary,
    PageDragDrop, PageDragDropColumns, PageDragDropColumnsEvaluate, RateActivity, PageMovement, PageMovementFrame,
    RateActivityOption, RateActivityQuestion, Help
)

from pages.forms import (
    PageForm, ThemeForm, SelfAssessmentForm, StaticForm, PageRateActivityForm, PageRateActivitySummaryForm,
    Page360SelectionForm, PanoForm, MovementForm, FrameForm, PageDragDropForm, PageDragDropColumnsForm,
    PageDragDropColumnsEvaluateForm, RateActivityForm, RateActivityOptionForm, RateActivityQuestionForm, HelpForm
)


@superuser_only
def index(request, course_slug, unit_slug):

    unit = get_object_or_404(Unit, slug=unit_slug, course__slug=course_slug)

    pages = Page.objects.filter(unit=unit)

    return render(request, 'pages/admin/index.html', {'unit': unit, 'pages': pages})


@superuser_only
def add(request, course_slug, unit_slug):

    unit = get_object_or_404(Unit, slug=unit_slug, course__slug=course_slug)

    pages = unit.get_pages()

    page_form = PageForm(initial={'order': pages.count() + 1})

    if request.POST:
        page_form = PageForm(request.POST)
        if page_form.is_valid():
            try:
                page = page_form.save(commit=False)
                page.unit = unit
                page.slug = slugify_unique(page.title, Page)
                page.save()
                messages.success(request, "Page added successfully")
            except Exception:
                messages.error(request, "Could not save page")
            return HttpResponseRedirect(reverse('admin_pages', args=[unit.course.slug, unit.slug]))

    return render(request, 'pages/admin/add.html', {'unit': unit, 'page_form': page_form})


@superuser_only
def edit(request, course_slug, unit_slug, page_slug):

    page = get_object_or_404(Page, unit__course__slug=course_slug, unit__slug=unit_slug, slug=page_slug)

    page_form = PageForm(instance=page)

    if request.POST:
        page_form = PageForm(request.POST, instance=page)
        if page_form.is_valid():
            try:
                page_form.save()
                messages.success(request, "Page updated successfully")
            except Exception:
                messages.error(request, "Could not save page")
            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/edit.html', {'page': page, 'page_form': page_form})


@superuser_only
def disable(request, course_slug, unit_slug, page_slug):
    page = get_object_or_404(Page, unit__course__slug=course_slug, unit__slug=unit_slug, slug=page_slug)
    try:
        page.enabled = False
        page.save()
        messages.success(request, "Page disabled")
    except Exception:
        messages.error(request, "Could not disable page")

    return HttpResponseRedirect(reverse('admin_pages', args=[course_slug, unit_slug]))


@superuser_only
def enable(request, course_slug, unit_slug, page_slug):
    page = get_object_or_404(Page, unit__course__slug=course_slug, unit__slug=unit_slug, slug=page_slug)
    try:
        page.enabled = True
        page.save()
        messages.success(request, "Page enabled")
    except Exception:
        messages.error(request, "Could not enable page")

    return HttpResponseRedirect(reverse('admin_pages', args=[course_slug, unit_slug]))


@superuser_only
def delete(request, course_slug, unit_slug, page_slug):
    page = get_object_or_404(Page, unit__course__slug=course_slug, unit__slug=unit_slug, slug=page_slug)
    try:
        page.delete()
        messages.success(request, "Page deleted")
    except Exception:
        messages.error(request, "Could not delete page")

    return HttpResponseRedirect(reverse('admin_pages', args=[course_slug, unit_slug]))


@superuser_only
def preview(request, course_slug, unit_slug, page_slug):

    page = get_object_or_404(Page, unit__course__slug=course_slug, unit__slug=unit_slug, slug=page_slug)

    return render(request, 'pages/admin/preview.html', {'page': page})


# THEMES ###

@superuser_only
def themes(request):

    themes = Theme.objects.all()

    return render(request, 'pages/admin/themes/index.html', {'themes': themes})


@superuser_only
def add_theme(request):

    theme_form = ThemeForm()

    if request.POST:
        theme_form = ThemeForm(request.POST)
        if theme_form.is_valid():
            try:
                theme = theme_form.save(commit=False)
                theme.slug = slugify_unique(theme.title, Theme)
                theme.save()
                messages.success(request, "Theme added successfully")
            except Exception:
                messages.error(request, "Could not save theme")
            return HttpResponseRedirect(reverse('admin_themes'))

    return render(request, 'pages/admin/themes/add.html', {'theme_form': theme_form})


@superuser_only
def edit_theme(request, slug):

    theme = get_object_or_404(Theme, slug=slug)

    theme_form = ThemeForm(instance=theme)

    if request.POST:
        theme_form = ThemeForm(request.POST, instance=theme)

        if theme_form.is_valid():
            try:
                theme_form.save()
                messages.success(request, "Theme updated")
            except Exception:
                messages.error(request, "Could not update theme")
            return HttpResponseRedirect(reverse('admin_themes'))

    return render(request, 'pages/admin/themes/edit.html', {'theme_form': theme_form, 'theme': theme})


@superuser_only
def delete_theme(request, slug):
    theme = get_object_or_404(Theme, slug=slug)
    try:
        theme.delete()
        messages.success(request, "Theme deleted")
    except Exception:
        messages.error(request, "Could not delete Theme")

    return HttpResponseRedirect(reverse('admin_themes'))


@superuser_only
def disable_theme(request, slug):
    theme = get_object_or_404(Theme, slug=slug)
    try:
        theme.enabled = False
        theme.save()
        messages.success(request, "Theme disabled")
    except Exception:
        messages.error(request, "Could not disable Theme")

    return HttpResponseRedirect(reverse('admin_themes'))


@superuser_only
def enable_theme(request, slug):
    theme = get_object_or_404(Theme, slug=slug)
    try:
        theme.enabled = True
        theme.save()
        messages.success(request, "Theme enabled")
    except Exception:
        messages.error(request, "Could not enable Theme")

    return HttpResponseRedirect(reverse('admin_themes'))


# Self Assessments ###

@superuser_only
def self_assessments(request, page_slug):
    page = get_object_or_404(Page, slug=page_slug)

    self_assessments = SelfAssessment.objects.filter(page=page)

    return render(request, 'pages/admin/self-assessments/index.html', {'page': page, 'self_assessments': self_assessments})


@superuser_only
def self_assessments_add(request, page_slug):

    page = get_object_or_404(Page, slug=page_slug)

    sa_form = SelfAssessmentForm()

    if request.POST:
        sa_form = SelfAssessmentForm(request.POST)
        if sa_form.is_valid():
            try:
                sa = sa_form.save(commit=False)
                sa.page = page
                sa.save()
                messages.success(request, "Self Assessment added successfully")
            except Exception:
                messages.error(request, "Could not save Self Assessment")
            return HttpResponseRedirect(reverse('admin_self_assessments', args=[page.slug]))

    return render(request, 'pages/admin/self-assessments/add.html', {'sa_form': sa_form, 'page': page})


@superuser_only
def self_assessments_edit(request, page_slug, assessment_id):

    sa = get_object_or_404(SelfAssessment, id=assessment_id)

    sa_form = SelfAssessmentForm(instance=sa)

    if request.POST:
        sa_form = SelfAssessmentForm(request.POST, instance=sa)
        if sa_form.is_valid():
            try:
                sa.save()
                messages.success(request, "Self Assessment updated")
            except Exception:
                messages.error(request, "Could not save Self Assessment")
            return HttpResponseRedirect(reverse('admin_self_assessments', args=[page_slug]))

    return render(request, 'pages/admin/self-assessments/edit.html', {'sa_form': sa_form, 'sa': sa, 'page': sa.page})


@superuser_only
def self_assessments_delete(request, page_slug, assessment_id):

    self_assessment = get_object_or_404(SelfAssessment, id=assessment_id)

    try:
        self_assessment.delete()
        messages.success(request, "Self Assessment deleted")
    except Exception:
        messages.error(request, "Could not delete Self Assessment")

    return HttpResponseRedirect(reverse('admin_self_assessments', args=[page_slug]))


# PAGE TYPES ###

@superuser_only
def select_page_type(request, page_slug):

    page = get_object_or_404(Page, slug=page_slug)

    if page.get_page_type():
        messages.error(request, "Page content exists. Please delete the current page content before continuing")
        return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/select.html', {'page': page})


@superuser_only
def set_page_type(request, page_slug, type):

    page = get_object_or_404(Page, slug=page_slug)

    if page.get_page_type():
        messages.error(request, "Page content exists. Please delete the current page content before continuing")
        return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    if type == 'static':
        return add_static(request, page)

    if type == 'rate':
        return add_rate(request, page)

    if type == 'rate-results':
        return add_rate_results(request, page)

    if type == '360':
        return add_pano(request, page)

    if type == '360-selection':
        return add_pano_selection(request, page)

    if type == 'movement':
        return add_movement(request, page, type)

    if type == 'drag-drop':
        return add_drag_drop(request, page)

    if type == 'drag-drop-columns':
        return add_drag_drop_columns(request, page)

    if type == 'drag-drop-columns-evaluate':
        return add_drag_drop_columns_evaluate(request, page)

    if type == 'self-assessment':
        return add_self_assessment_page(request, page)

    messages.error(request, "Sorry, your selection is not valid")
    return HttpResponseRedirect(reverse('admin_select_page_type', args=[page.slug]))


@superuser_only
def edit_page_type(request, page_slug, type):
    page = get_object_or_404(Page, slug=page_slug)

    if type == 'Static':
        return edit_static(request, page)

    if type == '360':
        return edit_pano(request, page)

    if type == '360-selection':
        return edit_pano_selection(request, page)

    if type == 'Movement':
        return edit_movement(request, page, type)

    if type == 'drag-drop':
        return edit_drag_drop(request, page, type)

    if type == 'rate':
        return edit_rate(request, page)

    if type == 'rate-results':
        return edit_rate_results(request, page)

    if type == 'drag-drop-columns':
        return edit_drag_drop_columns(request, page)

    if type == 'drag-drop-columns-evaluate':
        return edit_drag_drop_columns_evaluate(request, page)

    messages.error(request, "Sorry, your selection is not valid")
    return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))


@superuser_only
def delete_page_type(request, page_slug, type):

    page = get_object_or_404(Page, slug=page_slug)

    try:
        if type == 'static':
            page_type = get_object_or_404(PageStatic, page=page)
            page_type.delete()

        if type == '360':
            page_type = get_object_or_404(Page360, page=page)
            page_type.delete()

        if type == '360-selection':
            page_type = get_object_or_404(Page360Selection, page=page)
            page_type.delete()

        if type == 'rate':
            page_type = get_object_or_404(PageRateActivity, page=page)
            page_type.delete()

        if type == 'rate-results':
            page_type = get_object_or_404(PageRateActivitySummary, page=page)
            page_type.delete()

        if type == 'drag-drop':
            page_type = get_object_or_404(PageDragDrop, page=page)
            page_type.delete()

        if type == 'drag-drop-columns':
            page_type = get_object_or_404(PageDragDropColumns, page=page)
            page_type.delete()

        if type == 'drag-drop-columns-evaluate':
            page_type = get_object_or_404(PageDragDropColumnsEvaluate, page=page)
            page_type.delete()

        messages.success(request, "Page content deleted")
    except Exception:
        messages.error(request, "Could not delete page content")

    return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))


@superuser_only
def add_static(request, page):

    static_form = StaticForm()

    if request.POST:
        static_form = StaticForm(request.POST, request.FILES)

        if static_form.is_valid():

            try:
                static = static_form.save(commit=False)
                static.page = page
                static.save()

                if request.POST.get('save-preview'):
                    return HttpResponseRedirect(reverse('admin_pages_preview', args=[page.unit.course.slug, page.unit.slug, page.slug]))

                messages.success(request, "Static page added")
            except Exception:
                messages.error(request, "Could not add static page")

            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/static/add_static.html', {'page': page, 'static_form': static_form})


@superuser_only
def edit_static(request, page):

    static = get_object_or_404(PageStatic, page=page)

    static_form = StaticForm(instance=static)

    if request.POST:
        static_form = StaticForm(request.POST, request.FILES, instance=static)

        if static_form.is_valid():

            try:
                static_form.save()

                if request.POST.get('save-preview'):
                    return HttpResponseRedirect(reverse('admin_pages_preview', args=[page.unit.course.slug, page.unit.slug, page.slug]))

                messages.success(request, "Static page saved")

                if request.POST.get('save-continue'):
                    return HttpResponseRedirect(reverse('admin_edit_page_type', args=[page.slug, "Static"]))

            except Exception:
                messages.error(request, "Could not save static page")

            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/static/edit_static.html', {'page': page, 'static_form': static_form})


@superuser_only
def add_rate(request, page):

    page_activity_form = PageRateActivityForm()
    page_activity_form.fields['activity'].queryset = RateActivity.objects.filter(unit=page.unit)

    if request.POST:
        page_activity_form = PageRateActivityForm(request.POST)
        page_activity_form.fields['activity'].queryset = RateActivity.objects.filter(unit=page.unit)

        if page_activity_form.is_valid():
            try:
                page_rate_activity = page_activity_form.save(commit=False)
                page_rate_activity.page = page
                page_rate_activity.save()
                messages.success(request, "Rate Activity page created successfully")
            except Exception:
                messages.error(request, "Rate Activity page could not be saved")
            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/rate/add.html', {'page': page, 'page_activity_form': page_activity_form, 'rate_activities': rate_activities})


@superuser_only
def edit_rate(request, page):

    page_rate = get_object_or_404(PageRateActivity, page=page)

    page_activity_form = PageRateActivityForm(instance=page_rate)

    if request.POST:
        page_activity_form = PageRateActivityForm(request.POST, instance=page_rate)

        if page_activity_form.is_valid():
            try:
                page_activity_form.save()
                messages.success(request, "Rate Activity page saved")
            except Exception:
                messages.error(request, "Rate Activity page could not be saved")
            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/rate/edit.html', {'page': page, 'page_activity_form': page_activity_form})


@superuser_only
def add_rate_results(request, page):

    rate_activity_summary_form = PageRateActivitySummaryForm()
    rate_activity_summary_form.fields['activity'].queryset = RateActivity.objects.filter(unit=page.unit)

    if request.POST:
        rate_activity_summary_form = PageRateActivitySummaryForm(request.POST)
        rate_activity_summary_form.fields['activity'].queryset = RateActivity.objects.filter(unit=page.unit)

        if rate_activity_summary_form.is_valid():
            try:
                rate_activity_summary = rate_activity_summary_form.save(commit=False)
                rate_activity_summary.page = page
                rate_activity_summary.save()
                messages.success(request, "Rate activity summary page created successfully")
            except Exception:
                messages.error(request, "Rate activity summary page could not be saved")
            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/rate-results/add.html', {'page': page, 'rate_activity_summary_form': rate_activity_summary_form})


@superuser_only
def edit_rate_results(request, page):

    page_rate_results = get_object_or_404(PageRateActivitySummary, page=page)

    rate_activity_summary_form = PageRateActivitySummaryForm(instance=page_rate_results)

    if request.POST:
        rate_activity_summary_form = PageRateActivitySummaryForm(request.POST, instance=page_rate_results)

        if rate_activity_summary_form.is_valid():
            try:
                rate_activity_summary_form.save()
                messages.success(request, "Rate activity summary page saved successfully")
            except Exception:
                messages.error(request, "Rate activity summary page could not be saved")
            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/rate-results/edit.html', {'page': page, 'rate_activity_summary_form': rate_activity_summary_form, 'rate_activities': rate_activities})


@superuser_only
def add_pano(request, page):

    pano_form = PanoForm()

    if request.POST:
        pano_form = PanoForm(request.POST)

        if pano_form.is_valid():

            try:
                pano = pano_form.save(commit=False)
                pano.page = page
                pano.save()
                pano_form.save_m2m()
                messages.success(request, "360 page added")
            except Exception:
                messages.error(request, "Could not add 360 page")

            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/360/add_pano.html', {'page': page, 'pano_form': pano_form})


@superuser_only
def edit_pano(request, page):

    pano_form = PanoForm(instance=page.get_content())
    if request.POST:
        pano_form = PanoForm(request.POST, instance=page.get_content())

        if pano_form.is_valid():

            try:
                pano_form.save()
                messages.success(request, "360 page saved")
            except Exception:
                messages.error(request, "Could not save 360 page")

            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/360/edit_pano.html', {'page': page, 'pano_form': pano_form})


@superuser_only
def add_pano_selection(request, page):

    page_360_selection_form = Page360SelectionForm()

    if request.POST:
        page_360_selection_form = Page360SelectionForm(request.POST)

        if page_360_selection_form.is_valid():

            try:
                pano = page_360_selection_form.save(commit=False)
                pano.page = page
                pano.save()
                messages.success(request, "360 selection page added")
            except Exception:
                messages.error(request, "Could not add 360 selection page")

            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/360-selection/add.html', {'page': page, 'page_360_selection_form': page_360_selection_form})


@superuser_only
def edit_pano_selection(request, page):

    pano_form = PanoForm(instance=page.get_content())
    if request.POST:
        pano_form = PanoForm(request.POST, instance=page.get_content())

        if pano_form.is_valid():

            try:
                pano_form.save()
                messages.success(request, "360 page saved")
            except Exception:
                messages.error(request, "Could not save 360 page")

            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/360/edit_pano.html', {'page': page, 'pano_form': pano_form})


@superuser_only
def add_movement(request, page, type):

    try:
        movement = PageMovement(page=page)
        movement.save()
    except Exception:
        messages.error(request, "Could not create animation")
        return HttpResponseRedirect(reverse('admin_edit_page_type', args=[page.slug, type]))

    movement_form = MovementForm(instance=movement)
    frame_form = FrameForm()

    return render(request, 'pages/admin/page-types/movement/add_movement.html', {'type': type, 'page': page, 'frame_form': frame_form, 'movement_form': movement_form})


@superuser_only
def edit_movement(request, page, type):

    page_movement = get_object_or_404(PageMovement, page=page)
    frames = PageMovementFrame.objects.filter(page_movement=page_movement)

    movement_form = MovementForm(instance=page_movement)
    frame_form = FrameForm()

    if request.POST:
        movement_form = MovementForm(request.POST, request.FILES, instance=page_movement)
        frame_form = FrameForm(request.POST, request.FILES)

        if movement_form.is_valid():
            try:
                movement_form.save()
            except Exception:
                pass

        if frame_form.is_valid():
            try:
                frame = frame_form.save(commit=False)
                frame.page_movement = page_movement
                frame.save()
                messages.success(request, "Frame saved")
            except Exception:
                messages.error(request, "Could not save frame")
            return HttpResponseRedirect(reverse('admin_edit_page_type', args=[page.slug, type]))

    return render(request, 'pages/admin/page-types/movement/edit_movement.html', {'page': page, 'frame_form': frame_form, 'frames': frames, 'movement_form': movement_form})


@superuser_only
def edit_movement_frame(request, page_slug, frame_id):

    frame = get_object_or_404(PageMovementFrame, id=frame_id)

    frame_form = FrameForm(instance=frame)

    if request.POST:
        frame_form = FrameForm(request.POST, request.FILES, instance=frame)
        if frame_form.is_valid():
            try:
                frame_form.save()
                messages.success(request, "Frame saved")
            except Exception:
                messages.error(request, "Could not save frame")
            return HttpResponseRedirect(reverse('admin_edit_page_type', args=[frame.page_movement.page.slug, frame.page_movement.page.get_page_type()]))

    return render(request, 'pages/admin/page-types/movement/edit_movement_frame.html', {'frame': frame, 'frame_form': frame_form, 'page': frame.page_movement.page})


@superuser_only
def delete_movement_frame(request, page_slug, frame_id):

    frame = get_object_or_404(PageMovementFrame, id=frame_id)

    try:
        frame.delete()
        messages.success(request, "Frame deleted")
    except Exception:
        messages.error(request, "Could not delete frame")
    return HttpResponseRedirect(reverse('admin_edit_page_type', args=[frame.page_movement.page.slug, frame.page_movement.page.get_page_type()]))


@superuser_only
def add_drag_drop(request, page):

    page_drag_drop_form = PageDragDropForm()

    if request.POST:
        page_drag_drop_form = PageDragDropForm(request.POST)

        if page_drag_drop_form.is_valid():
            try:
                page_drag_drop = page_drag_drop_form.save(commit=False)
                page_drag_drop.page = page
                page_drag_drop.save()
                messages.success(request, "Drag & Drop page created successfully")
            except Exception:
                messages.error(request, "Drag & Drop page could not be saved")
            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/drag-drop/add.html', {'page': page, 'page_drag_drop_form': page_drag_drop_form})


@superuser_only
def edit_drag_drop(request, page, type):

    page_drag_drop = get_object_or_404(PageDragDrop, page=page)

    page_drag_drop_form = PageDragDropForm(instance=page_drag_drop)

    if request.POST:
        page_drag_drop_form = PageDragDropForm(request.POST, instance=page_drag_drop)

        if page_drag_drop_form.is_valid():
            try:
                page_drag_drop_form.save()
                messages.success(request, "Drag & Drop page saved successfully")
            except Exception:
                messages.error(request, "Drag & Drop page could not be saved")
            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/drag-drop/edit.html', {'page': page, 'page_drag_drop_form': page_drag_drop_form})


@superuser_only
def add_drag_drop_columns(request, page):

    page_drag_drop_form = PageDragDropColumnsForm()

    if request.POST:
        page_drag_drop_form = PageDragDropColumnsForm(request.POST, request.FILES)

        if page_drag_drop_form.is_valid():
            try:
                page_drag_drop = page_drag_drop_form.save(commit=False)
                page_drag_drop.page = page
                page_drag_drop.save()
                messages.success(request, "Drag & Drop Columns page created successfully")
            except Exception:
                messages.error(request, "Drag & Drop Columns page could not be saved")
            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/drag-drop-columns/add.html', {'page': page, 'page_drag_drop_form': page_drag_drop_form})


@superuser_only
def edit_drag_drop_columns(request, page):

    page_drag_drop = get_object_or_404(PageDragDropColumns, page=page)

    page_drag_drop_form = PageDragDropColumnsForm(instance=page_drag_drop)

    if request.POST:
        page_drag_drop_form = PageDragDropColumnsForm(request.POST, instance=page_drag_drop)

        if page_drag_drop_form.is_valid():
            try:
                page_drag_drop_form.save()
                messages.success(request, "Drag & Drop Columns page saved successfully")
            except Exception:
                messages.error(request, "Drag & Drop Columns page could not be saved")
            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/drag-drop-columns/edit.html', {'page': page, 'page_drag_drop_form': page_drag_drop_form})


@superuser_only
def add_drag_drop_columns_evaluate(request, page):

    page_drag_drop_form = PageDragDropColumnsEvaluateForm()

    if request.POST and request.FILES:
        page_drag_drop_form = PageDragDropColumnsEvaluateForm(request.POST, request.FILES)

        if page_drag_drop_form.is_valid():
            try:
                page_drag_drop = page_drag_drop_form.save(commit=False)
                page_drag_drop.page = page
                page_drag_drop.save()
                messages.success(request, "Drag & Drop Columns page created successfully")
            except Exception:
                messages.error(request, "Drag & Drop Columns page could not be saved")
            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/drag-drop-columns/add.html', {'page': page, 'page_drag_drop_form': page_drag_drop_form})


@superuser_only
def edit_drag_drop_columns_evaluate(request, page):

    page_drag_drop = get_object_or_404(PageDragDropColumnsEvaluate, page=page)

    page_drag_drop_form = PageDragDropColumnsEvaluateForm(instance=page_drag_drop)

    if request.POST:
        page_drag_drop_form = PageDragDropColumnsEvaluateForm(request.POST, instance=page_drag_drop)

        if page_drag_drop_form.is_valid():
            try:
                page_drag_drop_form.save()
                messages.success(request, "Drag & Drop Columns page saved successfully")
            except Exception:
                messages.error(request, "Drag & Drop Columns page could not be saved")
            return HttpResponseRedirect(reverse('admin_pages', args=[page.unit.course.slug, page.unit.slug]))

    return render(request, 'pages/admin/page-types/drag-drop-columns/edit.html', {'page': page, 'page_drag_drop_form': page_drag_drop_form})


@superuser_only
def add_self_assessment_page(request, page):

    return render(request, 'pages/admin/page-types/self-assessment/list.html', {
        'page': page,
    })


@superuser_only
def rate_activities(request, course_slug, unit_slug):

    unit = get_object_or_404(Unit, slug=unit_slug, course__slug=course_slug)

    activities = RateActivity.objects.filter(unit=unit)

    return render(request, 'pages/admin/rate/activities.html', {'unit': unit, 'activities': activities})


@superuser_only
def rate_activities_add(request, course_slug, unit_slug):

    unit = get_object_or_404(Unit, slug=unit_slug, course__slug=course_slug)

    activity_form = RateActivityForm()

    if request.POST:

        activity_form = RateActivityForm(request.POST)

        if activity_form.is_valid():
            try:
                activity = activity_form.save(commit=False)
                activity.unit = unit
                activity.save()
                messages.success(request, "Activity saved")
            except Exception:
                messages.error(request, "Activity could not be saved")
            return HttpResponseRedirect(reverse('admin_rate_activities', args=[course_slug, unit_slug]))

    return render(request, 'pages/admin/rate/add.html', {'unit': unit, 'activity_form': activity_form})


@superuser_only
def rate_activities_edit(request, course_slug, unit_slug, id):

    unit = get_object_or_404(Unit, slug=unit_slug, course__slug=course_slug)
    activity = get_object_or_404(RateActivity, id=id)

    activity_form = RateActivityForm(instance=activity)

    if request.POST:

        activity_form = RateActivityForm(request.POST, instance=activity)

        if activity_form.is_valid():
            try:
                activity_form.save()
                messages.success(request, "Activity saved")
            except Exception:
                messages.error(request, "Activity could not be saved")
            return HttpResponseRedirect(reverse('admin_rate_activities', args=[course_slug, unit_slug]))

    return render(request, 'pages/admin/rate/edit.html', {'unit': unit, 'activity_form': activity_form})


@superuser_only
def rate_activities_delete(request, course_slug, unit_slug, id):

    get_object_or_404(Unit, slug=unit_slug, course__slug=course_slug)
    activity = get_object_or_404(RateActivity, id=id)

    try:
        activity.delete()
        messages.success(request, "Activity deleted")
    except Exception:
        messages.error(request, "Could not delete activity")

    return HttpResponseRedirect(reverse('admin_rate_activities', args=[course_slug, unit_slug]))


@superuser_only
def rate_activities_options(request, course_slug, unit_slug, id):

    get_object_or_404(Unit, slug=unit_slug, course__slug=course_slug)
    activity = get_object_or_404(RateActivity, id=id)

    options = RateActivityOption.objects.filter(rate_activity=activity)

    return render(request, 'pages/admin/rate/options/index.html', {'activity': activity, 'options': options})


@superuser_only
def rate_activities_options_add(request, course_slug, unit_slug, id):

    get_object_or_404(Unit, slug=unit_slug, course__slug=course_slug)
    activity = get_object_or_404(RateActivity, id=id)

    option_form = RateActivityOptionForm()

    if request.POST:
        option_form = RateActivityOptionForm(request.POST)

        if option_form.is_valid():
            try:
                option = option_form.save(commit=False)
                option.rate_activity = activity
                option.save()
                messages.success(request, "Option saved")
            except Exception:
                messages.error(request, "Could not save option")

            return HttpResponseRedirect(reverse('admin_rate_activities_options', args=[course_slug, unit_slug, activity.id]))

    return render(request, 'pages/admin/rate/options/add.html', {'activity': activity, 'option_form': option_form})


@superuser_only
def rate_activities_options_edit(request, course_slug, unit_slug, id, option_id):

    get_object_or_404(Unit, slug=unit_slug, course__slug=course_slug)
    activity = get_object_or_404(RateActivity, id=id)
    option = get_object_or_404(RateActivityOption, id=option_id)

    option_form = RateActivityOptionForm(instance=option)

    if request.POST:
        option_form = RateActivityOptionForm(request.POST, instance=option)

        if option_form.is_valid():
            try:
                option_form.save()
                messages.success(request, "Option saved")
            except Exception:
                messages.error(request, "Could not save option")

            return HttpResponseRedirect(reverse('admin_rate_activities_options', args=[course_slug, unit_slug, activity.id]))

    return render(request, 'pages/admin/rate/options/edit.html', {'activity': activity, 'option_form': option_form, 'option': option})


@superuser_only
def rate_activities_options_delete(request, course_slug, unit_slug, id, option_id):

    get_object_or_404(Unit, slug=unit_slug, course__slug=course_slug)
    activity = get_object_or_404(RateActivity, id=id)
    option = get_object_or_404(RateActivityOption, id=option_id)

    try:
        option.delete()
        messages.success(request, "Option deleted")
    except Exception:
        messages.error(request, "Could not delete option")

    return HttpResponseRedirect(reverse('admin_rate_activities_options', args=[course_slug, unit_slug, activity.id]))


@superuser_only
def rate_questions(request, page_slug):

    page = get_object_or_404(Page, slug=page_slug)
    activity_page = get_object_or_404(PageRateActivity, page=page)

    questions = RateActivityQuestion.objects.filter(rate_activity=activity_page).order_by('order')

    return render(request, 'pages/admin/rate/questions/index.html', {'activity_page': activity_page, 'unit': page.unit, 'questions': questions})


@superuser_only
def rate_questions_add(request, page_slug):

    page = get_object_or_404(Page, slug=page_slug)
    activity_page = get_object_or_404(PageRateActivity, page=page)

    form = RateActivityQuestionForm()

    if request.POST:
        form = RateActivityQuestionForm(request.POST)

        if form.is_valid():
            try:
                question = form.save(commit=False)
                question.rate_activity = activity_page
                question.save()
                messages.success(request, "Question saved")
            except Exception:
                messages.error(request, "Could not save question")

            return HttpResponseRedirect(reverse('admin_rate_questions', args=[page_slug]))

    return render(request, 'pages/admin/rate/questions/add.html', {'activity_page': activity_page, 'unit': page.unit, 'form': form})


@superuser_only
def rate_questions_edit(request, page_slug, id):

    page = get_object_or_404(Page, slug=page_slug)
    activity_page = get_object_or_404(PageRateActivity, page=page)
    question = get_object_or_404(RateActivityQuestion, id=id)

    form = RateActivityQuestionForm(instance=question)

    if request.POST:
        form = RateActivityQuestionForm(request.POST, instance=question)

        if form.is_valid():
            try:
                form.save()
                messages.success(request, "Question saved")
            except Exception:
                messages.error(request, "Could not save question")

            return HttpResponseRedirect(reverse('admin_rate_questions', args=[page_slug]))

    return render(request, 'pages/admin/rate/questions/edit.html', {'activity_page': activity_page, 'unit': page.unit, 'form': form, 'question': question})


@superuser_only
def rate_questions_delete(request, page_slug, id):

    page = get_object_or_404(Page, slug=page_slug)
    get_object_or_404(PageRateActivity, page=page)
    question = get_object_or_404(RateActivityQuestion, id=id)

    try:
        question.delete()
        messages.success(request, "Question deleted")
    except Exception:
        messages.error(request, "Could not delete question")

    return HttpResponseRedirect(reverse('admin_rate_questions', args=[page_slug]))

    return HttpResponseRedirect(reverse('admin_rate_questions', args=[page_slug]))


@superuser_only
def help(request):

    help = Help.objects.all()

    return render(request, "pages/admin/help/index.html", {'help': help})


@superuser_only
def help_add(request):

    pages = Page.objects.all().order_by('unit__course__course', 'unit__title', 'order', 'title',)

    page_error = False

    form = HelpForm()

    if request.POST:

        page_id = request.POST.get('page', False)

        form = HelpForm(request.POST)

        if form.is_valid() and page_id:
            help = form.save(commit=False)
            help.page_id = page_id
            help.save()

            messages.success(request, "Help added")

            return redirect('admin_pages_help')

        if not page_id:
            page_error = True

    return render(request, "pages/admin/help/add.html", {'pages': pages, 'form': form, 'page_error': page_error})


@superuser_only
def help_edit(request, id):

    help = get_object_or_404(Help, id=id)

    pages = Page.objects.all().order_by('unit__course__course', 'unit__title', 'order', 'title',)

    page_error = False

    form = HelpForm(instance=help)

    if request.POST:

        page_id = request.POST.get('page', False)

        form = HelpForm(request.POST, instance=help)

        if form.is_valid() and page_id:
            form.save()
            help.page_id = page_id
            help.save()

            messages.success(request, "Help saved")

            return redirect('admin_pages_help')

        if not page_id:
            page_error = True

    return render(request, "pages/admin/help/edit.html", {'pages': pages, 'form': form, 'page_error': page_error, 'help': help})


@superuser_only
def help_delete(request, id):

    help = get_object_or_404(Help, id=id)

    help.delete()

    return redirect('admin_pages_help')