from rest_framework import serializers
from .models import AccountingPeriod, LedgerClassification, ClubBudget, BudgetLine, FFPPolicy, FFPAssessment, FinancialControlEvent


class AccountingPeriodSerializer(serializers.ModelSerializer):
    def validate(self,data):
        if data['ends_at'] <= data['starts_at']:
            raise serializers.ValidationError({'ends_at':'End must follow start'})
        return data
    class Meta: model = AccountingPeriod; fields = "__all__"; read_only_fields = ("club", "is_closed", "closed_at")

class LedgerClassificationSerializer(serializers.ModelSerializer):
    class Meta: model = LedgerClassification; fields = "__all__"

class BudgetLineSerializer(serializers.ModelSerializer):
    class Meta: model = BudgetLine; fields = ("id", "category", "planned_amount", "hard_limit", "warning_threshold_pct", "created_at", "updated_at")

class ClubBudgetSerializer(serializers.ModelSerializer):
    lines = BudgetLineSerializer(many=True, read_only=True)
    class Meta: model = ClubBudget; fields = "__all__"; read_only_fields = ("club", "status", "activated_at", "closed_at")

class FFPPolicySerializer(serializers.ModelSerializer):
    class Meta: model = FFPPolicy; fields = "__all__"

class FFPAssessmentSerializer(serializers.ModelSerializer):
    class Meta: model = FFPAssessment; fields = "__all__"

class FinancialControlEventSerializer(serializers.ModelSerializer):
    class Meta: model = FinancialControlEvent; fields = "__all__"

from .models import (
    GLAccount, JournalEntry, JournalLine, AccrualDocument, FixedAssetBook,
    PlayerRegistrationAsset, FinancialStatementSnapshot,
)


class GLAccountSerializer(serializers.ModelSerializer):
    class Meta:
        model = GLAccount
        fields = ("id", "code", "name", "account_type", "normal_balance", "is_control_account", "is_active")


class JournalLineSerializer(serializers.ModelSerializer):
    account_code = serializers.CharField(source="account.code", read_only=True)
    account_name = serializers.CharField(source="account.name", read_only=True)
    class Meta:
        model = JournalLine
        fields = ("id", "line_no", "account", "account_code", "account_name", "debit", "credit", "description", "metadata")


class JournalEntrySerializer(serializers.ModelSerializer):
    lines = JournalLineSerializer(many=True, read_only=True)
    class Meta:
        model = JournalEntry
        fields = ("id", "journal_no", "period", "accounting_date", "status", "source_type", "source_id", "memo", "checksum", "posted_at", "lines")


class AccrualDocumentSerializer(serializers.ModelSerializer):
    outstanding_amount = serializers.DecimalField(max_digits=24, decimal_places=8, read_only=True)
    recognition_account_code = serializers.CharField(source="recognition_account.code", read_only=True)
    control_account_code = serializers.CharField(source="control_account.code", read_only=True)
    class Meta:
        model = AccrualDocument
        fields = ("id", "period", "document_type", "counterparty_label", "original_amount", "settled_amount", "outstanding_amount", "recognized_on", "due_date", "status", "source_type", "source_id", "recognition_account_code", "control_account_code", "metadata", "created_at")


class FixedAssetBookSerializer(serializers.ModelSerializer):
    carrying_amount = serializers.DecimalField(max_digits=24, decimal_places=8, read_only=True)
    asset_name = serializers.CharField(source="asset.name", read_only=True)
    asset_type = serializers.CharField(source="asset.asset_type", read_only=True)
    class Meta:
        model = FixedAssetBook
        fields = ("id", "asset", "asset_name", "asset_type", "acquisition_cost", "residual_value", "accumulated_depreciation", "carrying_amount", "useful_life_months", "placed_in_service", "last_depreciated_through", "disposed_on", "source_type", "source_id")


class PlayerRegistrationAssetSerializer(serializers.ModelSerializer):
    carrying_amount = serializers.DecimalField(max_digits=24, decimal_places=8, read_only=True)
    class Meta:
        model = PlayerRegistrationAsset
        fields = ("id", "player", "contract", "acquisition_cost", "accumulated_amortization", "carrying_amount", "starts_on", "ends_on", "last_amortized_through", "disposed_on", "source_transfer_id")


class FinancialStatementSnapshotSerializer(serializers.ModelSerializer):
    class Meta:
        model = FinancialStatementSnapshot
        fields = "__all__"

# ---------------------------------------------------------------------------
# Regulatory FFP bridge serializers
# ---------------------------------------------------------------------------
from .models import (
    FFPRegulatoryPolicy, FFPRegulatoryAdjustment, FFPRelatedPartyReview,
    FFPRegulatoryAssessment, FFPRegulatorySubmission, FFPFederationReviewCase,
    FFPRegulatoryCaseEvent,
)


class FFPRegulatoryPolicySerializer(serializers.ModelSerializer):
    class Meta:
        model = FFPRegulatoryPolicy
        fields = "__all__"
        read_only_fields = ("federation", "created_at")


class FFPRegulatoryAdjustmentSerializer(serializers.ModelSerializer):
    class Meta:
        model = FFPRegulatoryAdjustment
        fields = "__all__"
        read_only_fields = ("club", "requested_by", "reviewed_by", "submitted_at", "reviewed_at", "created_at", "status")


class FFPRelatedPartyReviewSerializer(serializers.ModelSerializer):
    sponsor_name = serializers.CharField(source="agreement.sponsor_name", read_only=True)
    class Meta:
        model = FFPRelatedPartyReview
        fields = "__all__"
        read_only_fields = (
            "club", "reported_revenue", "status", "disclosed_by", "reviewed_by", "reviewed_at", "created_at",
            "fair_value", "allowed_revenue",
        )


class FFPRegulatoryAssessmentSerializer(serializers.ModelSerializer):
    class Meta:
        model = FFPRegulatoryAssessment
        fields = "__all__"


class FFPRegulatorySubmissionSerializer(serializers.ModelSerializer):
    assessment_status = serializers.CharField(source="assessment.status", read_only=True)
    class Meta:
        model = FFPRegulatorySubmission
        fields = "__all__"
        read_only_fields = (
            "club", "federation", "status", "attested_by", "attested_at", "submitted_at",
            "payload_checksum", "created_at", "updated_at",
        )


class FFPRegulatoryCaseEventSerializer(serializers.ModelSerializer):
    class Meta:
        model = FFPRegulatoryCaseEvent
        fields = "__all__"


class FFPFederationReviewCaseSerializer(serializers.ModelSerializer):
    events = FFPRegulatoryCaseEventSerializer(many=True, read_only=True)
    club_id = serializers.UUIDField(source="submission.club_id", read_only=True)
    assessment_status = serializers.CharField(source="submission.assessment.status", read_only=True)
    class Meta:
        model = FFPFederationReviewCase
        fields = "__all__"
        read_only_fields = ("submission", "federation", "status", "assigned_to", "opened_at", "decided_at", "closed_at", "updated_at")

# ---------------------------------------------------------------------------
# Native GL regulatory dimensions / accounting treatment serializers
# ---------------------------------------------------------------------------
from .models import (
    GLRegulatoryTreatmentPolicy,
    GLRegulatoryTreatmentRule,
    JournalLineRegulatoryClassification,
)


class GLRegulatoryTreatmentRuleSerializer(serializers.ModelSerializer):
    class Meta:
        model = GLRegulatoryTreatmentRule
        fields = (
            "id", "policy", "ordinal", "priority", "account_codes", "account_types",
            "source_types", "metadata_match", "classification", "dimensions",
            "exclusion_type", "require_review", "notes", "created_at",
        )
        read_only_fields = ("policy", "created_at")


class GLRegulatoryTreatmentPolicySerializer(serializers.ModelSerializer):
    treatment_rules = GLRegulatoryTreatmentRuleSerializer(many=True, read_only=True)

    class Meta:
        model = GLRegulatoryTreatmentPolicy
        fields = (
            "id", "federation", "name", "version", "status", "effective_from", "effective_to",
            "default_revenue_classification", "default_expense_classification",
            "default_balance_sheet_classification", "require_full_classification", "rules", "notes",
            "policy_hash", "published_at", "published_by", "created_at", "updated_at", "treatment_rules",
        )
        read_only_fields = (
            "federation", "status", "policy_hash", "published_at", "published_by",
            "created_at", "updated_at",
        )


class JournalLineRegulatoryClassificationSerializer(serializers.ModelSerializer):
    account_code = serializers.CharField(source="journal_line.account.code", read_only=True)
    account_type = serializers.CharField(source="journal_line.account.account_type", read_only=True)
    line_no = serializers.IntegerField(source="journal_line.line_no", read_only=True)
    debit = serializers.DecimalField(source="journal_line.debit", max_digits=24, decimal_places=8, read_only=True)
    credit = serializers.DecimalField(source="journal_line.credit", max_digits=24, decimal_places=8, read_only=True)
    policy_hash = serializers.CharField(source="policy.policy_hash", read_only=True, allow_null=True)

    class Meta:
        model = JournalLineRegulatoryClassification
        fields = (
            "id", "journal_line", "entry", "club", "period", "federation", "policy", "policy_hash",
            "policy_rule", "line_no", "account_code", "account_type", "debit", "credit",
            "classification", "dimensions", "exclusion_type", "automated", "requires_review",
            "source_context", "rulebook_governance", "classification_hash", "created_at",
        )
        read_only_fields = fields
