from __future__ import annotations

import fnmatch
import hashlib
import json
from datetime import datetime, time
from decimal import Decimal, ROUND_HALF_UP

from django.core.serializers.json import DjangoJSONEncoder
from django.db import transaction
from django.db.models import Q
from django.utils import timezone

from .constants import GLAccountType, GLCode, JournalStatus
from .exceptions import BudgetIntegrityError, FFPPolicyError
from .models import (
    AccountingPeriod,
    GLRegulatoryTreatmentPolicy,
    GLRegulatoryTreatmentRule,
    JournalEntry,
    JournalLine,
    JournalLineRegulatoryClassification,
)
from .regulatory_constants import (
    GLRegulatoryClassificationType,
    GLRegulatoryDimension,
    GLRegulatoryPolicyStatus,
    RegulatoryAdjustmentType,
)

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 _aware_accounting_date(value):
    if isinstance(value, datetime):
        return value if timezone.is_aware(value) else timezone.make_aware(value)
    return timezone.make_aware(datetime.combine(value, time.min), timezone.get_current_timezone())


def _json_list(values):
    return sorted({str(value) for value in (values or []) if str(value)})


def _nested_value(payload, path):
    current = payload
    for part in str(path).split("."):
        if not isinstance(current, dict) or part not in current:
            return None
        current = current[part]
    return current


class GLRegulatoryTreatmentPolicyService:
    """Lifecycle and integrity service for the regulatory GL treatment matrix."""

    @staticmethod
    def _rule_payload(rule):
        return {
            "ordinal": rule.ordinal,
            "priority": rule.priority,
            "account_codes": _json_list(rule.account_codes),
            "account_types": _json_list(rule.account_types),
            "source_types": _json_list(rule.source_types),
            "metadata_match": rule.metadata_match or {},
            "classification": rule.classification,
            "dimensions": _json_list(rule.dimensions),
            "exclusion_type": rule.exclusion_type,
            "require_review": rule.require_review,
            "notes": rule.notes,
        }

    @classmethod
    def payload(cls, policy):
        return {
            "schema_version": 1,
            "policy_id": str(policy.pk),
            "federation_id": str(policy.federation_id),
            "name": policy.name,
            "version": policy.version,
            "effective_from": policy.effective_from.isoformat(),
            "effective_to": policy.effective_to.isoformat() if policy.effective_to else None,
            "defaults": {
                "revenue": policy.default_revenue_classification,
                "expense": policy.default_expense_classification,
                "balance_sheet": policy.default_balance_sheet_classification,
            },
            "require_full_classification": policy.require_full_classification,
            "rules_config": policy.rules or {},
            "treatment_rules": [
                cls._rule_payload(row)
                for row in policy.treatment_rules.order_by("ordinal", "id")
            ],
        }

    @staticmethod
    def validate_rule_values(*, classification, dimensions, exclusion_type="", account_types=None):
        if classification not in GLRegulatoryClassificationType.values:
            raise BudgetIntegrityError("Unknown GL regulatory classification")
        unknown = set(dimensions or []) - set(GLRegulatoryDimension.values)
        if unknown:
            raise BudgetIntegrityError(f"Unknown GL regulatory dimensions: {', '.join(sorted(unknown))}")
        if exclusion_type and exclusion_type not in RegulatoryAdjustmentType.values:
            raise BudgetIntegrityError("Unknown FFP exclusion type")
        if classification == GLRegulatoryClassificationType.EXCLUDED_EXPENSE and not exclusion_type:
            raise BudgetIntegrityError("Excluded-expense rules must declare an exclusion_type")
        if exclusion_type and classification != GLRegulatoryClassificationType.EXCLUDED_EXPENSE:
            raise BudgetIntegrityError("exclusion_type is only valid for EXCLUDED_EXPENSE rules")
        unknown_types = set(account_types or []) - set(GLAccountType.values)
        if unknown_types:
            raise BudgetIntegrityError(f"Unknown GL account types: {', '.join(sorted(unknown_types))}")

    @classmethod
    @transaction.atomic
    def add_rule(cls, *, policy, values):
        policy = GLRegulatoryTreatmentPolicy.objects.select_for_update().get(pk=policy.pk)
        if policy.status != GLRegulatoryPolicyStatus.DRAFT:
            raise BudgetIntegrityError("Only draft GL regulatory treatment policies can be edited")
        account_types = _json_list(values.get("account_types"))
        cls.validate_rule_values(
            classification=values.get("classification"),
            dimensions=values.get("dimensions") or [],
            exclusion_type=str(values.get("exclusion_type") or ""),
            account_types=account_types,
        )
        return GLRegulatoryTreatmentRule.objects.create(
            policy=policy,
            ordinal=int(values["ordinal"]),
            priority=int(values.get("priority", 0)),
            account_codes=_json_list(values.get("account_codes")),
            account_types=account_types,
            source_types=_json_list(values.get("source_types")),
            metadata_match=dict(values.get("metadata_match") or {}),
            classification=values["classification"],
            dimensions=_json_list(values.get("dimensions")),
            exclusion_type=str(values.get("exclusion_type") or ""),
            require_review=bool(values.get("require_review", False)),
            notes=str(values.get("notes") or "")[:255],
        )

    @classmethod
    @transaction.atomic
    def publish(cls, *, policy, actor):
        policy = GLRegulatoryTreatmentPolicy.objects.select_for_update().select_related("federation").get(pk=policy.pk)
        if policy.status != GLRegulatoryPolicyStatus.DRAFT:
            raise BudgetIntegrityError("Only draft GL regulatory treatment policies can be published")
        if policy.effective_to and policy.effective_to <= policy.effective_from:
            raise BudgetIntegrityError("Policy effective_to must be after effective_from")
        if policy.default_revenue_classification not in {
            GLRegulatoryClassificationType.RELEVANT_REVENUE,
            GLRegulatoryClassificationType.RELATED_PARTY_REVENUE,
            GLRegulatoryClassificationType.NON_RELEVANT,
            GLRegulatoryClassificationType.REVIEW_REQUIRED,
        }:
            raise BudgetIntegrityError("Invalid default revenue regulatory classification")
        if policy.default_expense_classification not in {
            GLRegulatoryClassificationType.RELEVANT_EXPENSE,
            GLRegulatoryClassificationType.NON_RELEVANT,
            GLRegulatoryClassificationType.REVIEW_REQUIRED,
        }:
            raise BudgetIntegrityError("Invalid default expense regulatory classification")
        if policy.default_balance_sheet_classification not in {
            GLRegulatoryClassificationType.NON_RELEVANT,
            GLRegulatoryClassificationType.OWNER_CONTRIBUTION,
            GLRegulatoryClassificationType.REVIEW_REQUIRED,
        }:
            raise BudgetIntegrityError("Invalid default balance-sheet regulatory classification")
        ordinals = list(policy.treatment_rules.order_by("ordinal").values_list("ordinal", flat=True))
        if len(ordinals) != len(set(ordinals)):
            raise BudgetIntegrityError("Treatment rule ordinals must be unique")
        for row in policy.treatment_rules.all():
            cls.validate_rule_values(
                classification=row.classification,
                dimensions=row.dimensions or [],
                exclusion_type=row.exclusion_type,
                account_types=row.account_types or [],
            )
        payload = cls.payload(policy)
        policy.policy_hash = stable_hash(payload)
        policy.status = GLRegulatoryPolicyStatus.PUBLISHED
        policy.published_at = timezone.now()
        policy.published_by = actor
        policy.save(update_fields=["policy_hash", "status", "published_at", "published_by", "updated_at"])
        from core_runtime.services import OutboxService
        OutboxService.enqueue(
            topic="club_finance.gl_regulatory_treatment",
            event_type="club_finance.gl_regulatory_treatment.policy_published",
            aggregate_type="GLRegulatoryTreatmentPolicy",
            aggregate_id=policy.pk,
            deduplication_key=f"gl-reg-treatment-policy-published:{policy.pk}:{policy.policy_hash}",
            payload={
                "policy_id": str(policy.pk),
                "federation_id": str(policy.federation_id),
                "version": policy.version,
                "policy_hash": policy.policy_hash,
                "effective_from": policy.effective_from.isoformat(),
                "effective_to": policy.effective_to.isoformat() if policy.effective_to else None,
            },
        )
        return policy

    @classmethod
    def verify_integrity(cls, policy):
        if policy.status != GLRegulatoryPolicyStatus.PUBLISHED:
            return {"valid": False, "reason": "POLICY_NOT_PUBLISHED"}
        expected = stable_hash(cls.payload(policy))
        return {
            "valid": expected == policy.policy_hash,
            "expected_hash": expected,
            "stored_hash": policy.policy_hash,
        }

    @classmethod
    def active(cls, *, federation, at, season=None):
        from federation_rulebook.constants import RulebookPolicyDomain
        from federation_rulebook.services import RulebookResolutionService

        resolved = RulebookResolutionService.resolve(
            federation=federation,
            domain=RulebookPolicyDomain.GL_ACCOUNTING_TREATMENT,
            at=at,
            season=season,
            required=False,
        )
        if resolved is not None:
            source = RulebookResolutionService.resolve_source_object(
                federation=federation,
                domain=RulebookPolicyDomain.GL_ACCOUNTING_TREATMENT,
                at=at,
                season=season,
                required=True,
            )
            if source.status != GLRegulatoryPolicyStatus.PUBLISHED:
                raise BudgetIntegrityError("Rulebook resolved an unpublished GL accounting treatment policy")
            integrity = cls.verify_integrity(source)
            if not integrity["valid"]:
                raise BudgetIntegrityError("Rulebook GL accounting treatment policy failed integrity verification")
            return source, resolved

        policy = (
            GLRegulatoryTreatmentPolicy.objects.filter(
                federation=federation,
                status=GLRegulatoryPolicyStatus.PUBLISHED,
                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:
            return None, None
        integrity = cls.verify_integrity(policy)
        if not integrity["valid"]:
            raise BudgetIntegrityError("Active GL accounting treatment policy failed integrity verification")
        return policy, None


class GLRegulatoryClassificationService:
    """Classify every posted GL line into immutable FFP dimensions and treatments."""

    DEFAULT_EXPENSE_DIMENSIONS = {
        GLCode.PLAYER_WAGES: [GLRegulatoryDimension.SQUAD_COST, GLRegulatoryDimension.WAGE_COST],
        GLCode.STAFF_WAGES: [GLRegulatoryDimension.SQUAD_COST, GLRegulatoryDimension.WAGE_COST],
        GLCode.PAYROLL_BONUS: [GLRegulatoryDimension.SQUAD_COST, GLRegulatoryDimension.WAGE_COST],
        GLCode.SIGNING_BONUS: [GLRegulatoryDimension.SQUAD_COST, GLRegulatoryDimension.WAGE_COST],
        GLCode.TERMINATION_COMPENSATION: [GLRegulatoryDimension.SQUAD_COST, GLRegulatoryDimension.WAGE_COST],
        GLCode.PLAYER_LOAN_EXPENSE: [GLRegulatoryDimension.SQUAD_COST],
        GLCode.PLAYER_AMORTIZATION_EXPENSE: [
            GLRegulatoryDimension.SQUAD_COST,
            GLRegulatoryDimension.PLAYER_AMORTIZATION,
        ],
        GLCode.DEBT_INTEREST: [GLRegulatoryDimension.DEBT_SERVICE],
        GLCode.DEBT_FEES: [GLRegulatoryDimension.DEBT_SERVICE],
        GLCode.FINES: [GLRegulatoryDimension.REGULATORY_FINE],
    }

    @staticmethod
    def _federation_for(entry):
        if not entry.period.season_id:
            return None
        from .regulatory import RegulatoryFederationResolver
        try:
            return RegulatoryFederationResolver.for_club_period(entry.club, entry.period)
        except FFPPolicyError:
            return None

    @staticmethod
    def _rule_matches(rule, *, line, entry):
        if rule.account_codes and line.account.code not in {str(x) for x in rule.account_codes}:
            return False
        if rule.account_types and line.account.account_type not in {str(x) for x in rule.account_types}:
            return False
        if rule.source_types:
            if not any(fnmatch.fnmatchcase(entry.source_type, str(pattern)) for pattern in rule.source_types):
                return False
        metadata = line.metadata or {}
        for key, expected in (rule.metadata_match or {}).items():
            if _nested_value(metadata, key) != expected:
                return False
        return True

    @staticmethod
    def _rule_specificity(rule):
        return (
            len(rule.account_codes or [])
            + len(rule.account_types or [])
            + len(rule.source_types or [])
            + len(rule.metadata_match or {})
        )

    @classmethod
    def _select_rule(cls, policy, *, line, entry):
        matches = [
            row for row in policy.treatment_rules.all()
            if cls._rule_matches(row, line=line, entry=entry)
        ]
        if not matches:
            return None
        matches.sort(
            key=lambda row: (row.priority, cls._rule_specificity(row), -row.ordinal, str(row.pk)),
            reverse=True,
        )
        return matches[0]

    @classmethod
    def _native_default(cls, *, line, policy=None):
        account_type = line.account.account_type
        if account_type == GLAccountType.REVENUE:
            classification = (
                policy.default_revenue_classification if policy
                else GLRegulatoryClassificationType.RELEVANT_REVENUE
            )
            dimensions = [GLRegulatoryDimension.OPERATING]
        elif account_type == GLAccountType.EXPENSE:
            classification = (
                policy.default_expense_classification if policy
                else GLRegulatoryClassificationType.RELEVANT_EXPENSE
            )
            dimensions = cls.DEFAULT_EXPENSE_DIMENSIONS.get(
                line.account.code, [GLRegulatoryDimension.OPERATING]
            )
        else:
            classification = (
                policy.default_balance_sheet_classification if policy
                else GLRegulatoryClassificationType.NON_RELEVANT
            )
            dimensions = []

        if line.account.code == GLCode.OWNER_CAPITAL:
            classification = GLRegulatoryClassificationType.OWNER_CONTRIBUTION
            dimensions = [GLRegulatoryDimension.OWNER_CONTRIBUTION]
        elif line.account.code in {GLCode.LOANS_PAYABLE}:
            dimensions = [GLRegulatoryDimension.FINANCING]
        elif line.account.code in {
            GLCode.PLAYER_REGISTRATION_ASSET,
            GLCode.CLUB_FACILITIES,
            GLCode.OTHER_NFT_ASSETS,
        }:
            dimensions = [GLRegulatoryDimension.CAPITAL_EXPENDITURE]

        metadata = line.metadata or {}
        extra_dimensions = metadata.get("regulatory_dimensions") or []
        if isinstance(extra_dimensions, str):
            extra_dimensions = [extra_dimensions]
        extra_dimensions = [x for x in extra_dimensions if x in GLRegulatoryDimension.values]
        dimensions = _json_list([*dimensions, *extra_dimensions])
        if metadata.get("related_party"):
            dimensions = _json_list([*dimensions, GLRegulatoryDimension.RELATED_PARTY])
            if account_type == GLAccountType.REVENUE:
                classification = GLRegulatoryClassificationType.RELATED_PARTY_REVENUE
        return classification, dimensions, "", False

    @classmethod
    def _derive(cls, *, line, entry, policy):
        if entry.source_type == 'MANUAL_ACCRUAL' and line.account.account_type == GLAccountType.REVENUE:
            return {'rule':None,'classification':GLRegulatoryClassificationType.REVIEW_REQUIRED,
                    'dimensions':[GLRegulatoryDimension.OPERATING],'exclusion_type':'','requires_review':True}
        rule = cls._select_rule(policy, line=line, entry=entry) if policy else None
        if rule is None:
            classification, dimensions, exclusion_type, require_review = cls._native_default(
                line=line, policy=policy
            )
            return {
                "rule": None,
                "classification": classification,
                "dimensions": dimensions,
                "exclusion_type": exclusion_type,
                "requires_review": require_review,
            }
        dimensions = _json_list(rule.dimensions)
        requires_review = bool(rule.require_review) or rule.classification == GLRegulatoryClassificationType.REVIEW_REQUIRED
        return {
            "rule": rule,
            "classification": rule.classification,
            "dimensions": dimensions,
            "exclusion_type": rule.exclusion_type,
            "requires_review": requires_review,
        }

    @classmethod
    def _classification_payload(cls, *, line, entry, federation, policy, result, provenance):
        return {
            "schema_version": 1,
            "journal_entry_id": str(entry.pk),
            "journal_checksum": entry.checksum,
            "journal_line_id": str(line.pk),
            "line_no": line.line_no,
            "club_id": str(entry.club_id),
            "period_id": str(entry.period_id),
            "federation_id": str(federation.pk) if federation else None,
            "account_code": line.account.code,
            "account_type": line.account.account_type,
            "debit": str(q8(line.debit)),
            "credit": str(q8(line.credit)),
            "source_type": entry.source_type,
            "source_id": entry.source_id,
            "metadata": line.metadata or {},
            "policy_id": str(policy.pk) if policy else None,
            "policy_hash": policy.policy_hash if policy else "NATIVE_DEFAULT_V1",
            "policy_rule_id": str(result["rule"].pk) if result["rule"] else None,
            "classification": result["classification"],
            "dimensions": result["dimensions"],
            "exclusion_type": result["exclusion_type"],
            "requires_review": result["requires_review"],
            "rulebook_governance": provenance or {},
        }

    @classmethod
    @transaction.atomic
    def classify_entry(cls, entry):
        entry = (
            JournalEntry.objects.select_for_update(of=("self", "club", "period"))
            .select_related("club", "period", "period__season")
            .get(pk=entry.pk)
        )
        if entry.status not in [JournalStatus.POSTED, JournalStatus.REVERSED]:
            return {"entry_id": str(entry.pk), "created": 0, "total": 0}
        lines = list(entry.lines.select_related("account").order_by("line_no"))
        federation = cls._federation_for(entry)
        policy = None
        resolved = None
        if federation is not None:
            policy, resolved = GLRegulatoryTreatmentPolicyService.active(
                federation=federation,
                at=_aware_accounting_date(entry.accounting_date),
                season=entry.period.season,
            )
        provenance = {}
        if resolved:
            from federation_rulebook.services import resolution_provenance
            provenance = resolution_provenance(resolved)

        created = 0
        for line in lines:
            existing = JournalLineRegulatoryClassification.objects.filter(journal_line=line).first()
            if existing:
                verification = cls.verify(existing)
                if not verification["valid"]:
                    raise BudgetIntegrityError("Existing GL regulatory classification failed integrity verification")
                continue
            row_federation = federation
            row_policy = policy
            row_provenance = provenance
            reversal_source = None
            reversal_line_id = (line.metadata or {}).get("reversal_of_line") if entry.source_type == "JOURNAL_REVERSAL" else None
            if reversal_line_id:
                reversal_source = (
                    JournalLineRegulatoryClassification.objects
                    .select_related("policy", "policy_rule", "federation")
                    .filter(journal_line_id=reversal_line_id)
                    .first()
                )
            if reversal_source is not None:
                row_federation = reversal_source.federation
                row_policy = reversal_source.policy
                row_provenance = dict(reversal_source.rulebook_governance or {})
                result = {
                    "rule": reversal_source.policy_rule,
                    "classification": reversal_source.classification,
                    "dimensions": _json_list(reversal_source.dimensions),
                    "exclusion_type": reversal_source.exclusion_type,
                    "requires_review": reversal_source.requires_review,
                }
            else:
                result = cls._derive(line=line, entry=entry, policy=policy)
            payload = cls._classification_payload(
                line=line,
                entry=entry,
                federation=row_federation,
                policy=row_policy,
                result=result,
                provenance=row_provenance,
            )
            JournalLineRegulatoryClassification.objects.create(
                journal_line=line,
                entry=entry,
                club=entry.club,
                period=entry.period,
                federation=row_federation,
                policy=row_policy,
                policy_rule=result["rule"],
                classification=result["classification"],
                dimensions=result["dimensions"],
                exclusion_type=result["exclusion_type"],
                automated=True,
                requires_review=result["requires_review"],
                source_context={
                    "account_code": line.account.code,
                    "account_type": line.account.account_type,
                    "source_type": entry.source_type,
                    "source_id": entry.source_id,
                    "metadata": line.metadata or {},
                    "policy_hash": row_policy.policy_hash if row_policy else "NATIVE_DEFAULT_V1",
                    "reversal_of_classification_hash": reversal_source.classification_hash if reversal_source else None,
                },
                rulebook_governance=row_provenance,
                classification_hash=stable_hash(payload),
            )
            created += 1
        return {"entry_id": str(entry.pk), "created": created, "total": len(lines)}

    @classmethod
    def verify(cls, classification):
        line = classification.journal_line
        entry = classification.entry
        result = {
            "rule": classification.policy_rule,
            "classification": classification.classification,
            "dimensions": _json_list(classification.dimensions),
            "exclusion_type": classification.exclusion_type,
            "requires_review": classification.requires_review,
        }
        payload = cls._classification_payload(
            line=line,
            entry=entry,
            federation=classification.federation,
            policy=classification.policy,
            result=result,
            provenance=classification.rulebook_governance,
        )
        expected = stable_hash(payload)
        return {
            "valid": expected == classification.classification_hash,
            "expected_hash": expected,
            "stored_hash": classification.classification_hash,
        }

    @classmethod
    def ensure_period(cls, period):
        entries = (
            JournalEntry.objects.filter(period=period, status__in=[JournalStatus.POSTED, JournalStatus.REVERSED])
            .order_by("accounting_date", "posted_at", "id")
        )
        created = 0
        total_entries = 0
        for entry in entries.iterator():
            result = cls.classify_entry(entry)
            created += result["created"]
            total_entries += 1
        return {"period_id": str(period.pk), "entries": total_entries, "classifications_created": created}

    @staticmethod
    def _activity(line):
        if line.account.account_type == GLAccountType.REVENUE:
            return q8(line.credit - line.debit)
        if line.account.account_type == GLAccountType.EXPENSE:
            return q8(line.debit - line.credit)
        if line.account.account_type == GLAccountType.EQUITY:
            return q8(line.credit - line.debit)
        return q8(line.debit - line.credit)

    @classmethod
    def period_summary(cls, period):
        cls.ensure_period(period)
        rows = (
            JournalLineRegulatoryClassification.objects.filter(
                period=period,
                entry__status__in=[JournalStatus.POSTED, JournalStatus.REVERSED],
            )
            .select_related("journal_line__account", "policy", "policy_rule", "entry")
            .order_by("entry__accounting_date", "entry_id", "journal_line__line_no")
        )
        totals = {
            "reported_revenue": ZERO,
            "base_expense": ZERO,
            "relevant_revenue": ZERO,
            "relevant_expense": ZERO,
            "native_excluded_expense": ZERO,
            "owner_contribution": ZERO,
            "squad_cost": ZERO,
            "wage_cost": ZERO,
            "related_party_revenue": ZERO,
            "review_amount": ZERO,
        }
        review_line_ids = []
        excluded_line_ids = []
        native_exclusions_by_type = {}
        excluded_line_ids_by_type = {}
        policy_hashes = set()
        federation_ids = set()
        rulebook_resolution_hashes = set()
        count = 0
        for row in rows.iterator():
            line = row.journal_line
            amount = cls._activity(line)
            count += 1
            if line.account.account_type == GLAccountType.REVENUE:
                totals["reported_revenue"] += amount
            elif line.account.account_type == GLAccountType.EXPENSE:
                totals["base_expense"] += amount

            if line.entry.source_type == 'MANUAL_ACCRUAL' and line.account.account_type == GLAccountType.REVENUE:
                totals['review_amount']+=amount
                review_line_ids.append(str(line.pk))
                continue
            if row.classification == GLRegulatoryClassificationType.RELEVANT_REVENUE:
                totals["relevant_revenue"] += amount
            elif row.classification == GLRegulatoryClassificationType.RELATED_PARTY_REVENUE:
                totals["relevant_revenue"] += amount
                totals["related_party_revenue"] += amount
            elif row.classification == GLRegulatoryClassificationType.RELEVANT_EXPENSE:
                totals["relevant_expense"] += amount
            elif row.classification == GLRegulatoryClassificationType.EXCLUDED_EXPENSE:
                totals["native_excluded_expense"] += amount
                excluded_line_ids.append(str(line.pk))
                key = str(row.exclusion_type or "")
                native_exclusions_by_type[key] = q8(native_exclusions_by_type.get(key, ZERO) + amount)
                excluded_line_ids_by_type.setdefault(key, []).append(str(line.pk))
            elif row.classification == GLRegulatoryClassificationType.OWNER_CONTRIBUTION:
                totals["owner_contribution"] += amount
            elif row.classification == GLRegulatoryClassificationType.REVIEW_REQUIRED:
                totals["review_amount"] += amount
                review_line_ids.append(str(line.pk))

            dimensions = set(row.dimensions or [])
            if GLRegulatoryDimension.SQUAD_COST in dimensions and line.account.account_type == GLAccountType.EXPENSE:
                totals["squad_cost"] += amount
            if GLRegulatoryDimension.WAGE_COST in dimensions and line.account.account_type == GLAccountType.EXPENSE:
                totals["wage_cost"] += amount
            federation_ids.add(str(row.federation_id) if row.federation_id else "")
            if row.policy_id:
                policy_hashes.add(row.policy.policy_hash)
            provenance = row.rulebook_governance or {}
            if provenance.get("resolution_hash"):
                rulebook_resolution_hashes.add(provenance["resolution_hash"])

        for key in totals:
            totals[key] = q8(totals[key])
        expected_lines = JournalLine.objects.filter(
            entry__period=period, entry__status__in=[JournalStatus.POSTED, JournalStatus.REVERSED]
        ).count()
        return {
            **totals,
            "classified_lines": count,
            "expected_lines": expected_lines,
            "coverage_complete": count == expected_lines,
            "review_line_ids": review_line_ids,
            "excluded_line_ids": excluded_line_ids,
            "native_exclusions_by_type": {k: q8(v) for k, v in native_exclusions_by_type.items()},
            "excluded_line_ids_by_type": excluded_line_ids_by_type,
            "policy_hashes": sorted(policy_hashes),
            "classification_federation_ids": sorted(federation_ids),
            "rulebook_resolution_hashes": sorted(rulebook_resolution_hashes),
        }
