from django.views.generic import ListView, DetailView
from django.http import JsonResponse
from django.views import View
from apps.core.views import CMSPageMixin, CMSObjectMixin
from traduction.helpers import prefetch_translations
from .models import University
from apps.core.models import UniversityMapSettings


class UniversityListView(CMSPageMixin, ListView):
    """
    Liste des universites partenaires.

    Utilise le template CMS si une page 'universites' existe.
    """
    model = University
    template_name = 'universities/list.html'
    context_object_name = 'universities'
    cms_page_slug = 'universites'

    def get_language_code(self):
        return getattr(self.request, 'current_language_code', 'fr')

    def get_queryset(self):
        return University.objects.filter(is_active=True).select_related(
            'country'
        ).prefetch_related(
            'departments', 'statistics', 'statistics__stat_type', 'industrial_partners'
        )

    def get_context_data(self, **kwargs):
        # Charger la page CMS
        self._cms_page = self.get_cms_page()
        context = super().get_context_data(**kwargs)
        language_code = self.get_language_code()

        # Ajouter la page CMS au contexte
        if self._cms_page:
            context['page'] = self._cms_page
            context['cms_page'] = self._cms_page

        # Traduire les universites
        universities = list(self.get_queryset())
        prefetch_translations(universities, language_code=language_code)

        # Traduire les pays lies
        countries = [u.country for u in universities if u.country]
        if countries:
            unique_countries = list({c.pk: c for c in countries}.values())
            prefetch_translations(unique_countries, language_code=language_code)
            country_map = {c.pk: c for c in unique_countries}
            for uni in universities:
                if uni.country and uni.country.pk in country_map:
                    uni.country = country_map[uni.country.pk]

        context['universities'] = universities
        context['map_settings'] = UniversityMapSettings.get_settings()
        return context


class UniversityMapDataView(View):
    """API endpoint pour recuperer les donnees des universites pour la carte"""

    def get(self, request):
        language_code = getattr(request, 'current_language_code', 'fr')

        universities = list(University.objects.filter(
            is_active=True,
            latitude__isnull=False,
            longitude__isnull=False
        ).select_related('country'))

        # Appliquer les traductions
        prefetch_translations(universities, language_code=language_code)

        # Traduire les pays
        countries = [u.country for u in universities if u.country]
        if countries:
            unique_countries = list({c.pk: c for c in countries}.values())
            prefetch_translations(unique_countries, language_code=language_code)
            country_map = {c.pk: c for c in unique_countries}
            for uni in universities:
                if uni.country and uni.country.pk in country_map:
                    uni.country = country_map[uni.country.pk]

        data = []
        for uni in universities:
            data.append({
                'id': uni.id,
                'name': uni.name,  # Deja traduit via prefetch
                'slug': uni.slug,
                'city': uni.city,
                'country': str(uni.country) if uni.country else '',
                'latitude': float(uni.latitude),
                'longitude': float(uni.longitude),
                'is_coordinator': uni.is_coordinator,
                'logo_url': uni.logo.url if uni.logo else None,
                'url': f'/universites/{uni.slug}/',
                'abbreviation': uni.abbreviation or '',
            })

        # Recuperer les parametres de la carte
        settings = UniversityMapSettings.get_settings()

        return JsonResponse({
            'universities': data,
            'settings': {
                'tile_url': settings.get_tile_url(),
                'attribution': settings.get_attribution(),
                'center': [float(settings.center_latitude), float(settings.center_longitude)],
                'zoom': settings.default_zoom,
                'marker_color': settings.marker_color,
                'coordinator_marker_color': settings.coordinator_marker_color,
            }
        })


class UniversityDetailView(DetailView):
    model = University
    template_name = 'universities/detail.html'
    context_object_name = 'university'

    def get_language_code(self):
        return getattr(self.request, 'current_language_code', 'fr')

    def get_queryset(self):
        return University.objects.filter(is_active=True).select_related(
            'country'
        ).prefetch_related(
            'departments', 'statistics', 'statistics__stat_type', 'industrial_partners'
        )

    def get_object(self, queryset=None):
        obj = super().get_object(queryset)
        language_code = self.get_language_code()

        # Traduire l'universite
        prefetch_translations([obj], language_code=language_code)

        # Traduire le pays
        if obj.country:
            prefetch_translations([obj.country], language_code=language_code)

        # Traduire les departements
        departments = list(obj.departments.all())
        if departments:
            prefetch_translations(departments, language_code=language_code)

        # Traduire les partenaires industriels
        partners = list(obj.industrial_partners.all())
        if partners:
            prefetch_translations(partners, language_code=language_code)

        # Traduire les types de statistiques
        stat_types = [s.stat_type for s in obj.statistics.all() if s.stat_type]
        if stat_types:
            unique_types = list({t.pk: t for t in stat_types}.values())
            prefetch_translations(unique_types, language_code=language_code)

        return obj

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        language_code = self.get_language_code()

        # Ajouter les membres de l'equipe de cette universite
        from apps.team.models import Person
        team_members = list(Person.objects.filter(
            university=self.object,
            is_active=True
        ).select_related('professor', 'phd_student', 'master_student')[:6])
        prefetch_translations(team_members, language_code=language_code)
        context['team_members'] = team_members

        return context