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

"""

import json

from django.db.models import QuerySet

from api.utils.serializer.serializer import AbstractModelAPISerializer
from codelist.models import KonovaCode
from codelist.settings import CODELIST_COMPENSATION_ACTION_ID, CODELIST_BIOTOPES_ID
from compensation.models import CompensationAction, UnitChoices, CompensationState
from intervention.models import Responsibility, Legal
from konova.models import Deadline, DeadlineType


class AbstractModelAPISerializerV1(AbstractModelAPISerializer):
    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 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 konova_code_from_json(self, json_str, code_list_identifier):
        """ Returns a konova code instance

        Args:
            json_str (str): The value for the code (atom id)
            code_list_identifier (str): From which konova code list this code is supposed to be from

        Returns:

        """
        if json_str is None or len(json_str) == 0:
            return None
        code = KonovaCode.objects.get(
            atom_id=json_str,
            code_lists__in=[code_list_identifier]
        )
        return code

    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


class DeductableAPISerializerV1Mixin:
    class Meta:
        abstract = True

    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
        ]


class ResponsibilityAPISerializerV1Mixin:
    class Meta:
        abstract = True

    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,
        }


class LegalAPISerializerV1Mixin:
    class Meta:
        abstract = True

    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()],
        }


class AbstractCompensationAPISerializerV1Mixin:
    class Meta:
        abstract = True

    def set_deadlines(self, obj, deadline_data):
        """ Sets the linked deadline data according to the given deadline_data


        Args:
            obj (Compensation): The Compensation object
            deadline_data (dict): The posted deadline_data

        Returns:
            obj (Compensation)
        """
        found_deadlines = []
        for entry in deadline_data:
            deadline_type = entry["type"]
            date = entry["date"]
            comment = entry["comment"]

            if deadline_type not in DeadlineType:
                raise ValueError(f"Invalid deadline type. Choices are {DeadlineType.values}")

            pre_existing_deadlines = obj.deadlines.filter(
                type=deadline_type,
                date=date,
                comment=comment,
            ).exclude(
                id__in=found_deadlines
            )
            if pre_existing_deadlines.count() > 0:
                found_deadlines += pre_existing_deadlines.values_list("id", flat=True)
            else:
                # Create!
                new_deadline = Deadline.objects.create(
                    type=deadline_type,
                    date=date,
                    comment=comment,
                )
                obj.deadlines.add(new_deadline)
        return obj

    def set_compensation_states(self, obj, states_data, states_manager):
        """ Sets the linked compensation state data according to the given states_data


        Args:
            obj (Compensation): The Compensation object
            states_data (dict): The posted states_data
            states_manager (Manager): The before_states or after_states manager

        Returns:
            obj (Compensation)
        """
        found_states = []
        for entry in states_data:
            biotope_type = entry["biotope"]
            surface = float(entry["surface"])
            if surface <= 0:
                raise ValueError("State surfaces must be > 0")
            pre_existing_states = states_manager.filter(
                biotope_type__atom_id=biotope_type,
                surface=surface,
            ).exclude(
                id__in=found_states
            )
            if pre_existing_states.count() > 0:
                found_states += pre_existing_states.values_list("id", flat=True)
            else:
                # Create!
                new_state = CompensationState.objects.create(
                    biotope_type=self.konova_code_from_json(biotope_type, CODELIST_BIOTOPES_ID),
                    surface=surface
                )
                states_manager.add(new_state)
        return obj

    def set_compensation_actions(self, obj, actions_data):
        """ Sets the linked compensation action data according to the given actions_data


        Args:
            obj (Compensation): The Compensation object
            actions_data (dict): The posted actions_data

        Returns:
            obj (Compensation)
        """
        found_actions = []
        for entry in actions_data:
            action = entry["action"]
            amount = float(entry["amount"])
            unit = entry["unit"]
            comment = entry["comment"]

            if amount <= 0:
                raise ValueError("Action amount must be > 0")
            if unit not in UnitChoices:
                raise ValueError(f"Invalid unit. Choices are {UnitChoices.values}")
            pre_existing_actions = obj.actions.filter(
                action_type__atom_id=action,
                amount=amount,
                unit=unit,
                comment=comment,
            ).exclude(
                id__in=found_actions
            )
            if pre_existing_actions.count() > 0:
                found_actions += pre_existing_actions.values_list("id", flat=True)
            else:
                # Create!
                new_action = CompensationAction.objects.create(
                    action_type=self.konova_code_from_json(action, CODELIST_COMPENSATION_ACTION_ID),
                    amount=amount,
                    unit=unit,
                    comment=comment,
                )
                obj.actions.add(new_action)
        return obj

    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",
        ))