from django.core.management.base import BaseCommand, CommandError

from club_finance.models import (
    AccountingPeriod,
    GLRegulatoryTreatmentPolicy,
    JournalLine,
    JournalLineRegulatoryClassification,
)
from club_finance.regulatory_constants import GLRegulatoryPolicyStatus
from club_finance.regulatory_dimensions import (
    GLRegulatoryClassificationService,
    GLRegulatoryTreatmentPolicyService,
)
from club_finance.constants import JournalStatus


class Command(BaseCommand):
    help = "Verify GL regulatory treatment policy hashes, line classification hashes, and classification coverage."

    def add_arguments(self, parser):
        parser.add_argument("--backfill", action="store_true", help="Classify missing historical journal lines before verification.")

    def handle(self, *args, **options):
        errors = []
        policies_checked = 0
        classifications_checked = 0
        backfilled = 0

        if options["backfill"]:
            for period in AccountingPeriod.objects.order_by("starts_at", "id").iterator():
                result = GLRegulatoryClassificationService.ensure_period(period)
                backfilled += result["classifications_created"]

        for policy in GLRegulatoryTreatmentPolicy.objects.filter(status=GLRegulatoryPolicyStatus.PUBLISHED).prefetch_related("treatment_rules"):
            policies_checked += 1
            result = GLRegulatoryTreatmentPolicyService.verify_integrity(policy)
            if not result["valid"]:
                errors.append(f"Policy {policy.pk} failed integrity verification")

        qs = JournalLineRegulatoryClassification.objects.select_related(
            "journal_line__account", "entry", "policy", "policy_rule", "federation"
        )
        for row in qs.iterator():
            classifications_checked += 1
            result = GLRegulatoryClassificationService.verify(row)
            if not result["valid"]:
                errors.append(f"Classification {row.pk} failed integrity verification")

        expected = JournalLine.objects.filter(
            entry__status__in=[JournalStatus.POSTED, JournalStatus.REVERSED]
        ).count()
        actual = JournalLineRegulatoryClassification.objects.filter(
            entry__status__in=[JournalStatus.POSTED, JournalStatus.REVERSED]
        ).count()
        if actual != expected:
            errors.append(f"Classification coverage incomplete: {actual}/{expected} journal lines classified")

        summary = {
            "published_policies_checked": policies_checked,
            "classifications_checked": classifications_checked,
            "classifications_backfilled": backfilled,
            "coverage": {"classified": actual, "expected": expected},
            "errors": errors,
        }
        self.stdout.write(str(summary))
        if errors:
            raise CommandError("GL regulatory treatment verification failed")
        self.stdout.write(self.style.SUCCESS("GL regulatory treatment verification passed"))
