# The core application of the Mia project.
#   by imacat <imacat@mail.imacat.idv.tw>, 2020/7/4

#  Copyright (c) 2020 imacat.
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.

"""The views of the Mia core application.

"""
from typing import Dict, Type, Optional, Any

from dirtyfields import DirtyFieldsMixin
from django import forms
from django.contrib import messages
from django.contrib.messages.views import SuccessMessageMixin
from django.db.models import Model
from django.http import HttpResponse, HttpRequest, \
    HttpResponseRedirect, Http404
from django.shortcuts import redirect, render
from django.views.generic import DeleteView as CoreDeleteView
from django.views.generic.base import View

from . import stored_post, utils
from .models import BaseModel
from .utils import UrlBuilder


class FormView(View):
    """The base form view."""
    model: Type[Model] = None
    form_class: Type[forms.Form] = None
    template_name: str = None
    context_object_name: str = "form"
    success_url: str = None
    error_url: str = None
    not_modified_message: str = None
    success_message: str = None

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.object: Optional[Model] = None

    def dispatch(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
        """The view to store an accounting transaction."""
        self.object = self.get_object()
        if self.request.method != "POST":
            return self.get(request, *args, **kwargs)
        else:
            return self.post(request, *args, **kwargs)

    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
        """Handles the GET requests."""
        return render(self.request, self.get_template_name(),
                      self.get_context_data(**kwargs))

    def post(self, request: HttpRequest, *args,
             **kwargs) -> HttpResponseRedirect:
        """Handles the POST requests."""
        form = self.get_form(**kwargs)
        if not form.is_valid():
            return self.form_invalid(form)
        return self.form_valid(form)

    def get_form_class(self) -> Type[forms.Form]:
        """Returns the form class."""
        if self.form_class is None:
            raise AttributeError("Please defined the form_class property.")
        return self.form_class

    @property
    def _model(self):
        if self.model is None:
            raise AttributeError("Please defined the model property.")
        return self.model

    def get_context_data(self, **kwargs) -> Dict[str, Any]:
        """Returns the context data for the template."""
        return {self.context_object_name: self.get_form()}

    def get_form(self, **kwargs) -> forms.Form:
        """Returns the form for the template."""
        if self.request.method != "POST":
            previous_post = stored_post.get_previous_post(self.request)
            if previous_post is not None:
                return self.make_form_from_post(previous_post)
            if self.object is not None:
                return self.make_form_from_model(self.object)
            return self.get_form_class()()
        else:
            post = self.request.POST.dict()
            utils.strip_post(post)
            return self.make_form_from_post(post)

    def get_template_name(self) -> str:
        """Returns the name of the template."""
        if self.template_name is not None:
            return self.template_name
        if self.model is not None:
            app_name = self.request.resolver_match.app_name
            model_name = self.model.__name__.lower()
            return F"{app_name}/{model_name}_form.html"
        raise AttributeError(
            "Please either define the template_name or the model property.")

    def make_form_from_post(self, post: Dict[str, str]) -> forms.Form:
        """Creates and returns the form from the POST data."""
        return self.get_form_class()(post)

    def make_form_from_model(self, obj: Model) -> forms.Form:
        """Creates and returns the form from a data model."""
        form_class = self.get_form_class()
        return form_class({x: getattr(obj, x, None)
                           for x in form_class.base_fields})

    def fill_model_from_form(self, obj: Model, form: forms.Form) -> None:
        """Fills in the data model from the form."""
        for name in form.fields:
            setattr(obj, name, form[name].value())
        if isinstance(obj, BaseModel):
            obj.current_user = self.request.user

    def form_invalid(self, form: forms.Form) -> HttpResponseRedirect:
        """Handles the action when the POST form is invalid."""
        return stored_post.error_redirect(
            self.request, self.get_error_url(), form.data)

    def form_valid(self, form: forms.Form) -> HttpResponseRedirect:
        """Handles the action when the POST form is valid."""
        if self.object is None:
            self.object = self._model()
        self.fill_model_from_form(self.object, form)
        if isinstance(self.object, DirtyFieldsMixin)\
                and not self.object.is_dirty(check_relationship=True):
            message = self.get_not_modified_message(form.cleaned_data)
        else:
            self.object.save()
            message = self.get_success_message(form.cleaned_data)
        messages.success(self.request, message)
        return redirect(str(UrlBuilder(self.get_success_url())
                            .query(r=self.request.GET.get("r"))))

    def get_success_url(self) -> str:
        """Returns the URL on success."""
        if self.success_url is not None:
            return self.success_url
        get_absolute_url = getattr(self.object, "get_absolute_url", None)
        if get_absolute_url is not None:
            return get_absolute_url()
        raise AttributeError(
            "Please define either the success_url property,"
            " the get_absolute_url method on the data model,"
            " or the get_success_url method.")

    def get_error_url(self) -> str:
        """Returns the URL on error"""
        if self.error_url is not None:
            return self.error_url
        return self.request.get_full_path()

    def get_not_modified_message(self, cleaned_data: Dict[str, str]) -> str:
        """Returns the message when the data was not modified.

        Args:
            cleaned_data: The cleaned data of the form.

        Returns:
            The message when the data was not modified.
        """
        return self.not_modified_message % cleaned_data

    def get_success_message(self, cleaned_data: Dict[str, str]) -> str:
        """Returns the success message.

        Args:
            cleaned_data: The cleaned data of the form.

        Returns:
            The message when the data was not modified.
        """
        return self.success_message % cleaned_data

    def get_object(self) -> Optional[Model]:
        """Finds and returns the current object, or None on a create form."""
        if "pk" in self.kwargs:
            pk = self.kwargs["pk"]
            try:
                return self._model.objects.get(pk=pk)
            except self._model.DoesNotExist:
                raise Http404
        return None


class DeleteView(SuccessMessageMixin, CoreDeleteView):
    """The delete form view, with SuccessMessageMixin."""

    def delete(self, request, *args, **kwargs):
        response = super(DeleteView, self).delete(request, *args, **kwargs)
        messages.success(request, self.get_success_message({}))
        return response