from rest_framework import serializers

from apps.account.serializers.account_serializers import ProfileSerializer
from apps.station import models
from apps.station.serializers.station_serializers import StationMasterSerializer
from base.serializers import DynamicFieldsModelSerializer


class StationEditRequestMediaSerializer(DynamicFieldsModelSerializer):
    """
    This is the StationEditRequestMediaSerializer class responsible for serializing and deserializing station media assets.

    It allows users to manage the upload and retrieval of media assets associated with station data.

    Meta:
        model (SuggestStationMedia): The model used for serialization and deserialization.
        fields (tuple): Specifies the fields included in the serialization and deserialization process.
        read_only_fields (tuple): Fields that are marked as read-only.
    """

    class Meta:
        model = models.SuggestStationMedia
        fields = ("id", "asset", "asset_type", "suggest_station", "user")
        read_only_fields = ("id", "suggest_station", "user")


class StationEditRequestSerializer(DynamicFieldsModelSerializer):
    """
    This is the StationEditRequestSerializer class responsible for serializing and deserializing station data.

    It allows users to manage the creation and retrieval of station data, including a description.

    Meta:
        model (SuggestStation): The model used for serialization and deserialization.
        fields (tuple): Specifies the fields included in the serialization and deserialization process.
        read_only_fields (tuple): Fields that are marked as read-only.
        extra_kwargs (dict): Additional arguments for controlling field behavior.
    """

    station_data = StationMasterSerializer(
        source="station",
        fields=["id", "name", "description", "coordinates"],
        read_only=True,
    )
    user_data = ProfileSerializer(
        source="user",
        fields=["id", "name", "email", "profile_pic", "mobile_number"],
        read_only=True,
    )

    assets = serializers.SerializerMethodField(read_only=True)

    class Meta:
        model = models.SuggestStation
        fields = (
            "id",
            "station",
            "user",
            "description",
            "status",
            "station_data",
            "user_data",
            "assets",
        )
        read_only_fields = ("id", "user")
        extra_kwargs = {
            "description": {"required": True, "allow_null": False},
            "station": {"write_only": True},
        }

    def get_assets(self, obj):
        assets_queryset = obj.suggest_station_medias.all()
        assets_serializer = StationEditRequestMediaSerializer(
            assets_queryset,
            fields=["id", "asset", "asset_type"],
            many=True,
            context=self.context,
        )
        return assets_serializer.data


class StationReportReasonSerializer(DynamicFieldsModelSerializer):

    """
    This is the StationReportReasonSerializer class responsible for serializing station report reasons.

    It allows users to manage the serialization of station report reason data.

    Meta:
        model (StationReasonMaster): The model used for serialization and deserialization.
        fields (tuple): Specifies the fields included in the serialization and deserialization process.
        read_only_fields (tuple): Fields that are marked as read-only.
    """

    class Meta:
        model = models.StationReasonMaster
        fields = ("id", "title")
        read_only_fields = fields


class StationReportSerializer(DynamicFieldsModelSerializer):

    """
    This is the StationReportSerializer class responsible for serializing station report data.

    It allows users to manage the serialization of station report data.

    Meta:
    model (StationReport): The model used for serialization and deserialization.
    fields (tuple): Specifies the fields included in the serialization and deserialization process.
    read_only_fields (tuple): Fields that are marked as read-only.
    """

    class Meta:
        model = models.StationReport
        fields = ("id", "reason", "station", "description", "user")
        read_only_fields = ("id", "user")

    def validate(self, data):
        """
        Validate the presence of a label or description.

        Args:
        data: The input data to validate.

        Returns:
        Validated data.

        Raises:
        serializers.ValidationError: If both reason and description are missing.
        """
        reason = data.get("reason")
        description = data.get("description")
        if reason is None and (description is None or description == ""):
            raise serializers.ValidationError("Description field is required")
        return data