from decimal import Decimal
from django.shortcuts import get_object_or_404
from django.utils import timezone
from rest_framework import permissions, status
from rest_framework.response import Response
from rest_framework.views import APIView
from clubs.models import Club
from .models import AccountingPeriod, ClubBudget, BudgetLine, FFPAssessment, FinancialControlEvent
from .serializers import AccountingPeriodSerializer, ClubBudgetSerializer, BudgetLineSerializer, FFPAssessmentSerializer, FinancialControlEventSerializer
from .services import AccountingPeriodService, LedgerClassificationService, BudgetService, FFPService, FinanceDashboardService
from .exceptions import FFPPolicyError, BudgetIntegrityError


def _owned_club(user, club_id):
    club = get_object_or_404(Club.objects.select_related("coach_career__user","ownership_record__owner"), pk=club_id)
    return club if club.owner_id == user.id else None


class PeriodListCreateView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def get(self, request, club_id):
        club = _owned_club(request.user, club_id)
        if not club: return Response({"detail": "Not club owner"}, status=403)
        return Response(AccountingPeriodSerializer(AccountingPeriod.objects.filter(club=club), many=True).data)
    def post(self, request, club_id):
        club = _owned_club(request.user, club_id)
        if not club: return Response({"detail": "Not club owner"}, status=403)
        s = AccountingPeriodSerializer(data=request.data); s.is_valid(raise_exception=True)
        starts_at = s.validated_data["starts_at"]; ends_at = s.validated_data["ends_at"]
        if AccountingPeriod.objects.filter(club=club, starts_at__lt=ends_at, ends_at__gt=starts_at).exists():
            return Response({"detail": "Accounting period overlaps an existing period"}, status=409)
        from django.db import transaction, IntegrityError
        try:
            with transaction.atomic():
                Club.objects.select_for_update().get(pk=club.pk)
                obj = AccountingPeriod.objects.create(club=club, **s.validated_data)
        except IntegrityError:
            return Response({'detail':'Accounting period overlaps or duplicates an existing period'},status=409)
        return Response(AccountingPeriodSerializer(obj).data, status=201)


class BudgetListCreateView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def get(self, request, club_id):
        club = _owned_club(request.user, club_id)
        if not club: return Response({"detail": "Not club owner"}, status=403)
        return Response(ClubBudgetSerializer(ClubBudget.objects.filter(club=club).prefetch_related("lines"), many=True).data)
    def post(self, request, club_id):
        club = _owned_club(request.user, club_id)
        if not club: return Response({"detail": "Not club owner"}, status=403)
        period = get_object_or_404(AccountingPeriod, pk=request.data.get("period"), club=club)
        if period.is_closed:return Response({'detail':'Financial period is closed'},status=409)
        payload=ClubBudgetSerializer(data=request.data);payload.is_valid(raise_exception=True)
        from django.db import transaction,IntegrityError
        try:
            with transaction.atomic():obj=payload.save(club=club)
        except IntegrityError:return Response({'detail':'Budget name already exists for this period'},status=409)
        return Response(ClubBudgetSerializer(obj).data, status=201)


class BudgetLineCreateView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def post(self, request, budget_id):
        budget = get_object_or_404(ClubBudget.objects.select_related("club__coach_career__user","club__ownership_record__owner"), pk=budget_id)
        if budget.club.owner_id != request.user.id: return Response({"detail":"Not club owner"}, status=403)
        if budget.status != 'DRAFT' or budget.period.is_closed:return Response({'detail':'Only draft budgets in open periods can be edited'},status=409)
        s = BudgetLineSerializer(data=request.data); s.is_valid(raise_exception=True)
        from django.db import transaction,IntegrityError
        try:
            with transaction.atomic():
                Club.objects.select_for_update().get(pk=budget.club_id)
                budget=ClubBudget.objects.select_for_update().get(pk=budget.pk)
                if budget.status!='DRAFT' or budget.period.is_closed:return Response({'detail':'Only draft budgets in open periods can be edited'},status=409)
                line = BudgetLine.objects.create(budget=budget, **s.validated_data)
        except IntegrityError:return Response({'detail':'This budget category already exists'},status=409)
        return Response(BudgetLineSerializer(line).data, status=201)


class BudgetActionView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def post(self, request, budget_id, action):
        budget = get_object_or_404(ClubBudget.objects.select_related("club__coach_career__user","club__ownership_record__owner"), pk=budget_id)
        if budget.club.owner_id != request.user.id: return Response({"detail":"Not club owner"}, status=403)
        if action == "activate":
            try: return Response(ClubBudgetSerializer(BudgetService.activate(budget)).data)
            except BudgetIntegrityError as exc: return Response({"detail": str(exc)}, status=409)
        if action == "report": return Response(BudgetService.report(budget))
        return Response({"detail":"Unknown action"}, status=404)


class FinanceSyncView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def post(self, request, club_id):
        club = _owned_club(request.user, club_id)
        if not club: return Response({"detail":"Not club owner"}, status=403)
        period = AccountingPeriod.objects.filter(pk=request.data.get("period"), club=club).first() if request.data.get("period") else None
        return Response(LedgerClassificationService.sync_club(club=club, period=period))


class FFPAssessView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def post(self, request, club_id):
        club = _owned_club(request.user, club_id)
        if not club: return Response({"detail":"Not club owner"}, status=403)
        period = get_object_or_404(AccountingPeriod, pk=request.data.get("period"), club=club)
        try:
            assessment = FFPService.assess(club=club, period=period)
        except FFPPolicyError as exc:
            return Response({"detail": str(exc), "code": "FFP_POLICY_REQUIRED"}, status=409)
        return Response(FFPAssessmentSerializer(assessment).data, status=201)


class FinanceDashboardView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def get(self, request, club_id):
        club = _owned_club(request.user, club_id)
        if not club: return Response({"detail":"Not club owner"}, status=403)
        period = AccountingPeriod.objects.filter(pk=request.query_params.get("period"), club=club).first() if request.query_params.get("period") else None
        data = FinanceDashboardService.summary(club=club, period=period)
        data["recent_ffp"] = FFPAssessmentSerializer(FFPAssessment.objects.filter(club=club)[:5], many=True).data
        from .models import FFPRegulatoryAssessment
        from .serializers import FFPRegulatoryAssessmentSerializer
        data["recent_regulatory_ffp"] = FFPRegulatoryAssessmentSerializer(
            FFPRegulatoryAssessment.objects.filter(club=club)[:5], many=True
        ).data
        data["control_events"] = FinancialControlEventSerializer(FinancialControlEvent.objects.filter(club=club)[:20], many=True).data
        return Response(data)

# ---------------------------------------------------------------------------
# Accrual general ledger / three-statement reporting API
# ---------------------------------------------------------------------------
from datetime import date as _date
from api_core.idempotency import execute_idempotent
from api_core.permissions import require_club_owner
from .accounting import (
    AccrualAccountingService, ChartOfAccountsService, FinancialStatementService,
    GeneralLedgerService, PeriodCloseService, ReconciliationService,
)
from .constants import AccrualDocumentType, GLAccountType
from .models import GLAccount, JournalEntry, AccrualDocument, FixedAssetBook, PlayerRegistrationAsset, FinancialStatementSnapshot
from .serializers import (
    GLAccountSerializer, JournalEntrySerializer, AccrualDocumentSerializer,
    FixedAssetBookSerializer, PlayerRegistrationAssetSerializer, FinancialStatementSnapshotSerializer,
)


def _finance_club_or_403(user, club_id):
    club = get_object_or_404(Club, pk=club_id)
    require_club_owner(user, club)
    return club


class GeneralLedgerSyncView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def post(self, request, club_id):
        club = _finance_club_or_403(request.user, club_id)
        period = AccountingPeriod.objects.filter(pk=request.data.get("period"), club=club).first() if request.data.get("period") else None
        def operation():
            through = _date.fromisoformat(request.data["through_date"]) if request.data.get("through_date") else timezone.localdate()
            return GeneralLedgerService.sync(club=club, period=period, through_date=through)
        return execute_idempotent(request=request, scope=f"club-finance:gl-sync:{club.pk}", operation=operation)


class ChartOfAccountsView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def get(self, request, club_id):
        club = _finance_club_or_403(request.user, club_id)
        ChartOfAccountsService.ensure_defaults(club)
        return Response(GLAccountSerializer(GLAccount.objects.filter(club=club), many=True).data)


class JournalListView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def get(self, request, club_id):
        club = _finance_club_or_403(request.user, club_id)
        qs = JournalEntry.objects.filter(club=club).prefetch_related("lines__account").order_by("-accounting_date", "-posted_at")
        if request.query_params.get("period"):
            qs = qs.filter(period_id=request.query_params["period"])
        limit = min(max(int(request.query_params.get("limit", 100)), 1), 500)
        return Response(JournalEntrySerializer(qs[:limit], many=True).data)


class AccrualDocumentListView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def get(self, request, club_id):
        club = _finance_club_or_403(request.user, club_id)
        qs = AccrualDocument.objects.filter(club=club).select_related("recognition_account", "control_account").order_by("due_date", "id")
        if request.query_params.get("type"):
            qs = qs.filter(document_type=request.query_params["type"])
        if request.query_params.get("status"):
            qs = qs.filter(status=request.query_params["status"])
        return Response(AccrualDocumentSerializer(qs[:500], many=True).data)

    def post(self, request, club_id):
        club = _finance_club_or_403(request.user, club_id)
        from rest_framework import serializers
        from decimal import Decimal
        class Input(serializers.Serializer):
            document_type=serializers.ChoiceField(choices=AccrualDocumentType.values)
            amount=serializers.DecimalField(max_digits=24,decimal_places=8,min_value=Decimal('.00000001'))
            recognized_on=serializers.DateField()
            due_date=serializers.DateField()
            recognition_account_code=serializers.CharField(max_length=20)
            counterparty_label=serializers.CharField(max_length=160,required=False,allow_blank=True,default='')
            source_id=serializers.CharField(max_length=120,required=False,allow_blank=True,default='')
            memo=serializers.CharField(max_length=255,required=False,allow_blank=True,default='')
        payload=Input(data=request.data);payload.is_valid(raise_exception=True); data=payload.validated_data
        def operation():
            doc_type = data["document_type"]
            if doc_type not in AccrualDocumentType.values:
                return Response({"detail": "Invalid document_type"}, status=400)
            ChartOfAccountsService.ensure_defaults(club)
            code = str(data["recognition_account_code"] or "")
            account = GLAccount.objects.filter(club=club, code=code, is_active=True).first()
            if not account:
                return Response({"detail": "Unknown recognition account"}, status=400)
            if doc_type == AccrualDocumentType.PAYABLE and account.account_type != GLAccountType.EXPENSE:
                return Response({"detail": "Payables must recognize an expense account"}, status=400)
            if doc_type == AccrualDocumentType.RECEIVABLE and account.account_type != GLAccountType.REVENUE:
                return Response({"detail": "Receivables must recognize a revenue account"}, status=400)
            obj = AccrualAccountingService.create_manual_document(
                club=club, document_type=doc_type, amount=data["amount"],
                recognized_on=data["recognized_on"],
                due_date=data["due_date"],
                recognition_account_code=code, counterparty_label=data["counterparty_label"],
                source_type="MANUAL_ACCRUAL", source_id=data["source_id"],
                idempotency_key=(request.headers.get("Idempotency-Key") or request.data.get("idempotency_key")),
                memo=data["memo"],
            )
            return Response(AccrualDocumentSerializer(obj).data, status=201)
        return execute_idempotent(request=request, scope=f"club-finance:accrual-create:{club.pk}", operation=operation)


class AssetBookView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def get(self, request, club_id):
        club = _finance_club_or_403(request.user, club_id)
        fixed = FixedAssetBook.objects.filter(club=club).select_related("asset")
        players = PlayerRegistrationAsset.objects.filter(club=club).select_related("player", "contract")
        return Response({"fixed_assets": FixedAssetBookSerializer(fixed, many=True).data, "player_registration_assets": PlayerRegistrationAssetSerializer(players, many=True).data})


class FinancialStatementView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def get(self, request, club_id, statement):
        club = _finance_club_or_403(request.user, club_id)
        period = get_object_or_404(AccountingPeriod, pk=request.query_params.get("period"), club=club) if request.query_params.get("period") else None
        if statement == "trial-balance":
            through = _date.fromisoformat(request.query_params["as_of"]) if request.query_params.get("as_of") else None
            return Response(FinancialStatementService.trial_balance(club=club, through_date=through, period=period))
        if statement == "income-statement":
            if not period: return Response({"detail": "period is required"}, status=400)
            return Response(FinancialStatementService.income_statement(club=club, period=period))
        if statement == "cash-flow":
            if not period: return Response({"detail": "period is required"}, status=400)
            return Response(FinancialStatementService.cash_flow(club=club, period=period))
        if statement == "balance-sheet":
            as_of = _date.fromisoformat(request.query_params["as_of"]) if request.query_params.get("as_of") else timezone.localdate()
            return Response(FinancialStatementService.balance_sheet(club=club, as_of=as_of))
        if statement == "three-statements":
            if not period: return Response({"detail": "period is required"}, status=400)
            return Response(FinancialStatementService.three_statements(club=club, period=period))
        return Response({"detail": "Unknown statement"}, status=404)


class AccountingPeriodCloseView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def post(self, request, period_id):
        period = get_object_or_404(AccountingPeriod.objects.select_related("club"), pk=period_id)
        require_club_owner(request.user, period.club)
        def operation():
            closed = PeriodCloseService.close(period)
            snapshots = FinancialStatementSnapshot.objects.filter(period=closed)
            return Response({"period": AccountingPeriodSerializer(closed).data, "snapshots": FinancialStatementSnapshotSerializer(snapshots, many=True).data})
        return execute_idempotent(request=request, scope=f"club-finance:period-close:{period.pk}", operation=operation)


class GeneralLedgerReconciliationView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def get(self, request, club_id):
        club = _finance_club_or_403(request.user, club_id)
        period = AccountingPeriod.objects.filter(pk=request.query_params.get("period"), club=club).first() if request.query_params.get("period") else None
        return Response(ReconciliationService.status(club=club, period=period))

# ---------------------------------------------------------------------------
# Regulatory FFP bridge / multi-season compliance API
# ---------------------------------------------------------------------------
from api_core.permissions import require_federation_role
from federations.models import Federation
from club_commercial.models import SponsorshipAgreement
from .models import (
    FFPRegulatoryPolicy, FFPRegulatoryAdjustment, FFPRelatedPartyReview,
    FFPRegulatoryAssessment, FFPRegulatorySubmission, FFPFederationReviewCase,
)
from .serializers import (
    FFPRegulatoryPolicySerializer, FFPRegulatoryAdjustmentSerializer,
    FFPRelatedPartyReviewSerializer, FFPRegulatoryAssessmentSerializer,
    FFPRegulatorySubmissionSerializer, FFPFederationReviewCaseSerializer,
)
from .regulatory import (
    RegulatoryFederationResolver, RegulatoryEvidenceService, RegulatoryCalculationService,
    RegulatorySubmissionService,
)
from .regulatory_constants import RegulatoryEvidenceStatus


class RegulatoryPolicyListCreateView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request, federation_id):
        federation = get_object_or_404(Federation, pk=federation_id)
        require_federation_role(request.user, federation, roles=["GOVERNOR", "TREASURY"])
        return Response(FFPRegulatoryPolicySerializer(
            FFPRegulatoryPolicy.objects.filter(federation=federation), many=True
        ).data)

    def post(self, request, federation_id):
        federation = get_object_or_404(Federation, pk=federation_id)
        require_federation_role(request.user, federation, roles=["GOVERNOR", "TREASURY"])

        def operation():
            serializer = FFPRegulatoryPolicySerializer(data=request.data)
            serializer.is_valid(raise_exception=True)
            obj = serializer.save(federation=federation)
            return Response(FFPRegulatoryPolicySerializer(obj).data, status=201)
        return execute_idempotent(
            request=request, scope=f"ffp-regulatory.policy.create:{federation.pk}", operation=operation
        )


class RegulatoryAssessmentListCreateView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request, club_id):
        club = get_object_or_404(Club.objects.select_related("ownership_record__owner", "coach_career__user"), pk=club_id)
        require_club_owner(request.user, club)
        qs = FFPRegulatoryAssessment.objects.filter(club=club).select_related("target_period", "policy", "federation")[:100]
        return Response(FFPRegulatoryAssessmentSerializer(qs, many=True).data)

    def post(self, request, club_id):
        club = get_object_or_404(Club.objects.select_related("ownership_record__owner", "coach_career__user"), pk=club_id)
        require_club_owner(request.user, club)
        period = get_object_or_404(AccountingPeriod, pk=request.data.get("period"), club=club)

        def operation():
            try:
                obj = RegulatoryCalculationService.assess(club=club, target_period=period)
            except (FFPPolicyError, BudgetIntegrityError) as exc:
                return Response({"detail": str(exc)}, status=409)
            return Response(FFPRegulatoryAssessmentSerializer(obj).data, status=201)
        return execute_idempotent(
            request=request, scope=f"ffp-regulatory.assess:{club.pk}:{period.pk}", operation=operation
        )


class RegulatoryAdjustmentListCreateView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request, club_id):
        club = get_object_or_404(Club.objects.select_related("ownership_record__owner", "coach_career__user"), pk=club_id)
        require_club_owner(request.user, club)
        return Response(FFPRegulatoryAdjustmentSerializer(
            FFPRegulatoryAdjustment.objects.filter(club=club).select_related("period", "requested_by", "reviewed_by")[:200], many=True
        ).data)

    def post(self, request, club_id):
        club = get_object_or_404(Club.objects.select_related("ownership_record__owner", "coach_career__user"), pk=club_id)
        require_club_owner(request.user, club)
        period = get_object_or_404(AccountingPeriod, pk=request.data.get("period"), club=club)

        def operation():
            try:
                obj = RegulatoryEvidenceService.create_adjustment(
                    club=club, period=period, user=request.user,
                    adjustment_type=request.data.get("adjustment_type"), amount=request.data.get("amount"),
                    source_type=request.data.get("source_type", ""), source_id=request.data.get("source_id", ""),
                    explanation=request.data.get("explanation", ""), evidence=request.data.get("evidence") or {},
                )
            except BudgetIntegrityError as exc:
                return Response({"detail": str(exc)}, status=409)
            return Response(FFPRegulatoryAdjustmentSerializer(obj).data, status=201)
        return execute_idempotent(
            request=request, scope=f"ffp-regulatory.adjustment.create:{club.pk}", operation=operation
        )


class RegulatoryAdjustmentActionView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def post(self, request, adjustment_id, action):
        adjustment = get_object_or_404(
            FFPRegulatoryAdjustment.objects.select_related("club__ownership_record__owner", "period"), pk=adjustment_id
        )
        if action == "submit":
            require_club_owner(request.user, adjustment.club)
            def operation():
                try:
                    obj = RegulatoryEvidenceService.submit_adjustment(adjustment=adjustment, user=request.user)
                except BudgetIntegrityError as exc:
                    return Response({"detail": str(exc)}, status=409)
                return Response(FFPRegulatoryAdjustmentSerializer(obj).data)
            return execute_idempotent(request=request, scope=f"ffp-regulatory.adjustment.submit:{adjustment.pk}", operation=operation)

        federation = RegulatoryFederationResolver.for_club_period(adjustment.club, adjustment.period)
        require_federation_role(request.user, federation, roles=["GOVERNOR", "TREASURY"])
        if action not in ["approve", "reject"]:
            return Response({"detail": "Unknown action"}, status=404)
        def operation():
            try:
                obj = RegulatoryEvidenceService.decide_adjustment(
                    adjustment=adjustment, reviewer=request.user, approve=(action == "approve")
                )
            except (BudgetIntegrityError, FFPPolicyError) as exc:
                return Response({"detail": str(exc)}, status=409)
            return Response(FFPRegulatoryAdjustmentSerializer(obj).data)
        return execute_idempotent(request=request, scope=f"ffp-regulatory.adjustment.{action}:{adjustment.pk}", operation=operation)


class RelatedPartyReviewListCreateView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request, club_id):
        club = get_object_or_404(Club.objects.select_related("ownership_record__owner", "coach_career__user"), pk=club_id)
        require_club_owner(request.user, club)
        qs = FFPRelatedPartyReview.objects.filter(club=club).select_related("agreement", "period")[:200]
        return Response(FFPRelatedPartyReviewSerializer(qs, many=True).data)

    def post(self, request, club_id):
        club = get_object_or_404(Club.objects.select_related("ownership_record__owner", "coach_career__user"), pk=club_id)
        require_club_owner(request.user, club)
        period = get_object_or_404(AccountingPeriod, pk=request.data.get("period"), club=club)
        agreement = get_object_or_404(SponsorshipAgreement, pk=request.data.get("agreement"), club=club)

        def operation():
            try:
                obj = RegulatoryEvidenceService.disclose_related_party(
                    club=club, period=period, agreement=agreement, user=request.user,
                    relationship_summary=request.data.get("relationship_summary", ""),
                    evidence=request.data.get("evidence") or {},
                )
            except BudgetIntegrityError as exc:
                return Response({"detail": str(exc)}, status=409)
            return Response(FFPRelatedPartyReviewSerializer(obj).data, status=201)
        return execute_idempotent(request=request, scope=f"ffp-regulatory.related-party.disclose:{agreement.pk}:{period.pk}", operation=operation)


class RelatedPartyReviewDecisionView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def post(self, request, review_id):
        review = get_object_or_404(FFPRelatedPartyReview.objects.select_related("club", "period"), pk=review_id)
        federation = RegulatoryFederationResolver.for_club_period(review.club, review.period)
        require_federation_role(request.user, federation, roles=["GOVERNOR", "TREASURY"])
        approve = request.data.get("approve")
        if approve not in [True, False]:
            return Response({"detail": "approve must be a boolean"}, status=400)

        def operation():
            try:
                obj = RegulatoryEvidenceService.decide_related_party(
                    review=review, reviewer=request.user, approve=approve,
                    fair_value=request.data.get("fair_value"), allowed_revenue=request.data.get("allowed_revenue"),
                )
            except BudgetIntegrityError as exc:
                return Response({"detail": str(exc)}, status=409)
            return Response(FFPRelatedPartyReviewSerializer(obj).data)
        return execute_idempotent(request=request, scope=f"ffp-regulatory.related-party.decision:{review.pk}", operation=operation)


class RegulatorySubmissionListCreateView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request, club_id):
        club = get_object_or_404(Club.objects.select_related("ownership_record__owner", "coach_career__user"), pk=club_id)
        require_club_owner(request.user, club)
        qs = FFPRegulatorySubmission.objects.filter(club=club).select_related("assessment")[:100]
        return Response(FFPRegulatorySubmissionSerializer(qs, many=True).data)

    def post(self, request, club_id):
        club = get_object_or_404(Club.objects.select_related("ownership_record__owner", "coach_career__user"), pk=club_id)
        require_club_owner(request.user, club)
        assessment = get_object_or_404(FFPRegulatoryAssessment, pk=request.data.get("assessment"), club=club)
        def operation():
            obj = RegulatorySubmissionService.create_draft(assessment=assessment)
            return Response(FFPRegulatorySubmissionSerializer(obj).data, status=201)
        return execute_idempotent(request=request, scope=f"ffp-regulatory.submission.create:{assessment.pk}", operation=operation)


class RegulatorySubmissionSubmitView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def post(self, request, submission_id):
        submission = get_object_or_404(
            FFPRegulatorySubmission.objects.select_related("club__ownership_record__owner", "assessment"), pk=submission_id
        )
        require_club_owner(request.user, submission.club)
        def operation():
            try:
                obj = RegulatorySubmissionService.submit(
                    submission=submission, user=request.user, attestation_text=request.data.get("attestation_text", "")
                )
            except BudgetIntegrityError as exc:
                return Response({"detail": str(exc)}, status=409)
            return Response(FFPRegulatorySubmissionSerializer(obj).data)
        return execute_idempotent(request=request, scope=f"ffp-regulatory.submission.submit:{submission.pk}", operation=operation)


class FederationRegulatoryQueueView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request, federation_id):
        federation = get_object_or_404(Federation, pk=federation_id)
        require_federation_role(request.user, federation, roles=["GOVERNOR", "TREASURY"])
        status_filter = request.query_params.get("status")
        qs = FFPFederationReviewCase.objects.filter(federation=federation).select_related(
            "submission__club", "submission__assessment"
        ).prefetch_related("events")
        if status_filter:
            qs = qs.filter(status=status_filter)
        return Response(FFPFederationReviewCaseSerializer(qs[:200], many=True).data)


class FederationRegulatoryReviewActionView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def post(self, request, case_id):
        case = get_object_or_404(FFPFederationReviewCase.objects.select_related("federation", "submission"), pk=case_id)
        require_federation_role(request.user, case.federation, roles=["GOVERNOR", "TREASURY"])
        action = request.data.get("action")
        def operation():
            try:
                obj = RegulatorySubmissionService.review(
                    case=case, reviewer=request.user, action=action,
                    findings=request.data.get("findings"), sanctions=request.data.get("sanctions"),
                )
            except BudgetIntegrityError as exc:
                return Response({"detail": str(exc)}, status=409)
            return Response(FFPFederationReviewCaseSerializer(obj).data)
        return execute_idempotent(request=request, scope=f"ffp-regulatory.case.action:{case.pk}:{action}", operation=operation)

class FederationRegulatoryEvidenceQueueView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request, federation_id):
        federation = get_object_or_404(Federation, pk=federation_id)
        require_federation_role(request.user, federation, roles=["GOVERNOR", "TREASURY"])
        adjustments = []
        for item in FFPRegulatoryAdjustment.objects.filter(status=RegulatoryEvidenceStatus.SUBMITTED).select_related("club", "period")[:500]:
            try:
                if RegulatoryFederationResolver.for_club_period(item.club, item.period).pk == federation.pk:
                    adjustments.append(item)
            except FFPPolicyError:
                continue
        related = []
        from .regulatory_constants import RelatedPartyReviewStatus
        for item in FFPRelatedPartyReview.objects.filter(status__in=[RelatedPartyReviewStatus.DISCLOSED, RelatedPartyReviewStatus.UNDER_REVIEW]).select_related("club", "period", "agreement")[:500]:
            try:
                if RegulatoryFederationResolver.for_club_period(item.club, item.period).pk == federation.pk:
                    related.append(item)
            except FFPPolicyError:
                continue
        return Response({
            "adjustments": FFPRegulatoryAdjustmentSerializer(adjustments, many=True).data,
            "related_party_reviews": FFPRelatedPartyReviewSerializer(related, many=True).data,
        })

# ---------------------------------------------------------------------------
# Native GL regulatory dimensions / Rulebook accounting treatment API
# ---------------------------------------------------------------------------
from .models import (
    GLRegulatoryTreatmentPolicy,
    JournalLineRegulatoryClassification,
)
from .serializers import (
    GLRegulatoryTreatmentPolicySerializer,
    GLRegulatoryTreatmentRuleSerializer,
    JournalLineRegulatoryClassificationSerializer,
)
from .regulatory_dimensions import (
    GLRegulatoryTreatmentPolicyService,
    GLRegulatoryClassificationService,
)


class GLRegulatoryTreatmentPolicyListCreateView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request, federation_id):
        federation = get_object_or_404(Federation, pk=federation_id)
        require_federation_role(request.user, federation, roles=["GOVERNOR", "TREASURY"])
        qs = GLRegulatoryTreatmentPolicy.objects.filter(federation=federation).prefetch_related("treatment_rules")
        return Response(GLRegulatoryTreatmentPolicySerializer(qs, many=True).data)

    def post(self, request, federation_id):
        federation = get_object_or_404(Federation, pk=federation_id)
        require_federation_role(request.user, federation, roles=["GOVERNOR", "TREASURY"])

        def operation():
            serializer = GLRegulatoryTreatmentPolicySerializer(data=request.data)
            serializer.is_valid(raise_exception=True)
            obj = serializer.save(federation=federation)
            return Response(GLRegulatoryTreatmentPolicySerializer(obj).data, status=201)

        return execute_idempotent(
            request=request,
            scope=f"gl-regulatory-treatment.policy.create:{federation.pk}",
            operation=operation,
        )


class GLRegulatoryTreatmentRuleCreateView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def post(self, request, policy_id):
        policy = get_object_or_404(GLRegulatoryTreatmentPolicy.objects.select_related("federation"), pk=policy_id)
        require_federation_role(request.user, policy.federation, roles=["GOVERNOR", "TREASURY"])
        serializer = GLRegulatoryTreatmentRuleSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        def operation():
            try:
                rule = GLRegulatoryTreatmentPolicyService.add_rule(policy=policy, values=serializer.validated_data)
            except BudgetIntegrityError as exc:
                return Response({"detail": str(exc)}, status=409)
            return Response(GLRegulatoryTreatmentRuleSerializer(rule).data, status=201)

        return execute_idempotent(
            request=request,
            scope=f"gl-regulatory-treatment.rule.create:{policy.pk}",
            operation=operation,
        )


class GLRegulatoryTreatmentPolicyPublishView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def post(self, request, policy_id):
        policy = get_object_or_404(GLRegulatoryTreatmentPolicy.objects.select_related("federation"), pk=policy_id)
        require_federation_role(request.user, policy.federation, roles=["GOVERNOR", "TREASURY"])

        def operation():
            try:
                published = GLRegulatoryTreatmentPolicyService.publish(policy=policy, actor=request.user)
            except BudgetIntegrityError as exc:
                return Response({"detail": str(exc)}, status=409)
            return Response(GLRegulatoryTreatmentPolicySerializer(published).data)

        return execute_idempotent(
            request=request,
            scope=f"gl-regulatory-treatment.policy.publish:{policy.pk}",
            operation=operation,
        )


class GLRegulatoryTreatmentPolicyIntegrityView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request, policy_id):
        policy = get_object_or_404(GLRegulatoryTreatmentPolicy.objects.select_related("federation"), pk=policy_id)
        require_federation_role(request.user, policy.federation, roles=["GOVERNOR", "TREASURY"])
        return Response(GLRegulatoryTreatmentPolicyService.verify_integrity(policy))


class PeriodGLRegulatoryClassificationView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def _period(self, request, period_id):
        period = get_object_or_404(AccountingPeriod.objects.select_related("club", "season"), pk=period_id)
        require_club_owner(request.user, period.club)
        return period

    def get(self, request, period_id):
        period = self._period(request, period_id)
        try:
            summary = GLRegulatoryClassificationService.period_summary(period)
        except (BudgetIntegrityError, FFPPolicyError) as exc:
            return Response({"detail": str(exc)}, status=409)
        qs = (
            JournalLineRegulatoryClassification.objects.filter(period=period)
            .select_related("journal_line__account", "entry", "policy", "policy_rule", "federation")
            .order_by("entry__accounting_date", "entry_id", "journal_line__line_no")[:500]
        )
        return Response({
            "summary": {key: str(value) if isinstance(value, Decimal) else value for key, value in summary.items()},
            "classifications": JournalLineRegulatoryClassificationSerializer(qs, many=True).data,
        })

    def post(self, request, period_id):
        period = self._period(request, period_id)

        def operation():
            try:
                result = GLRegulatoryClassificationService.ensure_period(period)
                summary = GLRegulatoryClassificationService.period_summary(period)
            except (BudgetIntegrityError, FFPPolicyError) as exc:
                return Response({"detail": str(exc)}, status=409)
            return Response({
                "backfill": result,
                "summary": {key: str(value) if isinstance(value, Decimal) else value for key, value in summary.items()},
            })

        return execute_idempotent(
            request=request,
            scope=f"gl-regulatory-treatment.period.backfill:{period.pk}",
            operation=operation,
        )

class GLRegulatoryTreatmentPolicyDetailView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def _policy(self, request, policy_id):
        policy = get_object_or_404(GLRegulatoryTreatmentPolicy.objects.select_related("federation"), pk=policy_id)
        require_federation_role(request.user, policy.federation, roles=["GOVERNOR", "TREASURY"])
        return policy

    def get(self, request, policy_id):
        policy = self._policy(request, policy_id)
        return Response(GLRegulatoryTreatmentPolicySerializer(policy).data)

    def patch(self, request, policy_id):
        policy = self._policy(request, policy_id)
        if policy.status != "DRAFT":
            return Response({"detail": "Published GL regulatory treatment policies are immutable"}, status=409)
        serializer = GLRegulatoryTreatmentPolicySerializer(policy, data=request.data, partial=True)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(serializer.data)


class GLRegulatoryTreatmentRuleDetailView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def _rule(self, request, rule_id):
        from .models import GLRegulatoryTreatmentRule
        rule = get_object_or_404(GLRegulatoryTreatmentRule.objects.select_related("policy__federation"), pk=rule_id)
        require_federation_role(request.user, rule.policy.federation, roles=["GOVERNOR", "TREASURY"])
        return rule

    def get(self, request, rule_id):
        return Response(GLRegulatoryTreatmentRuleSerializer(self._rule(request, rule_id)).data)

    def patch(self, request, rule_id):
        rule = self._rule(request, rule_id)
        if rule.policy.status != "DRAFT":
            return Response({"detail": "Rules of a published policy are immutable"}, status=409)
        serializer = GLRegulatoryTreatmentRuleSerializer(rule, data=request.data, partial=True)
        serializer.is_valid(raise_exception=True)
        try:
            GLRegulatoryTreatmentPolicyService.validate_rule_values(
                classification=serializer.validated_data.get("classification", rule.classification),
                dimensions=serializer.validated_data.get("dimensions", rule.dimensions),
                exclusion_type=serializer.validated_data.get("exclusion_type", rule.exclusion_type),
                account_types=serializer.validated_data.get("account_types", rule.account_types),
            )
            serializer.save()
        except BudgetIntegrityError as exc:
            return Response({"detail": str(exc)}, status=409)
        return Response(serializer.data)

    def delete(self, request, rule_id):
        rule = self._rule(request, rule_id)
        try:
            rule.delete()
        except BudgetIntegrityError as exc:
            return Response({"detail": str(exc)}, status=409)
        return Response(status=204)
