from rest_framework import serializers
from django.contrib.auth import get_user_model
from .models import Catalog, Category, Author, Publisher, RightsType, Book, BookRight, CartItem, Order, OrderItem, Payment, Language, Format, BookPlatformLink, Currency, HomePageContent, Service, FounderParagraph, FounderAchievement, RightsAgencyFeature, Testimonial, ContactSubmission, FooterQuickLink, FooterServiceItem, NavigationItem, Subscriber, DistributionPackage, AuthorApplication, AuthorApplicationBook, LegacyAuthorInvitation, LegacyInvitationBookEdit

User = get_user_model()

class CatalogSerializer(serializers.ModelSerializer):
    class Meta:
        model = Catalog
        fields = '__all__'

class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = '__all__'

# Public (unauthenticated) serializers: list fields explicitly. Author and
# Publisher also hold payout bank/M-Pesa details, ID numbers, addresses and
# margins — never add '__all__' here.
class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = ['id', 'name', 'slug', 'bio', 'image', 'created_at']

class PublisherSerializer(serializers.ModelSerializer):
    class Meta:
        model = Publisher
        fields = ['id', 'name']

class RightsTypeSerializer(serializers.ModelSerializer):
    class Meta:
        model = RightsType
        fields = '__all__'

class LanguageSerializer(serializers.ModelSerializer):
    class Meta:
        model = Language
        fields = '__all__'

class FormatSerializer(serializers.ModelSerializer):
    class Meta:
        model = Format
        fields = '__all__'

class BookRightSerializer(serializers.ModelSerializer):
    rights_type = RightsTypeSerializer(read_only=True)
    rights_type_id = serializers.PrimaryKeyRelatedField(queryset=RightsType.objects.all(), source='rights_type', write_only=True)

    class Meta:
        model = BookRight
        fields = ['id', 'rights_type', 'rights_type_id', 'price', 'currency', 'exclusive', 'available_quantity', 'status', 'additional_details']
        read_only_fields = ['id','status']

class BookPlatformLinkSerializer(serializers.ModelSerializer):
    platform = serializers.CharField(source='platform.name', read_only=True)
    class Meta:
        model = BookPlatformLink
        fields = ['platform', 'url']

class BookListSerializer(serializers.ModelSerializer):
    author = AuthorSerializer(read_only=True)
    catalog = CatalogSerializer(read_only=True)
    category = CategorySerializer(read_only=True)
    available_rights = BookRightSerializer(source='available_book_rights', many=True, read_only=True)
    available_formats = FormatSerializer(many=True, read_only=True)
    platform_links = BookPlatformLinkSerializer(many=True, read_only=True)
    currency = serializers.CharField(source='currency.code', read_only=True)
    units_sold = serializers.SerializerMethodField()
    price = serializers.SerializerMethodField()
    # Name only (no contact details) — lets the store search by publisher.
    publisher_name = serializers.CharField(source='publisher.name', read_only=True, default=None)

    class Meta:
        model = Book
        fields = ['id', 'slug', 'title', 'subtitle', 'cover', 'publication_year', 'author', 'publisher_name', 'catalog', 'category', 'price', 'old_price', 'rating', 'review_count', 'currency', 'stock', 'available_rights', 'available_formats', 'platform_links', 'is_featured', 'units_sold']

    def get_units_sold(self, obj):
        # Only present when the queryset was annotated (BookViewSet.bestsellers) —
        # None on the regular list/detail endpoints rather than an extra query.
        return getattr(obj, 'units_sold', None)

    def get_price(self, obj):
        return obj.effective_price

class BookDetailSerializer(serializers.ModelSerializer):
    author = AuthorSerializer(read_only=True)
    catalog = CatalogSerializer(read_only=True)
    category = CategorySerializer(read_only=True)
    publisher = PublisherSerializer(read_only=True)
    book_rights = BookRightSerializer(many=True, read_only=True)
    available_languages = LanguageSerializer(many=True, read_only=True)
    available_formats = FormatSerializer(many=True, read_only=True)
    platform_links = BookPlatformLinkSerializer(many=True, read_only=True)
    currency = serializers.CharField(source='currency.code', read_only=True)
    price = serializers.SerializerMethodField()

    class Meta:
        model = Book
        fields = '__all__'

    def get_price(self, obj):
        return obj.effective_price

class CartItemSerializer(serializers.ModelSerializer):
    book_right = BookRightSerializer(read_only=True)
    book_right_id = serializers.PrimaryKeyRelatedField(queryset=BookRight.objects.all(), source='book_right', write_only=True)

    class Meta:
        model = CartItem
        fields = ['id','user','book_right','book_right_id','quantity','added_at']
        read_only_fields = ['id','user','book_right','added_at']

class OrderItemSerializer(serializers.ModelSerializer):
    book_right = BookRightSerializer(read_only=True)
    class Meta:
        model = OrderItem
        fields = '__all__'

class OrderSerializer(serializers.ModelSerializer):
    order_items = OrderItemSerializer(many=True, read_only=True)
    class Meta:
        model = Order
        fields = ['id','user','total_amount','currency','status','created_at','order_items']

class PaymentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Payment
        fields = '__all__'

class AuthorDetailSerializer(serializers.ModelSerializer):
    books = BookListSerializer(many=True, read_only=True)
    class Meta:
        model = Author
        fields = ['id', 'name', 'slug', 'bio', 'image', 'created_at', 'books']

class NavigationItemSerializer(serializers.ModelSerializer):
    class Meta:
        model = NavigationItem
        fields = ['label', 'href']

class ServiceSerializer(serializers.ModelSerializer):

    class Meta:
        model = Service
        fields = ['title', 'description', 'icon', 'button_active', 'button_label', 'button_url']

class FounderParagraphSerializer(serializers.ModelSerializer):
    class Meta:
        model = FounderParagraph
        fields = ['text']

class FounderAchievementSerializer(serializers.ModelSerializer):
    class Meta:
        model = FounderAchievement
        fields = ['icon', 'number', 'label']

class RightsAgencyFeatureSerializer(serializers.ModelSerializer):
    class Meta:
        model = RightsAgencyFeature
        fields = ['text']

class TestimonialSerializer(serializers.ModelSerializer):
    class Meta:
        model = Testimonial
        fields = ['quote', 'author', 'title']

class FooterQuickLinkSerializer(serializers.ModelSerializer):
    class Meta:
        model = FooterQuickLink
        fields = ['text', 'url']

class FooterServiceItemSerializer(serializers.ModelSerializer):
    class Meta:
        model = FooterServiceItem
        fields = ['text']

class ContactSubmissionSerializer(serializers.ModelSerializer):
    firstName = serializers.CharField(source='first_name', max_length=100)
    lastName = serializers.CharField(source='last_name', max_length=100)

    class Meta:
        model = ContactSubmission
        fields = ['firstName', 'lastName', 'email', 'subject', 'message']

class SubscriberSerializer(serializers.ModelSerializer):
    class Meta:
        model = Subscriber
        fields = ['email']


class HomePageContentSerializer(serializers.ModelSerializer):
    background_image = serializers.ImageField(use_url=True, required=False)
    founder_image = serializers.ImageField(use_url=True, required=False)
    rights_agency_image = serializers.ImageField(use_url=True, required=False)
    navigation_items = NavigationItemSerializer(many=True, read_only=True)
    services = ServiceSerializer(many=True, read_only=True)
    founder_paragraphs = FounderParagraphSerializer(many=True, read_only=True)
    founder_achievements = FounderAchievementSerializer(many=True, read_only=True)
    rights_agency_features = RightsAgencyFeatureSerializer(many=True, read_only=True)
    testimonials = TestimonialSerializer(many=True, read_only=True)
    footer_quick_links = FooterQuickLinkSerializer(many=True, read_only=True)
    footer_service_items = FooterServiceItemSerializer(many=True, read_only=True)

    class Meta:
        model = HomePageContent
        fields = [
            'navigation_items',
            'title', 'subtitle', 'background_image', 'button_text',
            'about_title_start', 'about_title_end', 'about_description',
            'services_title_start', 'services_title_end', 'services_description',
            'services',
            'founder_headline_start', 'founder_headline_end', 'founder_title', 'founder_image',
            'founder_paragraphs', 'founder_achievements',
            'rights_agency_headline_start', 'rights_agency_headline_end', 'rights_agency_description',
            'rights_agency_button_text', 'rights_agency_image', 'rights_agency_features',
            'testimonials_title_start', 'testimonials_title_end', 'testimonials_description',
            'testimonials', 'contact_title_start', 'contact_title_end', 'contact_description',
            'contact_email', 'contact_phone', 'contact_address',
            'contact_facebook_url', 'contact_instagram_url', 'contact_linkedin_url',
            'contact_twitter_url', 'newsletter_title', 'newsletter_description', 'footer_brand_name',
            'footer_description', 'footer_quick_links_title', 'footer_services_title',
            'footer_copyright_text', 'footer_quick_links', 'footer_service_items',
        ]


# ---------------------------------------------------------------------------
# Author distribution applications
# ---------------------------------------------------------------------------

class DistributionPackageSerializer(serializers.ModelSerializer):
    class Meta:
        model = DistributionPackage
        fields = [
            'id', 'name', 'tier', 'description', 'my_keep_percent',
            'allows_external_bookstores', 'external_bookstore_author_percent',
            'book_signings_included',
            'includes_social_media_management', 'is_featured',
        ]


class AuthorApplicationBookSerializer(serializers.ModelSerializer):
    class Meta:
        model = AuthorApplicationBook
        fields = ['id', 'title', 'isbn', 'category', 'description', 'publication_year', 'selling_price_kes', 'copies_to_deliver']
        read_only_fields = ['id']


class AuthorApplicationSerializer(serializers.ModelSerializer):
    """
    signed_at / signed_ip_address are deliberately not writable here — the
    view sets them from the server clock / request at submission time, not
    from client-supplied values, so they stay trustworthy as proof of signing.
    """
    books = AuthorApplicationBookSerializer(many=True)

    class Meta:
        model = AuthorApplication
        fields = [
            'id', 'package', 'full_name', 'email', 'phone', 'bio', 'address', 'id_number',
            'payment_method', 'payment_account_name', 'payment_reference', 'payment_phone',
            'payment_email', 'payment_details_confirmed',
            'bank_name', 'bank_account_number', 'bank_branch', 'bank_branch_code', 'bank_account_type',
            'bank_swift_code', 'bank_address', 'recipient_address', 'payment_currency', 'intermediary_bank_details',
            'paybill_number', 'paybill_account_number',
            'till_number',
            'signed_name', 'books',
        ]
        read_only_fields = ['id']

    def validate_package(self, value):
        if not value.is_active:
            raise serializers.ValidationError("This package is no longer available.")
        return value

    def validate_books(self, value):
        if not value:
            raise serializers.ValidationError("Include at least one book.")
        return value

    def validate_payment_details_confirmed(self, value):
        if not value:
            raise serializers.ValidationError(
                "You must confirm the payment details are correct and belong to you before submitting."
            )
        return value

    def create(self, validated_data):
        books_data = validated_data.pop('books')
        application = AuthorApplication.objects.create(**validated_data)
        AuthorApplicationBook.objects.bulk_create([
            AuthorApplicationBook(application=application, **book_data)
            for book_data in books_data
        ])
        return application


class AgreementPreviewSerializer(serializers.ModelSerializer):
    """
    Same shape as AuthorApplicationSerializer minus the signature/confirmation
    requirements — used to validate input for the pre-submission agreement
    preview, where the applicant hasn't signed or confirmed anything yet
    (that's the point of showing them the preview).
    """
    books = AuthorApplicationBookSerializer(many=True)

    class Meta:
        model = AuthorApplication
        fields = [
            'package', 'full_name', 'email', 'phone', 'bio', 'address', 'id_number',
            'payment_method', 'payment_account_name', 'payment_reference', 'payment_phone',
            'payment_email',
            'bank_name', 'bank_account_number', 'bank_branch', 'bank_branch_code', 'bank_account_type',
            'bank_swift_code', 'bank_address', 'recipient_address', 'payment_currency', 'intermediary_bank_details',
            'paybill_number', 'paybill_account_number',
            'till_number',
            'books',
        ]

    def validate_books(self, value):
        if not value:
            raise serializers.ValidationError("Include at least one book.")
        return value


class AuthorApplicationBookCoverSerializer(serializers.ModelSerializer):
    class Meta:
        model = AuthorApplicationBook
        fields = ['cover']


# ---------------------------------------------------------------------------
# Legacy author invitations (retroactive agreement signing for
# already-catalogued authors/books)
# ---------------------------------------------------------------------------

_LEGACY_PAYMENT_FIELDS = [
    'payment_method', 'payment_account_name', 'payment_reference', 'payment_phone',
    'payment_email', 'payment_details_confirmed',
    'bank_name', 'bank_account_number', 'bank_branch', 'bank_branch_code', 'bank_account_type',
    'bank_swift_code', 'bank_address', 'recipient_address', 'payment_currency', 'intermediary_bank_details',
    'paybill_number', 'paybill_account_number',
    'till_number',
]


class LegacyInvitationBookSerializer(serializers.Serializer):
    """
    Read-only — book data merged with any pending edit the author made
    while signing (see legacy_invitation_service.effective_books). Books
    themselves are fixed by staff at invitation creation, never added/
    removed by the author — but title/cover/price can be requested-changed.
    Not a ModelSerializer: source objects are _EffectiveBook, not Book.
    """
    id = serializers.IntegerField()
    title = serializers.CharField()
    isbn = serializers.CharField(allow_blank=True, allow_null=True)
    cover = serializers.SerializerMethodField()
    category = serializers.SerializerMethodField()
    publication_year = serializers.IntegerField(allow_null=True)
    selling_price_kes = serializers.DecimalField(max_digits=10, decimal_places=2, allow_null=True)
    has_pending_edit = serializers.BooleanField()

    def get_cover(self, obj):
        if not obj.cover:
            return None
        request = self.context.get('request')
        url = obj.cover.url
        return request.build_absolute_uri(url) if request else url

    def get_category(self, obj):
        return obj.category.name if obj.category_id and obj.category else None


class LegacyInvitationBookEditSerializer(serializers.ModelSerializer):
    """
    PATCH /api/legacy-invitations/<token>/books/<book_id>/ — stages a
    title/cover/price change for one book. Blank/omitted fields mean "no
    change requested" for that field; applied to the real Book only on
    admin approval.
    """
    class Meta:
        model = LegacyInvitationBookEdit
        fields = ['title', 'cover', 'selling_price_kes']


class LegacyAuthorSummarySerializer(serializers.ModelSerializer):
    """Read-only snapshot of the author's current known data, used to pre-fill the signing form —
    the author still submits everything themselves; this just saves them retyping what's on file."""
    class Meta:
        model = Author
        fields = [
            'name', 'email', 'bio', 'address', 'id_number',
            'payment_method', 'payment_account_name', 'payment_reference', 'payment_phone',
            'payment_email',
            'bank_name', 'bank_account_number', 'bank_branch', 'bank_branch_code', 'bank_account_type',
            'bank_swift_code', 'bank_address', 'recipient_address', 'payment_currency', 'intermediary_bank_details',
            'paybill_number', 'paybill_account_number',
            'till_number',
        ]


class LegacyInvitationDetailSerializer(serializers.ModelSerializer):
    """GET /api/legacy-invitations/<token>/ — read-only, used to render the signing wizard."""
    author = LegacyAuthorSummarySerializer(read_only=True)
    books = serializers.SerializerMethodField()
    is_expired = serializers.BooleanField(read_only=True)

    def get_books(self, obj):
        from catalog_app.services.legacy_invitation_service import effective_books
        return LegacyInvitationBookSerializer(effective_books(obj), many=True, context=self.context).data

    class Meta:
        model = LegacyAuthorInvitation
        fields = ['id', 'status', 'author', 'books', 'expires_at', 'is_expired']


class LegacyInvitationSubmitSerializer(serializers.ModelSerializer):
    """
    POST /api/legacy-invitations/<token>/submit/
    Books are fixed (set by staff at creation) — not writable here, unlike
    AuthorApplicationSerializer where the applicant lists their own books.
    signed_at / signed_ip_address are server-set, same reasoning as
    AuthorApplicationSerializer.
    """
    class Meta:
        model = LegacyAuthorInvitation
        fields = [
            'package', 'bio', 'address', 'id_number',
            *_LEGACY_PAYMENT_FIELDS,
            'signed_name',
        ]

    def validate_package(self, value):
        if not value.is_active:
            raise serializers.ValidationError("This package is no longer available.")
        return value

    def validate_payment_details_confirmed(self, value):
        if not value:
            raise serializers.ValidationError(
                "You must confirm the payment details are correct and belong to you before submitting."
            )
        return value


class LegacyAgreementPreviewSerializer(serializers.ModelSerializer):
    """Same shape as LegacyInvitationSubmitSerializer minus the signature/confirmation requirements."""
    class Meta:
        model = LegacyAuthorInvitation
        fields = [
            'package', 'bio', 'address', 'id_number',
            *_LEGACY_PAYMENT_FIELDS,
        ]
