from django.shortcuts import render, redirect, get_object_or_404
from django.views.generic import View, ListView, TemplateView, DetailView, CreateView
from django.contrib.auth.mixins import LoginRequiredMixin
from django.contrib.auth import authenticate, login, logout  # <-- AGREGAR logout
from django.contrib import messages
from django.http import JsonResponse, HttpResponse, Http404  # 🆕 AGREGAR Http404
from django.urls import reverse, reverse_lazy
from django.db.models import Count, Q
from django.utils import timezone
from django.core.files.base import ContentFile
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST

from dashboard.db_helper import DBHelper
from router_analytics.services import get_team_metrics, get_player_metrics
from clients.permissions import PermissionChecker
from router_sports.services import SportsDataService
from router_sports.models import Match, Team, Player, Division

# ==================== DASHBOARD ====================

class dashBoardView(LoginRequiredMixin, View):  # <-- AGREGAR LoginRequiredMixin
    template_name = 'dashboard/dashboard.html'
    login_url = '/'  # Redirige al login si no está autenticado

    def get(self, request):
        # 🆕 Crear checker y service
        checker = PermissionChecker(request.user)
        service = SportsDataService(checker)
        
        # 🆕 Obtener partidos permitidos (últimos 10)
        matches = service.get_accessible_matches(limit=10)
        
        # 🆕 Obtener equipos permitidos
        teams = service.get_accessible_teams()

        testeo = checker.can_view_team(1)
        
        # Métricas de jugador (solo si tiene permiso)
        datametricsplayer = None
        if checker.can_view_player(11):  # Player ID 11 como ejemplo
            # TODO: Implementar get_player_metrics desde router_analytics
            # datametricsplayer = get_player_metrics(player_id=11, metric_id=2)
            pass
        
        return render(request, self.template_name, {
            "testeo" : testeo,
            "matches": matches,
            "teams": teams,
            "datametricsplayer": datametricsplayer,
            "has_full_access": request.user.is_superuser
        })


class DivisionView(LoginRequiredMixin, TemplateView):
    """Vista para mostrar una división específica"""
    template_name = 'division.html'
    login_url = '/'
    
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        division_slug = self.kwargs.get('slug')
        
        # 🆕 Crear checker y service
        checker = PermissionChecker(self.request.user)
        service = SportsDataService(checker)
        
        # TODO: Obtener division_id desde el slug
        # division = Division.objects.using('tikistats_internal').get(name__iexact=division_slug)
        # division_id = division.id
        
        # 🆕 Verificar permiso
        # if not checker.can_view_division(division_id):
        #     raise Http404("Division not found or access denied")
        
        context['division_name'] = division_slug.replace('-', ' ').title()
        context['division_slug'] = division_slug
        
        return context

from django.shortcuts import render
from django.contrib.auth.decorators import login_required

@login_required
def sub17_view(request):
    """Vista para la división Sub17"""
    
    # 🆕 Crear checker y service
    checker = PermissionChecker(request.user)
    service = SportsDataService(checker)
    
    # Obtener división Sub17
    try:
        division = Division.objects.using('tikistats_internal').get(name__icontains='Sub-17')
        division_id = division.id
    except Division.DoesNotExist:
        raise Http404("División Sub-17 no encontrada")
    
    # 🆕 Verificar permiso
    if not checker.can_view_division(division_id):
        raise Http404("Division not found or access denied")
    
    # 🆕 Obtener partidos recientes de la división
    recent_matches = service.get_accessible_matches(limit=5, division_id=division_id)
    
    # 🆕 Obtener jugadores de equipos permitidos
    allowed_team_ids = checker.get_allowed_teams()
    
    if allowed_team_ids is None:
        # Superusuario → todos los jugadores de la división
        players = Player.objects.using('tikistats_internal').filter(
            team_division_players__team_division__division_id=division_id,
            team_division_players__state='active'
        ).distinct()
    elif allowed_team_ids:
        # Jugadores de equipos permitidos
        players = Player.objects.using('tikistats_internal').filter(
            team_division_players__team_division__team_id__in=allowed_team_ids,
            team_division_players__team_division__division_id=division_id,
            team_division_players__state='active'
        ).distinct()
    else:
        players = Player.objects.using('tikistats_internal').none()
    
    context = {
        'division_id': division_id,
        'division': division,
        'total_players': players.count(),
        'matches_played': recent_matches.count(),
        'win_rate': 67,  # TODO: Calcular desde DB
        'goals_scored': 42,  # TODO: Calcular desde DB
        'recent_matches': recent_matches,
        'players': players[:10]  # Top 10 jugadores
    }
    
    return render(request, 'dashboard/sub17.html', context)

@login_required
def matchs_view(request, division_id, match_id):
    """Vista para mostrar estadísticas detalladas de un partido"""
    
    # 🆕 Crear checker y service
    checker = PermissionChecker(request.user)
    service = SportsDataService(checker)
    
    # 🆕 Verificar permiso
    if not checker.can_view_match(match_id):
        raise Http404("Match not found or access denied")
    
    # 🆕 Obtener partido desde service (ya hace la query cross-DB)
    match = service.get_match(match_id)
    
    if not match:
        raise Http404("Match not found")
    
    # 🆕 Verificar depth (si puede ver métricas históricas)
    can_view_historic = checker.can_view_match(match_id, depth='historic')
    
    # TODO: Obtener estadísticas del partido desde router_analytics
    match_stats = None
    if can_view_historic:
        # match_stats = get_match_metrics(match_id)
        pass
    
    context = {
        'division_id': division_id,
        'match': match,
        'can_view_historic': can_view_historic,
        'match_stats': match_stats,
    }
    
    return render(request, 'dashboard/matchs.html', context)

@login_required
def team_detail(request, team_id):
    """Vista para mostrar detalle de un equipo"""
    
    # 🆕 Crear checker y service
    checker = PermissionChecker(request.user)
    service = SportsDataService(checker)
    
    # 🆕 Verificar permiso
    if not checker.can_view_team(team_id, depth='historic'):
        raise Http404("Team not found or access denied")
    
    # 🆕 Obtener equipo
    team = service.get_team(team_id)
    
    if not team:
        raise Http404("Team not found")
    
    # 🆕 Obtener últimos partidos del equipo
    recent_matches = service.get_matches_by_team(team_id, limit=10)
    
    # 🆕 Obtener jugadores del equipo
    players = service.get_players_by_team(team_id)
    
    # 🆕 Obtener estadísticas (solo si tiene permiso historic)
    team_stats = None
    if checker.can_view_team(team_id, depth='historic'):
        team_stats = service.get_team_stats(team_id)
    
    context = {
        'team': team,
        'recent_matches': recent_matches,
        'players': players,
        'team_stats': team_stats,
        'can_view_historic': True,
    }
    
    return render(request, 'dashboard/team_detail.html', context)