from rest_framework import serializers
from api.models.data.currency import CURRENCY_CHOICES, currency_details as _currency_details_fn
from api.models.data.returns import Return, ReturnItems
from api.serializers.data.base import DataRootSerializer
from api.mixins.base_currency import BaseCurrencySerializerMixin
from api.utils.order_numeric import quantize_return_amount, quantize_return_qty




class ReturnItemsSerializer(DataRootSerializer):
    sales_item_details = serializers.SerializerMethodField()
    product_details = serializers.SerializerMethodField()

    class Meta:
        model = ReturnItems
        fields = "__all__"

    def get_sales_item_details(self, obj):
        if not obj.sales_item:
            return None
        item = obj.sales_item
        if item.sale_source == 'tank' and item.storage_tank_id:
            from api.services.tank_inventory import tank_product_label
            product_name = tank_product_label(item.storage_tank)
        else:
            product_name = (
                item.stock.product.name
                if item.stock_id and item.stock.product_id
                else None
            )
        return {
            "id": item.id,
            "product": product_name,
            "sale_source": item.sale_source,
            "liter_amount": item.liter_amount,
            "sell_price": item.sell_price,
        }

    def get_product_details(self, obj):
        if not obj.sales_item:
            return None
        item = obj.sales_item
        if item.sale_source == 'tank' and item.storage_tank_id:
            from api.services.tank_inventory import tank_product_label
            return {
                "id": None,
                "name": tank_product_label(item.storage_tank),
                "barcode": None,
                "is_tank_fill": True,
            }
        if item.stock_id and item.stock.product_id:
            return {
                "id": item.stock.product.id,
                "name": item.stock.product.name,
                "barcode": item.stock.product.barcode,
            }
        return None

    def validate(self, attrs):
        attrs = super().validate(attrs)
        if 'liter_amount' in attrs and attrs['liter_amount'] is not None:
            attrs['liter_amount'] = quantize_return_qty(attrs['liter_amount'])
        if 'return_price' in attrs and attrs['return_price'] is not None:
            attrs['return_price'] = quantize_return_amount(attrs['return_price'])
        return attrs


class ReturnSerializer(BaseCurrencySerializerMixin, DataRootSerializer):
    base_currency_amount_fields = ('total_amount', 'refund_amount')
    base_currency_date_field = 'return_date'

    currency = serializers.IntegerField()
    sales_details = serializers.SerializerMethodField()
    currency_details = serializers.SerializerMethodField()

    class Meta:
        model = Return
        fields = "__all__"
        read_only_fields = (
        )

    def validate(self, attrs):
        attrs = super().validate(attrs)
        for field in ('total_amount', 'refund_amount'):
            if field in attrs and attrs[field] is not None:
                attrs[field] = quantize_return_amount(attrs[field])
        return attrs

    def get_sales_details(self, obj):
        if obj.sales:
            return {
                "id": obj.sales.id,
                "invoice_number": obj.sales.invoice_number,
            }
        return None

    def get_currency_details(self, obj):
        return _currency_details_fn(obj.currency)