"""
Commande pour seeder les types d'evenements.
Ajoute uniquement les types qui n'existent pas encore.

Usage:
    python manage.py seed_event_types
    python manage.py seed_event_types --with-translations
"""
from django.core.management.base import BaseCommand
from apps.news.models import EventType
from traduction.models import Language, Dictionnaire
from django.contrib.contenttypes.models import ContentType


EVENT_TYPES = [
    {
        'name': 'Conference',
        'slug': 'conference',
        'description': 'Presentations et discussions academiques sur des sujets specifiques',
        'color': '#3B82F6',
        'order': 1,
        'translations': {
            'en': {
                'name': 'Conference',
                'description': 'Academic presentations and discussions on specific topics',
            }
        }
    },
    {
        'name': 'Seminaire',
        'slug': 'seminaire',
        'description': 'Sessions de travail approfondies sur des thematiques de recherche',
        'color': '#8B5CF6',
        'order': 2,
        'translations': {
            'en': {
                'name': 'Seminar',
                'description': 'In-depth working sessions on research topics',
            }
        }
    },
    {
        'name': 'Atelier',
        'slug': 'atelier',
        'description': 'Sessions pratiques et interactives',
        'color': '#10B981',
        'order': 3,
        'translations': {
            'en': {
                'name': 'Workshop',
                'description': 'Practical and interactive sessions',
            }
        }
    },
    {
        'name': 'Soutenance',
        'slug': 'soutenance',
        'description': 'Presentation et defense de memoire ou these',
        'color': '#F59E0B',
        'order': 4,
        'translations': {
            'en': {
                'name': 'Thesis Defense',
                'description': 'Presentation and defense of thesis or dissertation',
            }
        }
    },
    {
        'name': 'Cours magistral',
        'slug': 'cours-magistral',
        'description': 'Cours academique ouvert au public',
        'color': '#6366F1',
        'order': 5,
        'translations': {
            'en': {
                'name': 'Lecture',
                'description': 'Academic course open to the public',
            }
        }
    },
    {
        'name': 'Webinaire',
        'slug': 'webinaire',
        'description': 'Evenement en ligne interactif',
        'color': '#EC4899',
        'order': 6,
        'translations': {
            'en': {
                'name': 'Webinar',
                'description': 'Interactive online event',
            }
        }
    },
    {
        'name': 'Journee portes ouvertes',
        'slug': 'journee-portes-ouvertes',
        'description': 'Visite du campus et presentation du programme',
        'color': '#14B8A6',
        'order': 7,
        'translations': {
            'en': {
                'name': 'Open Day',
                'description': 'Campus visit and program presentation',
            }
        }
    },
    {
        'name': 'Ceremonie',
        'slug': 'ceremonie',
        'description': 'Remise de diplomes, inaugurations et evenements officiels',
        'color': '#EF4444',
        'order': 8,
        'translations': {
            'en': {
                'name': 'Ceremony',
                'description': 'Graduation ceremonies, inaugurations and official events',
            }
        }
    },
    {
        'name': 'Networking',
        'slug': 'networking',
        'description': 'Evenements de mise en relation professionnelle',
        'color': '#F97316',
        'order': 9,
        'translations': {
            'en': {
                'name': 'Networking',
                'description': 'Professional networking events',
            }
        }
    },
    {
        'name': 'Colloque',
        'slug': 'colloque',
        'description': 'Reunion de specialistes pour debattre de questions scientifiques',
        'color': '#0EA5E9',
        'order': 10,
        'translations': {
            'en': {
                'name': 'Symposium',
                'description': 'Meeting of specialists to discuss scientific questions',
            }
        }
    },
    {
        'name': 'Hackathon',
        'slug': 'hackathon',
        'description': 'Competition de developpement et d\'innovation',
        'color': '#84CC16',
        'order': 11,
        'translations': {
            'en': {
                'name': 'Hackathon',
                'description': 'Development and innovation competition',
            }
        }
    },
    {
        'name': 'Summer School',
        'slug': 'summer-school',
        'description': 'Programme intensif de formation estivale',
        'color': '#FBBF24',
        'order': 12,
        'translations': {
            'en': {
                'name': 'Summer School',
                'description': 'Intensive summer training program',
            }
        }
    },
]


class Command(BaseCommand):
    help = 'Seed les types d\'evenements (ajoute uniquement les manquants)'

    def add_arguments(self, parser):
        parser.add_argument(
            '--with-translations',
            action='store_true',
            help='Ajoute aussi les traductions anglaises',
        )
        parser.add_argument(
            '--force-translations',
            action='store_true',
            help='Met a jour les traductions meme si elles existent',
        )

    def handle(self, *args, **options):
        with_translations = options['with_translations']
        force_translations = options['force_translations']

        created_count = 0
        updated_count = 0
        skipped_count = 0
        translation_count = 0

        existing_slugs = set(EventType.objects.values_list('slug', flat=True))

        for data in EVENT_TYPES:
            slug = data['slug']
            translations = data.pop('translations', {})

            if slug in existing_slugs:
                # Mettre a jour les traductions si demande
                if with_translations or force_translations:
                    event_type = EventType.objects.get(slug=slug)
                    t_count = self._add_translations(event_type, translations, force_translations)
                    translation_count += t_count
                    if t_count > 0:
                        updated_count += 1
                else:
                    skipped_count += 1
                self.stdout.write(f'  [SKIP] {data["name"]} (existe deja)')
            else:
                event_type = EventType.objects.create(**data)
                created_count += 1
                self.stdout.write(self.style.SUCCESS(f'  [NEW] {data["name"]}'))

                if with_translations:
                    t_count = self._add_translations(event_type, translations, force=True)
                    translation_count += t_count

        self.stdout.write('')
        self.stdout.write(self.style.SUCCESS(f'Termine: {created_count} crees, {updated_count} mis a jour, {skipped_count} ignores'))
        if with_translations or force_translations:
            self.stdout.write(self.style.SUCCESS(f'Traductions: {translation_count} ajoutees/mises a jour'))

    def _add_translations(self, event_type, translations, force=False):
        """Ajoute les traductions pour un EventType"""
        count = 0
        content_type = ContentType.objects.get_for_model(EventType)

        for lang_code, fields in translations.items():
            try:
                language = Language.objects.get(code=lang_code, is_active=True)
            except Language.DoesNotExist:
                self.stdout.write(self.style.WARNING(f'    Langue {lang_code} non trouvee'))
                continue

            for field_name, translation_text in fields.items():
                if force:
                    Dictionnaire.objects.update_or_create(
                        content_type=content_type,
                        object_id=event_type.pk,
                        field=field_name,
                        language=language,
                        defaults={'translation': translation_text}
                    )
                    count += 1
                else:
                    _, created = Dictionnaire.objects.get_or_create(
                        content_type=content_type,
                        object_id=event_type.pk,
                        field=field_name,
                        language=language,
                        defaults={'translation': translation_text}
                    )
                    if created:
                        count += 1

        return count