"""
Author: Michel Peltriaux
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
Contact: michel.peltriaux@sgdnord.rlp.de
Created on: 21.01.22

"""
import json

from django.db.models import QuerySet
from django.http import JsonResponse, HttpRequest

from api.views.views import AbstractModelAPIView
from codelist.models import KonovaCode
from intervention.models import Responsibility, Legal


class AbstractModelAPIViewV1(AbstractModelAPIView):
    """ Holds general serialization functions for API v1

    """

    def get(self, request: HttpRequest, id):
        """ Handles the GET request

        Performs the fetching and serialization of the data

        Args:
            request (HttpRequest): The incoming request
            id (str): The entries id

        Returns:

        """
        self.prepare_lookup(id)

        try:
            data = self.fetch_and_serialize()
        except Exception as e:
            return self.return_error_response(e, 500)
        return JsonResponse(data)

    def model_to_geo_json(self, entry):
        """ Adds the basic data, which all elements hold

        Args:
            entry (): The data entry

        Returns:

        """
        geom = entry.geometry.geom.geojson
        geo_json = json.loads(geom)
        self.properties_data = {
            "id": entry.id,
            "identifier": entry.identifier,
            "title": entry.title,
            "created_on": self.created_on_to_json(entry),
            "modified_on": self.modified_on_to_json(entry),
        }
        self.extend_properties_data(entry)
        geo_json["properties"] = self.properties_data
        return geo_json

    def prepare_lookup(self, id):
        """ Customizes lookup values for db filtering

        Args:
            id (str): The entries id

        Returns:

        """
        self.lookup["id"] = id
        self.lookup["users__in"] = [self.user]

    def konova_code_to_json(self, konova_code: KonovaCode):
        """ Serializes KonovaCode model into json

        Args:
            konova_code (KonovaCode): The KonovaCode entry

        Returns:
            serialized_json (dict)
        """
        return {
            "atom_id": konova_code.atom_id,
            "long_name": konova_code.long_name,
            "short_name": konova_code.short_name,
        }

    def responsible_to_json(self, responsible: Responsibility):
        """ Serializes Responsibility model into json

        Args:
            responsible (Responsibility): The Responsibility entry

        Returns:
            serialized_json (dict)
        """
        return {
            "registration_office": self.konova_code_to_json(responsible.registration_office),
            "registration_file_number": responsible.registration_file_number,
            "conservation_office": self.konova_code_to_json(responsible.conservation_office),
            "conservation_file_number": responsible.conservation_file_number,
            "handler": responsible.handler,
        }

    def legal_to_json(self, legal: Legal):
        """ Serializes Legal model into json

        Args:
            legal (Legal): The Legal entry

        Returns:
            serialized_json (dict)
        """
        return {
            "registration_date": legal.registration_date,
            "binding_date": legal.binding_date,
            "process_type": self.konova_code_to_json(legal.process_type),
            "laws": [self.konova_code_to_json(law) for law in legal.laws.all()],
        }

    def payments_to_json(self, qs: QuerySet):
        """ Serializes payments into json

        Args:
            qs (QuerySet): A queryset of Payment entries

        Returns:
            serialized_json (list)
        """
        return list(qs.values("amount", "due_on", "comment"))

    def deductions_to_json(self, qs: QuerySet):
        """ Serializes eco account deductions into json

        Args:
            qs (QuerySet): A queryset of EcoAccountDeduction entries

        Returns:
            serialized_json (list)
        """
        return [
            {
                "id": entry.pk,
                "eco_account": {
                    "id": entry.account.pk,
                    "identifier": entry.account.identifier,
                    "title": entry.account.title,
                },
                "surface": entry.surface,
                "intervention": {
                    "id": entry.intervention.pk,
                    "identifier": entry.intervention.identifier,
                    "title": entry.intervention.title,
                }
            }
            for entry in qs
        ]

    def compensation_state_to_json(self, qs: QuerySet):
        """ Serializes compensation states into json

        Args:
            qs (QuerySet): A queryset of CompensationState entries

        Returns:
            serialized_json (list)
        """
        return [
            {
                "biotope": self.konova_code_to_json(entry.biotope_type),
                "surface": entry.surface,
            }
            for entry in qs
        ]

    def compensation_actions_to_json(self, qs: QuerySet):
        """ Serializes CompensationActions into json

        Args:
            qs (QuerySet): A queryset of CompensationAction entries

        Returns:
            serialized_json (list)
        """
        return [
            {
                "action": self.konova_code_to_json(entry.action_type),
                "amount": entry.amount,
                "unit": entry.unit,
                "comment": entry.comment,
            }
            for entry in qs
        ]

    def deadlines_to_json(self, qs: QuerySet):
        """ Serializes deadlines into json

        Args:
            qs (QuerySet): A queryset of Deadline entries

        Returns:
            serialized_json (list)
        """
        return list(qs.values(
            "type",
            "date",
            "comment",
        ))

    def created_on_to_json(self, entry):
        """ Serializes the created_on into json

        Args:
            entry (BaseObject): The entry

        Returns:
            created_on (timestamp)
        """
        return entry.created.timestamp

    def modified_on_to_json(self, entry):
        """ Serializes the modified_on into json

        Args:
            entry (BaseObject): The entry

        Returns:
            modified_on (timestamp)
        """
        modified_on = entry.modified or entry.created
        modified_on = modified_on.timestamp
        return modified_on