from django.core.management.base import BaseCommand
from django.db import transaction
from django.db.models import Q

from apps.business.binary_tree.models import BinaryLevelSnapshot, BinaryPlacementLog, BinaryTreeMetrics
from apps.business.distributor.models import (
    AutoIDActivationLog,
    AutoIDAllocation,
    BrandAmbassadorEligibility,
    DistributorGlobalPositionCounter,
    DistributorID,
    DistributorOwnershipPeriod,
    DistributorQualificationState,
    DistributorRewardOwnershipLedger,
    DistributorTransferAcceptance,
    DistributorTransferHistory,
    DistributorTransferRequest,
)
from apps.business.network_chat.models import ChatConversation, ChatMessage
from apps.business.orders.models import Order
from apps.business.pool.models import PoolEntry
from apps.business.power_stream.models import PowerStreamBonusRecord
from apps.business.rewards.models import DistributorLevelProgress
from apps.business.wallet.models import (
    ConversionRule,
    MonthlyConversionLog,
    SuperCoinTransaction,
    TDSLedger,
    UserVoucherCode,
    WalletLedger,
)


class Command(BaseCommand):
    help = "Delete all Distributor IDs and distributor-related ledgers/purchases data."

    def add_arguments(self, parser):
        parser.add_argument(
            "--confirm",
            action="store_true",
            help="Required safety flag to execute destructive deletion.",
        )

    def handle(self, *args, **options):
        if not options.get("confirm"):
            self.stdout.write(self.style.ERROR("Refusing to run without --confirm"))
            return

        distributor_qs = DistributorID.objects.all()
        distributor_count = distributor_qs.count()
        if distributor_count == 0:
            self.stdout.write(self.style.WARNING("No Distributor IDs found. Nothing to delete."))
            return

        distributor_user_ids = DistributorID.objects.values_list("user_id", flat=True).distinct()
        distributor_codes = DistributorID.objects.values_list("distributor_code", flat=True)

        order_qs = Order.objects.filter(Q(distributor__in=distributor_qs) | Q(order_type="BUNDLE"))
        order_refs_qs = order_qs.values_list("reference_id", flat=True)

        source_types = [
            WalletLedger.SourceType.DIRECT_INCENTIVE,
            WalletLedger.SourceType.LEVEL_REWARD,
            WalletLedger.SourceType.POWER_STREAM,
            WalletLedger.SourceType.PURCHASE,
            WalletLedger.SourceType.VOUCHER_PURCHASE,
            WalletLedger.SourceType.TDS_DEDUCTION,
        ]

        qs_map = {
            "Orders": order_qs,
            "WalletLedger": WalletLedger.objects.filter(
                Q(reference_id__in=order_refs_qs)
                | Q(user_id__in=distributor_user_ids, source_type__in=source_types)
            ),
            "SuperCoinTransaction": SuperCoinTransaction.objects.filter(
                Q(reference_id__in=order_refs_qs)
                | Q(
                    user_id__in=distributor_user_ids,
                    source_type__in=[
                        SuperCoinTransaction.SourceType.LEVEL_REWARD,
                        SuperCoinTransaction.SourceType.PURCHASE,
                    ],
                )
            ),
            "UserVoucherCode": UserVoucherCode.objects.filter(
                Q(source_reference_id__in=order_refs_qs) | Q(user_id__in=distributor_user_ids)
            ),
            "TDSLedger": TDSLedger.objects.filter(
                Q(distributor_id__in=distributor_codes) | Q(user_id__in=distributor_user_ids)
            ),
            "ConversionRule": ConversionRule.objects.filter(
                Q(distributor_id__in=distributor_codes) | Q(user_id__in=distributor_user_ids)
            ),
            "MonthlyConversionLog": MonthlyConversionLog.objects.filter(
                Q(distributor_id__in=distributor_codes) | Q(user_id__in=distributor_user_ids)
            ),
            "PowerStreamBonusRecord": PowerStreamBonusRecord.objects.filter(
                Q(earner_distributor__in=distributor_qs)
                | Q(trigger_distributor__in=distributor_qs)
                | Q(earner_id__in=distributor_user_ids)
            ),
            "BinaryTreeMetrics": BinaryTreeMetrics.objects.filter(distributor__in=distributor_qs),
            "BinaryPlacementLog": BinaryPlacementLog.objects.filter(
                Q(distributor__in=distributor_qs)
                | Q(binary_parent__in=distributor_qs)
                | Q(sponsor__in=distributor_qs)
            ),
            "BinaryLevelSnapshot": BinaryLevelSnapshot.objects.filter(distributor__in=distributor_qs),
            "DistributorLevelProgress": DistributorLevelProgress.objects.filter(distributor__in=distributor_qs),
            "PoolEntry": PoolEntry.objects.filter(distributor__in=distributor_qs),
            "DistributorRewardOwnershipLedger": DistributorRewardOwnershipLedger.objects.filter(distributor__in=distributor_qs),
            "DistributorQualificationState": DistributorQualificationState.objects.filter(distributor__in=distributor_qs),
            "DistributorOwnershipPeriod": DistributorOwnershipPeriod.objects.filter(distributor__in=distributor_qs),
            "DistributorTransferAcceptance": DistributorTransferAcceptance.objects.filter(
                transfer_request__target_distributor__in=distributor_qs
            ),
            "DistributorTransferHistory": DistributorTransferHistory.objects.filter(distributor__in=distributor_qs),
            "DistributorTransferRequest": DistributorTransferRequest.objects.filter(target_distributor__in=distributor_qs),
            "AutoIDActivationLog": AutoIDActivationLog.objects.filter(activated_distributor__in=distributor_qs),
            "AutoIDAllocation": AutoIDAllocation.objects.filter(source_distributor__in=distributor_qs),
            "BrandAmbassadorEligibility": BrandAmbassadorEligibility.objects.filter(user_id__in=distributor_user_ids),
            "ChatMessage": ChatMessage.objects.filter(
                Q(sender_id__in=distributor_user_ids)
                | Q(sender_distributor_code__in=distributor_codes)
                | Q(conversation__initiator_distributor_code__in=distributor_codes)
                | Q(conversation__recipient_distributor_code__in=distributor_codes)
            ),
            "ChatConversation": ChatConversation.objects.filter(
                Q(initiator_distributor_code__in=distributor_codes)
                | Q(recipient_distributor_code__in=distributor_codes)
                | Q(initiator_id__in=distributor_user_ids)
                | Q(recipient_id__in=distributor_user_ids)
            ),
        }

        self.stdout.write(self.style.WARNING("Purging distributor-related data:"))
        for name, qs in qs_map.items():
            self.stdout.write(f"  {name}: {qs.count()}")
        self.stdout.write(f"  DistributorID: {distributor_count}")

        with transaction.atomic():
            for _, qs in qs_map.items():
                qs.delete()

            DistributorID.objects.all().delete()
            DistributorGlobalPositionCounter.objects.update_or_create(pk=1, defaults={"counter": 0})

        self.stdout.write(self.style.SUCCESS("Distributor IDs and related data deleted successfully."))