import mimetypes
import os
from datetime import datetime
from django.http import (
    Http404,
    HttpResponse,
    HttpResponsePermanentRedirect,
    JsonResponse,
)
from django.contrib.auth.decorators import login_required, permission_required
from django.contrib.contenttypes.models import ContentType
from django.core.paginator import (
    Paginator,
    InvalidPage,
    EmptyPage,
    PageNotAnInteger,
)
from django.shortcuts import redirect, render
from django.utils import timezone
from django.utils.translation import ngettext, gettext_lazy as _
from django.views.decorators.http import require_POST
from icalendar import Calendar
from wagtail.admin import messages
from wagtail.models import Page, get_page_models
from coderedcms import utils
from coderedcms.forms import SearchForm
from coderedcms.models import CoderedPage, LayoutSettings
from coderedcms.importexport import (
    convert_csv_to_json,
    import_pages,
    ImportPagesFromCSVFileForm,
)
from coderedcms.settings import crx_settings
from coderedcms.templatetags.coderedcms_tags import get_name_of_class


def search(request):
    """
    Searches pages across the entire site.
    """
    search_form = SearchForm(request.GET)
    pagetypes = []
    results = None
    results_paginated = None

    if search_form.is_valid():
        search_query = search_form.cleaned_data["s"]
        search_model = search_form.cleaned_data["t"]

        # get all page models
        pagemodels = sorted(get_page_models(), key=get_name_of_class)
        # filter based on is search_filterable
        for model in pagemodels:
            if hasattr(model, "search_filterable") and model.search_filterable:
                pagetypes.append(model)

        results = Page.objects.live()
        if search_model:
            try:
                # If provided a model name, try to get it
                model = ContentType.objects.get(
                    model=search_model
                ).model_class()
                results = results.type(model)
            except ContentType.DoesNotExist:
                # Maintain existing behavior of only returning objects if the page type is real
                results = None

        # get and paginate results
        if results:
            results = results.search(search_query)
            paginator = Paginator(
                results, LayoutSettings.for_request(request).search_num_results
            )
            page = request.GET.get("p", 1)
            try:
                results_paginated = paginator.page(page)
            except PageNotAnInteger:
                results_paginated = paginator.page(1)
            except EmptyPage:
                results_paginated = paginator.page(1)
            except InvalidPage:
                results_paginated = paginator.page(1)

    # Render template
    return render(
        request,
        "coderedcms/pages/search.html",
        {
            "request": request,
            "pagetypes": pagetypes,
            "form": search_form,
            "results": results,
            "results_paginated": results_paginated,
        },
    )


@login_required
def serve_protected_file(request, path):
    """
    Function that serves protected files uploaded from forms.
    """
    # Fully resolve all provided paths.
    mediapath = os.path.abspath(crx_settings.CRX_PROTECTED_MEDIA_ROOT)
    fullpath = os.path.abspath(os.path.join(mediapath, path))

    # Path must be a sub-path of the PROTECTED_MEDIA_ROOT, and exist.
    if fullpath.startswith(mediapath) and os.path.isfile(fullpath):
        mimetype, encoding = mimetypes.guess_type(fullpath)
        with open(fullpath, "rb") as f:
            response = HttpResponse(f.read(), content_type=mimetype)
        if encoding:
            response["Content-Encoding"] = encoding

        return response
    raise Http404()


def favicon(request):
    icon = LayoutSettings.for_request(request).favicon
    if icon:
        return HttpResponsePermanentRedirect(
            icon.get_rendition("fill-256x256|format-webp").url
        )
    raise Http404()


def robots(request):
    return render(request, "robots.txt", content_type="text/plain")


@require_POST
def event_generate_single_ical_for_event(request):
    # Parse input.
    try:
        event_pk = request.POST["event_pk"]
    except KeyError:
        return HttpResponse("event_pk required", status=400)

    try:
        dt_start_str = utils.fix_ical_datetime_format(
            request.POST["datetime_start"]
        )
        dt_end_str = utils.fix_ical_datetime_format(
            request.POST["datetime_end"]
        )
        dt_start = None
        dt_end = None
        if dt_start_str:
            dt_start = datetime.strptime(dt_start_str, "%Y-%m-%dT%H:%M:%S%z")
        if dt_end_str:
            dt_end = datetime.strptime(dt_end_str, "%Y-%m-%dT%H:%M:%S%z")
    except KeyError:
        return HttpResponse(
            "datetime_start and datetime_end required.",
            status=400,
        )
    except ValueError:
        return HttpResponse(
            "datetime_start and datetime_end must be valid datetimes.",
            status=400,
        )

    # Get the page.
    try:
        event = CoderedPage.objects.get(pk=event_pk).specific
    except (CoderedPage.DoesNotExist, ValueError):
        raise Http404("Event does not exist")

    # Generate the ical file.
    ical = Calendar()
    ical.add("prodid", "-//Wagtail CRX//")
    ical.add("version", "2.0")
    ical.add_component(
        event.create_single_ical(dt_start=dt_start, dt_end=dt_end)
    )
    response = HttpResponse(ical.to_ical(), content_type="text/calendar")
    response["Filename"] = "{0}.ics".format(event.slug)
    response["Content-Disposition"] = "attachment; filename={0}.ics".format(
        event.slug
    )
    return response


@require_POST
def event_generate_recurring_ical_for_event(request):
    # Parse input.
    try:
        event_pk = request.POST["event_pk"]
    except KeyError:
        return HttpResponse("event_pk required", status=400)

    # Get the page.
    try:
        event = CoderedPage.objects.get(pk=event_pk).specific
    except (CoderedPage.DoesNotExist, ValueError):
        raise Http404("Event does not exist")

    # Generate the ical file.
    ical = Calendar()
    ical.add("prodid", "-//Wagtail CRX//")
    ical.add("version", "2.0")
    for e in event.create_recurring_ical():
        ical.add_component(e)
    response = HttpResponse(ical.to_ical(), content_type="text/calendar")
    response["Filename"] = "{0}.ics".format(event.slug)
    response["Content-Disposition"] = "attachment; filename={0}.ics".format(
        event.slug
    )
    return response


@require_POST
def event_generate_ical_for_calendar(request):
    # Parse input.
    try:
        page_id = request.POST["page_id"]
    except KeyError:
        return HttpResponse("page_id required", status=400)

    # Get the page.
    try:
        page = CoderedPage.objects.get(pk=page_id).specific
    except (CoderedPage.DoesNotExist, ValueError):
        raise Http404("Page does not exist")

    # Generate the ical file.
    ical = Calendar()
    ical.add("prodid", "-//Wagtail CRX//")
    ical.add("version", "2.0")
    for event_page in page.get_index_children():
        for e in event_page.specific.create_recurring_ical():
            ical.add_component(e)
    response = HttpResponse(ical.to_ical(), content_type="text/calendar")
    response["Filename"] = "calendar.ics"
    response["Content-Disposition"] = "attachment; filename=calendar.ics"
    return response


def event_get_calendar_events(request):
    """
    JSON list of events compatible with fullcalendar.js
    """
    # Parse input.
    try:
        page_id = request.GET["pid"]
    except KeyError:
        return HttpResponse("pid required", status=400)

    start = None
    end = None
    start_str = request.GET.get("start", None)
    end_str = request.GET.get("end", None)
    try:
        if start_str:
            start = timezone.make_aware(
                datetime.strptime(start_str[:10], "%Y-%m-%d"),
            )
        if end_str:
            end = timezone.make_aware(
                datetime.strptime(end_str[:10], "%Y-%m-%d"),
            )
    except ValueError:
        return HttpResponse(
            "start and end must be valid datetimes.", status=400
        )

    # Get the page.
    try:
        page = CoderedPage.objects.get(pk=page_id).specific
    except (CoderedPage.DoesNotExist, ValueError):
        raise Http404("Page does not exist")

    return JsonResponse(
        page.get_calendar_events(start=start, end=end), safe=False
    )


@login_required
@permission_required(
    "wagtailadmin.access_admin",
    login_url="wagtailadmin_login",
)
def import_index(request):
    """
    Landing page to replace wagtailimportexport.
    """
    return render(request, "wagtailimportexport/index.html")


@login_required
@permission_required(
    "wagtailadmin.access_admin",
    login_url="wagtailadmin_login",
)
def import_pages_from_csv_file(request):
    """
    Overwrite of the `import_pages` view from wagtailimportexport.  By default, the `import_pages`
    view expects a json file to be uploaded.  This view converts the uploaded csv into the json
    format that the importer expects.
    """

    if request.method == "POST":
        form = ImportPagesFromCSVFileForm(request.POST, request.FILES)
        if form.is_valid():
            import_data = convert_csv_to_json(
                form.cleaned_data["file"].read().decode("utf-8").splitlines(),
                form.cleaned_data["page_type"],
            )
            parent_page = form.cleaned_data["parent_page"]
            try:
                page_count = import_pages(import_data, parent_page)
            except LookupError as e:
                messages.error(
                    request, _("Import failed: %(reason)s") % {"reason": e}
                )
            else:
                messages.success(
                    request,
                    ngettext(
                        "%(count)s page imported.",
                        "%(count)s pages imported.",
                        page_count,
                    )
                    % {"count": page_count},
                )
            return redirect("wagtailadmin_explore", parent_page.pk)
    else:
        form = ImportPagesFromCSVFileForm()

    return render(
        request,
        "wagtailimportexport/import_from_csv.html",
        {
            "form": form,
        },
    )