from django.core.management.base import BaseCommand
from django.db import transaction
from registration.models import Event, EventType
from feedback.models import Feedback, FeedbackConfiguration
from datetime import datetime
from django.utils import timezone


class Command(BaseCommand):
    help = 'Migrate existing feedback to be linked with events'

    def add_arguments(self, parser):
        parser.add_argument(
            '--create-legacy-event',
            action='store_true',
            help='Create a "Legacy Feedback" event for unlinked feedback',
        )
        parser.add_argument(
            '--event-name',
            type=str,
            default='Legacy Feedback Collection',
            help='Name for the legacy event (default: Legacy Feedback Collection)',
        )
        parser.add_argument(
            '--dry-run',
            action='store_true',
            help='Show what would be done without making changes',
        )

    def handle(self, *args, **options):
        dry_run = options['dry_run']
        create_legacy_event = options['create_legacy_event']
        event_name = options['event_name']

        # Find feedback without event links
        unlinked_feedback = Feedback.objects.filter(event__isnull=True)
        unlinked_count = unlinked_feedback.count()

        self.stdout.write(f"Found {unlinked_count} feedback entries without event links")

        if unlinked_count == 0:
            self.stdout.write(self.style.SUCCESS("No unlinked feedback found. Migration not needed."))
            return

        if dry_run:
            self.stdout.write(self.style.WARNING("DRY RUN MODE - No changes will be made"))
            
            # Group by event_name to show what would happen
            event_names = unlinked_feedback.values_list('event_name', flat=True).distinct()
            for name in event_names:
                count = unlinked_feedback.filter(event_name=name).count()
                self.stdout.write(f"  - '{name}': {count} feedback entries")
            
            if create_legacy_event:
                self.stdout.write(f"Would create legacy event: '{event_name}'")
            return

        with transaction.atomic():
            if create_legacy_event:
                # Create a legacy event type
                legacy_type, created = EventType.objects.get_or_create(
                    name="Legacy",
                    defaults={'description': 'Legacy events for historical feedback'}
                )

                # Create a legacy event
                legacy_event, created = Event.objects.get_or_create(
                    name=event_name,
                    defaults={
                        'event_type': legacy_type,
                        'description': 'Legacy event created to archive existing feedback',
                        'start_date': timezone.now() - timezone.timedelta(days=365),
                        'end_date': timezone.now() - timezone.timedelta(days=364),
                        'location': 'Various',
                        'is_paid': False,
                        'is_active': False
                    }
                )

                # Link all unlinked feedback to the legacy event
                updated_count = unlinked_feedback.update(event=legacy_event)
                
                self.stdout.write(
                    self.style.SUCCESS(
                        f"Created legacy event '{event_name}' and linked {updated_count} feedback entries"
                    )
                )

            else:
                # Try to match feedback to existing events by event_name
                matched_count = 0
                unmatched_feedback = []

                for feedback in unlinked_feedback:
                    if feedback.event_name:
                        # Try to find an existing event with similar name
                        existing_event = Event.objects.filter(
                            name__icontains=feedback.event_name
                        ).first()
                        
                        if existing_event:
                            feedback.event = existing_event
                            feedback.save()
                            matched_count += 1
                        else:
                            unmatched_feedback.append(feedback)
                    else:
                        unmatched_feedback.append(feedback)

                self.stdout.write(
                    self.style.SUCCESS(f"Matched {matched_count} feedback entries to existing events")
                )

                if unmatched_feedback:
                    self.stdout.write(
                        self.style.WARNING(
                            f"{len(unmatched_feedback)} feedback entries could not be matched to existing events"
                        )
                    )
                    self.stdout.write("Consider running with --create-legacy-event to handle these")

        # Show final status
        remaining_unlinked = Feedback.objects.filter(event__isnull=True).count()
        self.stdout.write(f"Remaining unlinked feedback: {remaining_unlinked}")

        if remaining_unlinked == 0:
            self.stdout.write(self.style.SUCCESS("All feedback is now linked to events!"))