import hashlib
import json
from decimal import Decimal, ROUND_HALF_UP

from django.core.exceptions import ObjectDoesNotExist
from django.core.serializers.json import DjangoJSONEncoder
from django.db import transaction
from django.db.models import Q, Sum
from django.utils import timezone

from leagues.constants import LeagueCompetitionType, LeagueMembershipStatus
from .accounting import GeneralLedgerService
from .constants import GLAccountType, GLCode, JournalStatus
from .exceptions import FFPPolicyError, BudgetIntegrityError
from .models import (
    AccountingPeriod, JournalLine,
    FFPRegulatoryPolicy, FFPRegulatoryAdjustment, FFPRelatedPartyReview,
    FFPRegulatoryAssessment, FFPRegulatorySubmission,
    FFPFederationReviewCase, FFPRegulatoryCaseEvent,
)
from .regulatory_constants import (
    RegulatoryAdjustmentType, RegulatoryEvidenceStatus, RelatedPartyReviewStatus,
    RegulatoryAssessmentStatus, RegulatorySubmissionStatus, FederationReviewStatus,
)

Q8 = Decimal("0.00000001")
ZERO = Decimal("0")


def q8(value):
    return Decimal(value or 0).quantize(Q8, rounding=ROUND_HALF_UP)


def stable_hash(payload):
    raw = json.dumps(payload, cls=DjangoJSONEncoder, sort_keys=True, separators=(",", ":")).encode()
    return hashlib.sha256(raw).hexdigest()


def _emit(*, event_type, aggregate_type, aggregate_id, club_id, federation_id=None, payload=None):
    from core_runtime.services import OutboxService
    body = dict(payload or {})
    body["club_id"] = str(club_id)
    if federation_id:
        body["federation_id"] = str(federation_id)
    OutboxService.enqueue(
        topic="club_finance.ffp_regulatory",
        event_type=event_type,
        aggregate_type=aggregate_type,
        aggregate_id=aggregate_id,
        deduplication_key=f"{event_type}:{aggregate_id}",
        payload=body,
    )


class RegulatoryFederationResolver:
    @staticmethod
    def for_club_period(club, period):
        if period.season_id is None:
            raise FFPPolicyError("Regulatory FFP requires an accounting period linked to a season")
        membership = (
            club.league_memberships.select_related("league__federation_authority__federation")
            .filter(
                season_id=period.season_id,
                competition_type=LeagueCompetitionType.ADULT,
                status=LeagueMembershipStatus.REGISTERED,
            )
            .order_by("-registered_at")
            .first()
        )
        if membership is None:
            raise FFPPolicyError("Club has no adult league membership for the accounting period season")
        try:
            return membership.league.federation_authority.federation
        except ObjectDoesNotExist as exc:
            raise FFPPolicyError("League has no federation authority") from exc


class RegulatoryPolicyService:
    @staticmethod
    def active(*, federation, at):
        from federation_rulebook.constants import RulebookPolicyDomain
        from federation_rulebook.services import RulebookResolutionService
        governed = RulebookResolutionService.resolve_source_object(
            federation=federation, domain=RulebookPolicyDomain.FFP_REGULATORY, at=at, required=False
        )
        if governed is not None:
            return governed
        policy = (
            FFPRegulatoryPolicy.objects.filter(
                federation=federation, is_active=True, effective_from__lte=at,
            )
            .filter(Q(effective_to__isnull=True) | Q(effective_to__gt=at))
            .order_by("-effective_from", "-version")
            .first()
        )
        if policy is None:
            raise FFPPolicyError("No active regulatory FFP policy for federation")
        return policy


class RegulatoryEvidenceService:
    DEFAULT_EXCLUSIONS = {
        RegulatoryAdjustmentType.YOUTH_DEVELOPMENT,
        RegulatoryAdjustmentType.INFRASTRUCTURE,
        RegulatoryAdjustmentType.COMMUNITY,
        RegulatoryAdjustmentType.WOMENS_FOOTBALL,
    }

    @classmethod
    @transaction.atomic
    def create_adjustment(cls, *, club, period, user, adjustment_type, amount, source_type="", source_id="", explanation="", evidence=None):
        if period.club_id != club.pk:
            raise BudgetIntegrityError("Accounting period does not belong to club")
        if adjustment_type not in RegulatoryAdjustmentType.values:
            raise BudgetIntegrityError("Invalid regulatory adjustment type")
        amount = q8(amount)
        if amount <= 0:
            raise BudgetIntegrityError("Adjustment amount must be positive")
        return FFPRegulatoryAdjustment.objects.create(
            club=club, period=period, adjustment_type=adjustment_type, amount=amount,
            source_type=str(source_type or ""), source_id=str(source_id or ""),
            explanation=explanation or "", evidence=evidence or {}, requested_by=user,
        )

    @staticmethod
    @transaction.atomic
    def submit_adjustment(*, adjustment, user):
        adjustment = FFPRegulatoryAdjustment.objects.select_for_update().get(pk=adjustment.pk)
        if adjustment.status != RegulatoryEvidenceStatus.DRAFT:
            raise BudgetIntegrityError("Only draft adjustment can be submitted")
        if adjustment.requested_by_id != user.pk:
            raise BudgetIntegrityError("Only adjustment requester can submit")
        adjustment.status = RegulatoryEvidenceStatus.SUBMITTED
        adjustment.submitted_at = timezone.now()
        adjustment.save(update_fields=["status", "submitted_at"])
        federation = RegulatoryFederationResolver.for_club_period(adjustment.club, adjustment.period)
        _emit(
            event_type="ffp.regulatory.adjustment.submitted", aggregate_type="FFPRegulatoryAdjustment", aggregate_id=adjustment.pk,
            club_id=adjustment.club_id, federation_id=federation.pk,
            payload={"adjustment_id": str(adjustment.pk), "status": adjustment.status,
                     "message": "A club submitted an FFP permitted-exclusion adjustment for federation review."},
        )
        from regulatory_evidence.services import RegulatoryEvidenceBridgeService
        RegulatoryEvidenceBridgeService.capture_ffp_period_item(
            club=adjustment.club, period=adjustment.period, federation=federation, actor=user,
            external_key=f"adjustment:{adjustment.pk}", title="FFP permitted-exclusion adjustment", document_type="FFP_ADJUSTMENT",
            payload={
                "adjustment_id": str(adjustment.pk), "type": adjustment.adjustment_type, "amount": str(adjustment.amount),
                "source_type": adjustment.source_type, "source_id": adjustment.source_id,
                "explanation": adjustment.explanation, "evidence": adjustment.evidence, "status": adjustment.status,
            },
        )
        return adjustment

    @classmethod
    @transaction.atomic
    def decide_adjustment(cls, *, adjustment, reviewer, approve, policy=None):
        adjustment = FFPRegulatoryAdjustment.objects.select_for_update().select_related("club", "period").get(pk=adjustment.pk)
        if adjustment.status != RegulatoryEvidenceStatus.SUBMITTED:
            raise BudgetIntegrityError("Adjustment is not awaiting federation review")
        federation = RegulatoryFederationResolver.for_club_period(adjustment.club, adjustment.period)
        policy = policy or RegulatoryPolicyService.active(federation=federation, at=adjustment.period.ends_at)
        permitted = set(policy.permitted_exclusion_types or cls.DEFAULT_EXCLUSIONS)
        if approve and adjustment.adjustment_type not in permitted:
            raise BudgetIntegrityError("Adjustment type is not permitted by active regulatory policy")
        adjustment.status = RegulatoryEvidenceStatus.APPROVED if approve else RegulatoryEvidenceStatus.REJECTED
        adjustment.reviewed_by = reviewer
        adjustment.reviewed_at = timezone.now()
        adjustment.save(update_fields=["status", "reviewed_by", "reviewed_at"])
        _emit(
            event_type="ffp.regulatory.adjustment.decided", aggregate_type="FFPRegulatoryAdjustment", aggregate_id=adjustment.pk,
            club_id=adjustment.club_id, federation_id=federation.pk,
            payload={"adjustment_id": str(adjustment.pk), "status": adjustment.status,
                     "message": f"Federation {adjustment.status.lower()} an FFP regulatory adjustment."},
        )
        return adjustment

    @staticmethod
    def sponsorship_revenue(*, agreement, period):
        qs = JournalLine.objects.filter(
            entry__club=agreement.club,
            entry__period=period,
            entry__status__in=[JournalStatus.POSTED, JournalStatus.REVERSED],
            account__code=GLCode.SPONSORSHIP_REVENUE,
            entry__economy_ledger__reference_type="SPONSORSHIP_AGREEMENT",
            entry__economy_ledger__reference_id=str(agreement.pk),
        )
        agg = qs.aggregate(debit=Sum("debit"), credit=Sum("credit"))
        return max(ZERO, q8((agg["credit"] or ZERO) - (agg["debit"] or ZERO)))

    @classmethod
    @transaction.atomic
    def disclose_related_party(cls, *, club, period, agreement, user, relationship_summary="", evidence=None):
        if period.club_id != club.pk or agreement.club_id != club.pk:
            raise BudgetIntegrityError("Related-party evidence belongs to another club")
        reported = cls.sponsorship_revenue(agreement=agreement, period=period)
        obj, created = FFPRelatedPartyReview.objects.get_or_create(
            agreement=agreement, period=period,
            defaults={
                "club": club, "reported_revenue": reported, "relationship_summary": relationship_summary or "",
                "evidence": evidence or {}, "disclosed_by": user,
            },
        )
        if not created and obj.status == RelatedPartyReviewStatus.DISCLOSED:
            obj.reported_revenue = reported
            obj.relationship_summary = relationship_summary or obj.relationship_summary
            obj.evidence = evidence or obj.evidence
            obj.save(update_fields=["reported_revenue", "relationship_summary", "evidence"])
        federation = RegulatoryFederationResolver.for_club_period(club, period)
        _emit(
            event_type="ffp.regulatory.related_party.disclosed", aggregate_type="FFPRelatedPartyReview", aggregate_id=obj.pk,
            club_id=club.pk, federation_id=federation.pk,
            payload={"review_id": str(obj.pk), "status": obj.status,
                     "message": "A related-party sponsorship was disclosed for federation fair-value review."},
        )
        from regulatory_evidence.services import RegulatoryEvidenceBridgeService
        RegulatoryEvidenceBridgeService.capture_ffp_period_item(
            club=club, period=period, federation=federation, actor=user,
            external_key=f"related-party:{obj.pk}", title="Related-party sponsorship disclosure", document_type="RELATED_PARTY_DISCLOSURE",
            payload={
                "review_id": str(obj.pk), "agreement_id": str(obj.agreement_id), "reported_revenue": str(obj.reported_revenue),
                "relationship_summary": obj.relationship_summary, "evidence": obj.evidence, "status": obj.status,
            }, audience="SHARED",
        )
        return obj

    @classmethod
    @transaction.atomic
    def decide_related_party(cls, *, review, reviewer, approve, fair_value=None, allowed_revenue=None):
        review = FFPRelatedPartyReview.objects.select_for_update().get(pk=review.pk)
        if review.status not in [RelatedPartyReviewStatus.DISCLOSED, RelatedPartyReviewStatus.UNDER_REVIEW]:
            raise BudgetIntegrityError("Related-party review is already decided")
        if not approve:
            review.status = RelatedPartyReviewStatus.REJECTED
            review.reviewed_by = reviewer
            review.reviewed_at = timezone.now()
            review.save(update_fields=["status", "reviewed_by", "reviewed_at"])
            federation = RegulatoryFederationResolver.for_club_period(review.club, review.period)
            _emit(
                event_type="ffp.regulatory.related_party.decided", aggregate_type="FFPRelatedPartyReview", aggregate_id=review.pk,
                club_id=review.club_id, federation_id=federation.pk,
                payload={"review_id": str(review.pk), "status": review.status,
                         "message": "Federation rejected a related-party fair-value review."},
            )
            return review
        fair = q8(fair_value)
        if fair < 0:
            raise BudgetIntegrityError("Fair value cannot be negative")
        allowed = q8(allowed_revenue if allowed_revenue is not None else min(review.reported_revenue, fair))
        if allowed < 0 or allowed > review.reported_revenue or allowed > fair:
            raise BudgetIntegrityError("Allowed related-party revenue cannot exceed reported revenue or fair value")
        review.fair_value = fair
        review.allowed_revenue = allowed
        review.status = RelatedPartyReviewStatus.APPROVED
        review.reviewed_by = reviewer
        review.reviewed_at = timezone.now()
        review.save(update_fields=["fair_value", "allowed_revenue", "status", "reviewed_by", "reviewed_at"])
        federation = RegulatoryFederationResolver.for_club_period(review.club, review.period)
        _emit(
            event_type="ffp.regulatory.related_party.decided", aggregate_type="FFPRelatedPartyReview", aggregate_id=review.pk,
            club_id=review.club_id, federation_id=federation.pk,
            payload={"review_id": str(review.pk), "status": review.status, "fair_value": str(review.fair_value),
                     "allowed_revenue": str(review.allowed_revenue),
                     "message": "Federation approved a related-party sponsorship fair-value treatment."},
        )
        return review


class RegulatoryCalculationService:
    DEFAULT_SQUAD_COST_CODES = [
        GLCode.PLAYER_WAGES, GLCode.STAFF_WAGES, GLCode.PAYROLL_BONUS,
        GLCode.SIGNING_BONUS, GLCode.TERMINATION_COMPENSATION,
        GLCode.PLAYER_LOAN_EXPENSE, GLCode.PLAYER_AMORTIZATION_EXPENSE,
    ]
    DEFAULT_WAGE_CODES = [
        GLCode.PLAYER_WAGES, GLCode.STAFF_WAGES, GLCode.PAYROLL_BONUS,
        GLCode.SIGNING_BONUS, GLCode.TERMINATION_COMPENSATION,
    ]

    @staticmethod
    def _net_activity(period, *, account_type=None, codes=None):
        qs = JournalLine.objects.filter(entry__period=period, entry__status=JournalStatus.POSTED)
        if account_type:
            qs = qs.filter(account__account_type=account_type)
        if codes:
            qs = qs.filter(account__code__in=codes)
        agg = qs.aggregate(debit=Sum("debit"), credit=Sum("credit"))
        debit = q8(agg["debit"] or ZERO)
        credit = q8(agg["credit"] or ZERO)
        if account_type == GLAccountType.REVENUE:
            return max(ZERO, q8(credit - debit))
        if account_type == GLAccountType.EXPENSE:
            return max(ZERO, q8(debit - credit))
        return q8(credit - debit)

    @staticmethod
    def _rolling_periods(*, club, target_period, count):
        qs = AccountingPeriod.objects.filter(
            club=club, season__isnull=False, ends_at__lte=target_period.ends_at
        ).select_related("season").order_by("-ends_at", "-starts_at")
        selected = []
        seen_seasons = set()
        for period in qs:
            if period.season_id in seen_seasons:
                continue
            selected.append(period)
            seen_seasons.add(period.season_id)
            if len(selected) >= count:
                break
        return list(reversed(selected))

    @classmethod
    def _period_result(cls, *, club, period, policy):
        if not period.is_closed:
            GeneralLedgerService.sync(club=club, period=period, through_date=min(timezone.localdate(), period.ends_at.date()))

        # Native regulatory treatment is now projected directly from every posted
        # GL line. Historical entries are backfilled deterministically on demand.
        from .regulatory_dimensions import GLRegulatoryClassificationService
        native = GLRegulatoryClassificationService.period_summary(period)

        manual_adjustments = FFPRegulatoryAdjustment.objects.filter(
            club=club, period=period, status=RegulatoryEvidenceStatus.APPROVED,
            adjustment_type__in=(policy.permitted_exclusion_types or list(RegulatoryEvidenceService.DEFAULT_EXCLUSIONS)),
        )
        native_excluded_line_ids = set(native.get("excluded_line_ids") or [])
        manual_exclusions = ZERO
        skipped_duplicate_adjustments = []
        for adjustment in manual_adjustments:
            source_type = str(adjustment.source_type or "").upper()
            if source_type in {"JOURNAL_LINE", "GL_JOURNAL_LINE"} and str(adjustment.source_id) in native_excluded_line_ids:
                skipped_duplicate_adjustments.append(str(adjustment.pk))
                continue
            manual_exclusions += adjustment.amount
        manual_exclusions = q8(manual_exclusions)

        reported_revenue = q8(native["reported_revenue"])
        base_expense = q8(native["base_expense"])
        relevant_revenue = q8(native["relevant_revenue"])
        permitted_exclusion_types = set(
            policy.permitted_exclusion_types or list(RegulatoryEvidenceService.DEFAULT_EXCLUSIONS)
        )
        native_by_type = native.get("native_exclusions_by_type") or {}
        native_exclusions = q8(sum(
            (q8(amount) for exclusion_type, amount in native_by_type.items() if exclusion_type in permitted_exclusion_types),
            ZERO,
        ))
        disallowed_native_exclusions = q8(sum(
            (q8(amount) for exclusion_type, amount in native_by_type.items() if exclusion_type not in permitted_exclusion_types),
            ZERO,
        ))
        disallowed_native_exclusion_line_ids = [
            line_id
            for exclusion_type, line_ids in (native.get("excluded_line_ids_by_type") or {}).items()
            if exclusion_type not in permitted_exclusion_types
            for line_id in line_ids
        ]
        regulatory_expense = max(
            ZERO,
            q8(native["relevant_expense"] + disallowed_native_exclusions - manual_exclusions),
        )
        total_exclusions = q8(native_exclusions + manual_exclusions)

        related_reduction = ZERO
        unresolved = []
        if policy.require_related_party_fair_value:
            from club_commercial.models import SponsorshipAgreement
            related = SponsorshipAgreement.objects.filter(
                club=club, starts_at__lt=period.ends_at, ends_at__gt=period.starts_at,
            )
            for agreement in related:
                review = FFPRelatedPartyReview.objects.filter(agreement=agreement, period=period).first()
                explicitly_related = bool((agreement.metadata or {}).get("related_party")) or review is not None
                if not explicitly_related:
                    continue
                reported = RegulatoryEvidenceService.sponsorship_revenue(agreement=agreement, period=period)
                if reported <= 0:
                    continue
                if review is None or review.status != RelatedPartyReviewStatus.APPROVED or review.allowed_revenue is None:
                    unresolved.append(str(agreement.pk))
                    continue
                related_reduction += max(ZERO, q8(reported - review.allowed_revenue))

        adjusted_revenue = max(ZERO, q8(relevant_revenue - related_reduction))
        result = q8(adjusted_revenue - regulatory_expense)
        return {
            "period": period,
            "revenue": adjusted_revenue,
            "reported_revenue": reported_revenue,
            "expense": base_expense,
            "regulatory_expense": regulatory_expense,
            "exclusions": total_exclusions,
            "native_exclusions": native_exclusions,
            "manual_exclusions": manual_exclusions,
            "disallowed_native_exclusions": disallowed_native_exclusions,
            "disallowed_native_exclusion_line_ids": disallowed_native_exclusion_line_ids,
            "related_reduction": q8(related_reduction),
            "result": result,
            "wage": q8(native["wage_cost"]),
            "squad": q8(native["squad_cost"]),
            "owner_contribution": q8(native["owner_contribution"]),
            "unresolved_related_party": unresolved,
            "native_review_line_ids": native.get("review_line_ids") or [],
            "classification_coverage_complete": bool(native.get("coverage_complete")),
            "classified_lines": int(native.get("classified_lines") or 0),
            "expected_lines": int(native.get("expected_lines") or 0),
            "treatment_policy_hashes": native.get("policy_hashes") or [],
            "classification_federation_ids": native.get("classification_federation_ids") or [],
            "classification_federation_mismatch": any(
                value != str(policy.federation_id) for value in (native.get("classification_federation_ids") or [])
            ),
            "treatment_rulebook_resolution_hashes": native.get("rulebook_resolution_hashes") or [],
            "skipped_duplicate_adjustments": skipped_duplicate_adjustments,
        }

    @classmethod
    @transaction.atomic
    def assess(cls, *, club, target_period, policy=None):
        if target_period.club_id != club.pk:
            raise BudgetIntegrityError("Target accounting period belongs to another club")
        federation = RegulatoryFederationResolver.for_club_period(club, target_period)
        policy = policy or RegulatoryPolicyService.active(federation=federation, at=target_period.ends_at)
        if policy.federation_id != federation.pk:
            raise FFPPolicyError("Regulatory policy does not govern this club")
        periods = cls._rolling_periods(club=club, target_period=target_period, count=policy.rolling_seasons)
        if not periods or periods[-1].pk != target_period.pk:
            raise FFPPolicyError("Target period must be the latest season-linked accounting period")
        rows = [cls._period_result(club=club, period=p, policy=policy) for p in periods]
        current = rows[-1]
        rolling_result = q8(sum((x["result"] for x in rows), ZERO))

        owner_capital = max(ZERO, q8(sum((x["owner_contribution"] for x in rows), ZERO)))
        owner_allowance = min(q8(owner_capital), q8(policy.owner_contribution_cap))
        acceptable = q8(policy.max_aggregate_loss + owner_allowance)

        revenue = current["revenue"]
        squad_ratio = (current["squad"] / revenue) if revenue > 0 else None
        wage_ratio = (current["wage"] / revenue) if revenue > 0 else None
        reasons = []
        breach = False
        review_required = False
        warning = False

        unresolved = [x for row in rows for x in row["unresolved_related_party"]]
        native_review_lines = [x for row in rows for x in row["native_review_line_ids"]]
        disallowed_native_exclusion_lines = [x for row in rows for x in row["disallowed_native_exclusion_line_ids"]]
        incomplete_coverage = [str(row["period"].pk) for row in rows if not row["classification_coverage_complete"]]
        federation_mismatch_periods = [str(row["period"].pk) for row in rows if row["classification_federation_mismatch"]]
        if unresolved:
            review_required = True
            reasons.append("RELATED_PARTY_FAIR_VALUE_REVIEW_REQUIRED")
        if native_review_lines:
            review_required = True
            reasons.append("NATIVE_GL_CLASSIFICATION_REVIEW_REQUIRED")
        if disallowed_native_exclusion_lines:
            review_required = True
            reasons.append("NATIVE_GL_EXCLUSION_NOT_PERMITTED_BY_FFP_POLICY")
        if incomplete_coverage:
            review_required = True
            reasons.append("NATIVE_GL_CLASSIFICATION_INCOMPLETE")
        if federation_mismatch_periods:
            review_required = True
            reasons.append("NATIVE_GL_CLASSIFICATION_FEDERATION_MISMATCH")
        if policy.require_full_window and len(periods) < policy.rolling_seasons:
            review_required = True
            reasons.append("ROLLING_WINDOW_INCOMPLETE")
        if rolling_result < -acceptable:
            breach = True
            reasons.append("ROLLING_ACCEPTABLE_LOSS_EXCEEDED")
        if squad_ratio is not None and squad_ratio > policy.max_squad_cost_ratio:
            breach = True
            reasons.append("SQUAD_COST_RATIO_EXCEEDED")
        if wage_ratio is not None and wage_ratio > policy.max_wage_to_revenue_ratio:
            breach = True
            reasons.append("WAGE_TO_REVENUE_EXCEEDED")
        if revenue <= 0 and (current["squad"] > 0 or current["wage"] > 0):
            review_required = True
            reasons.append("NO_RELEVANT_REVENUE")

        buffer = Decimal("1") - (policy.warning_buffer_pct / Decimal("100"))
        if not breach:
            if rolling_result < -(acceptable * buffer):
                warning = True; reasons.append("ROLLING_LOSS_NEAR_LIMIT")
            if squad_ratio is not None and squad_ratio > policy.max_squad_cost_ratio * buffer:
                warning = True; reasons.append("SQUAD_COST_RATIO_NEAR_LIMIT")
            if wage_ratio is not None and wage_ratio > policy.max_wage_to_revenue_ratio * buffer:
                warning = True; reasons.append("WAGE_RATIO_NEAR_LIMIT")

        status = (
            RegulatoryAssessmentStatus.BREACH if breach else
            RegulatoryAssessmentStatus.REVIEW_REQUIRED if review_required else
            RegulatoryAssessmentStatus.WARNING if warning else
            RegulatoryAssessmentStatus.COMPLIANT
        )
        from federation_rulebook.constants import RulebookPolicyDomain
        from federation_rulebook.services import RulebookResolutionService, resolution_provenance
        rulebook_resolution = RulebookResolutionService.resolve(
            federation=federation,
            domain=RulebookPolicyDomain.FFP_REGULATORY,
            at=target_period.ends_at,
            season=target_period.season,
            required=False,
        )
        rulebook_governance = None
        if rulebook_resolution and rulebook_resolution["binding"].source_object_id == str(policy.pk):
            rulebook_governance = resolution_provenance(rulebook_resolution)

        evidence = {
            "rolling_seasons_required": policy.rolling_seasons,
            "rolling_seasons_present": len(periods),
            "periods": [
                {
                    "period_id": str(x["period"].pk), "season_id": str(x["period"].season_id),
                    "revenue": str(x["revenue"]), "reported_revenue": str(x["reported_revenue"]),
                    "expense": str(x["expense"]), "regulatory_expense": str(x["regulatory_expense"]),
                    "approved_exclusions": str(x["exclusions"]),
                    "native_gl_exclusions": str(x["native_exclusions"]),
                    "manual_approved_exclusions": str(x["manual_exclusions"]),
                    "disallowed_native_exclusions": str(x["disallowed_native_exclusions"]),
                    "disallowed_native_exclusion_line_ids": x["disallowed_native_exclusion_line_ids"],
                    "related_party_revenue_reduction": str(x["related_reduction"]), "result": str(x["result"]),
                    "wage_cost": str(x["wage"]), "squad_cost": str(x["squad"]),
                    "owner_contribution": str(x["owner_contribution"]),
                    "unresolved_related_party": x["unresolved_related_party"],
                    "native_review_line_ids": x["native_review_line_ids"],
                    "classification_coverage_complete": x["classification_coverage_complete"],
                    "classified_lines": x["classified_lines"], "expected_lines": x["expected_lines"],
                    "treatment_policy_hashes": x["treatment_policy_hashes"],
                    "classification_federation_ids": x["classification_federation_ids"],
                    "classification_federation_mismatch": x["classification_federation_mismatch"],
                    "treatment_rulebook_resolution_hashes": x["treatment_rulebook_resolution_hashes"],
                    "skipped_duplicate_adjustments": x["skipped_duplicate_adjustments"],
                } for x in rows
            ],
            "owner_capital_detected": str(q8(owner_capital)),
            "owner_contribution_cap": str(q8(policy.owner_contribution_cap)),
            "policy_version": policy.version,
            "rulebook_governance": rulebook_governance,
        }
        checksum_payload = {
            "club": str(club.pk), "period": str(target_period.pk), "federation": str(federation.pk),
            "policy": str(policy.pk), "status": status, "rolling_result": str(rolling_result),
            "acceptable": str(acceptable), "evidence": evidence, "reasons": reasons,
        }
        assessment = FFPRegulatoryAssessment.objects.create(
            club=club, target_period=target_period, federation=federation, policy=policy, status=status,
            relevant_revenue=current["revenue"], base_expense=current["expense"],
            approved_exclusions=current["exclusions"], related_party_revenue_reduction=current["related_reduction"],
            owner_contribution_allowance=owner_allowance,
            regulatory_expense=current["regulatory_expense"],
            current_result=current["result"], rolling_result=rolling_result, acceptable_loss_limit=acceptable,
            squad_cost=current["squad"], wage_cost=current["wage"], squad_cost_ratio=squad_ratio,
            wage_to_revenue_ratio=wage_ratio, reasons=reasons, window_evidence=evidence,
            checksum=stable_hash(checksum_payload),
        )
        _emit(
            event_type="ffp.regulatory.assessed", aggregate_type="FFPRegulatoryAssessment", aggregate_id=assessment.pk,
            club_id=club.pk, federation_id=federation.pk,
            payload={"assessment_id": str(assessment.pk), "status": status, "reasons": reasons,
                     "period_id": str(target_period.pk), "message": "Regulatory FFP assessment completed."},
        )
        return assessment


class RegulatorySubmissionService:
    @classmethod
    @transaction.atomic
    def create_draft(cls, *, assessment):
        payload_checksum = stable_hash({
            "assessment_id": str(assessment.pk), "assessment_checksum": assessment.checksum,
            "club_id": str(assessment.club_id), "federation_id": str(assessment.federation_id),
        })
        obj, _ = FFPRegulatorySubmission.objects.get_or_create(
            assessment=assessment,
            defaults={
                "club": assessment.club, "federation": assessment.federation,
                "payload_checksum": payload_checksum,
            },
        )
        return obj

    @classmethod
    @transaction.atomic
    def submit(cls, *, submission, user, attestation_text):
        submission = FFPRegulatorySubmission.objects.select_for_update().select_related("assessment").get(pk=submission.pk)
        if submission.status not in [RegulatorySubmissionStatus.DRAFT, RegulatorySubmissionStatus.INFO_REQUESTED]:
            raise BudgetIntegrityError("Submission is not open for attestation")
        text = (attestation_text or "").strip()
        if len(text) < 20:
            raise BudgetIntegrityError("Attestation text must explicitly confirm the regulatory submission")
        if submission.assessment.status == RegulatoryAssessmentStatus.REVIEW_REQUIRED:
            raise BudgetIntegrityError("Assessment contains unresolved regulatory evidence")
        submission.attestation_text = text
        submission.attested_by = user
        submission.attested_at = timezone.now()
        submission.submitted_at = timezone.now()
        submission.status = RegulatorySubmissionStatus.SUBMITTED
        submission.save(update_fields=["attestation_text", "attested_by", "attested_at", "submitted_at", "status", "updated_at"])
        case, created = FFPFederationReviewCase.objects.get_or_create(
            submission=submission, defaults={"federation": submission.federation}
        )
        if created:
            FFPRegulatoryCaseEvent.objects.create(case=case, event_type="SUBMISSION_RECEIVED", actor=user, payload={})
        _emit(
            event_type="ffp.regulatory.submission.submitted", aggregate_type="FFPRegulatorySubmission", aggregate_id=submission.pk,
            club_id=submission.club_id, federation_id=submission.federation_id,
            payload={"submission_id": str(submission.pk), "status": submission.status,
                     "message": "Club submitted its regulatory FFP attestation for federation review."},
        )
        from regulatory_evidence.services import RegulatoryEvidenceBridgeService
        RegulatoryEvidenceBridgeService.capture_ffp_submission(submission=submission, actor=user)
        return submission

    @classmethod
    @transaction.atomic
    def review(cls, *, case, reviewer, action, findings=None, sanctions=None):
        case = FFPFederationReviewCase.objects.select_for_update().select_related("submission", "submission__assessment").get(pk=case.pk)
        submission = FFPRegulatorySubmission.objects.select_for_update().get(pk=case.submission_id)
        action = str(action or "").upper()
        now = timezone.now()
        event_type = None
        if action == "START_REVIEW":
            case.status = FederationReviewStatus.UNDER_REVIEW
            submission.status = RegulatorySubmissionStatus.UNDER_REVIEW
            case.assigned_to = reviewer
            event_type = "REVIEW_STARTED"
        elif action == "REQUEST_INFO":
            case.status = FederationReviewStatus.INFO_REQUESTED
            submission.status = RegulatorySubmissionStatus.INFO_REQUESTED
            case.assigned_to = reviewer
            event_type = "INFO_REQUESTED"
        elif action == "CLEAR":
            case.status = FederationReviewStatus.CLEARED
            submission.status = RegulatorySubmissionStatus.ACCEPTED
            case.assigned_to = reviewer
            case.decided_at = now
            event_type = "CLEARED"
        elif action == "CONFIRM_BREACH":
            case.status = FederationReviewStatus.BREACH_CONFIRMED
            submission.status = RegulatorySubmissionStatus.BREACH
            case.assigned_to = reviewer
            case.decided_at = now
            event_type = "BREACH_CONFIRMED"
        elif action == "SANCTION":
            if submission.status != RegulatorySubmissionStatus.BREACH:
                raise BudgetIntegrityError("Sanction requires a confirmed breach")
            if not sanctions:
                raise BudgetIntegrityError("Sanction action requires sanction evidence")
            case.status = FederationReviewStatus.SANCTIONED
            case.assigned_to = reviewer
            case.decided_at = case.decided_at or now
            event_type = "SANCTIONED"
        elif action == "CLOSE":
            if case.status not in [FederationReviewStatus.CLEARED, FederationReviewStatus.SANCTIONED, FederationReviewStatus.BREACH_CONFIRMED]:
                raise BudgetIntegrityError("Only decided cases can be closed")
            case.status = FederationReviewStatus.CLOSED
            case.closed_at = now
            event_type = "CLOSED"
        else:
            raise BudgetIntegrityError("Unknown federation review action")
        if findings is not None:
            case.findings = findings
        if sanctions is not None:
            case.sanctions = sanctions
        case.save(update_fields=["status", "assigned_to", "findings", "sanctions", "decided_at", "closed_at", "updated_at"])
        submission.save(update_fields=["status", "updated_at"])
        FFPRegulatoryCaseEvent.objects.create(
            case=case, event_type=event_type, actor=reviewer,
            payload={"findings": findings or {}, "sanctions": sanctions or []},
        )
        outbox_type = {
            "INFO_REQUESTED": "ffp.regulatory.review.info_requested",
            "CLEARED": "ffp.regulatory.review.cleared",
            "BREACH_CONFIRMED": "ffp.regulatory.review.breach_confirmed",
            "SANCTIONED": "ffp.regulatory.review.sanctioned",
        }.get(event_type, "ffp.regulatory.review.updated")
        _emit(
            event_type=outbox_type, aggregate_type="FFPFederationReviewCase", aggregate_id=case.pk,
            club_id=submission.club_id, federation_id=submission.federation_id,
            payload={"case_id": str(case.pk), "submission_id": str(submission.pk), "status": case.status,
                     "message": f"Federation FFP review updated: {event_type.replace('_', ' ').title()}."},
        )
        if event_type == "SANCTIONED":
            from club_licensing.services import ClubSanctionService
            ClubSanctionService.from_ffp_case(case=case, reviewer=reviewer, sanctions=sanctions or [])
        return case
