"""
Physicians Console UI views - Server-rendered templates for physician management
"""
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator
from django.db.models import Avg, Count, Q
from django.shortcuts import get_object_or_404, render
from django.utils import timezone

from apps.organizations.models import Department, Hospital, Staff

from .models import PhysicianMonthlyRating


@login_required
def physician_list(request):
    """
    Physicians list view with filters.

    Features:
    - Server-side pagination
    - Filters (hospital, department, specialization, status)
    - Search by name or license number
    - Current month rating display
    """
    # Base queryset with optimizations
    queryset = Staff.objects.select_related('hospital', 'department')

    # Apply RBAC filters
    user = request.user
    if user.is_px_admin():
        pass  # See all
    elif user.hospital:
        queryset = queryset.filter(hospital=user.hospital)
    else:
        queryset = queryset.none()

    # Apply filters
    hospital_filter = request.GET.get('hospital')
    if hospital_filter:
        queryset = queryset.filter(hospital_id=hospital_filter)

    department_filter = request.GET.get('department')
    if department_filter:
        queryset = queryset.filter(department_id=department_filter)

    specialization_filter = request.GET.get('specialization')
    if specialization_filter:
        queryset = queryset.filter(specialization__icontains=specialization_filter)

    status_filter = request.GET.get('status', 'active')
    if status_filter:
        queryset = queryset.filter(status=status_filter)

    # Search
    search_query = request.GET.get('search')
    if search_query:
        queryset = queryset.filter(
            Q(first_name__icontains=search_query) |
            Q(last_name__icontains=search_query) |
            Q(license_number__icontains=search_query) |
            Q(specialization__icontains=search_query)
        )

    # Ordering
    order_by = request.GET.get('order_by', 'last_name')
    queryset = queryset.order_by(order_by)

    # Pagination
    page_size = int(request.GET.get('page_size', 25))
    paginator = Paginator(queryset, page_size)
    page_number = request.GET.get('page', 1)
    page_obj = paginator.get_page(page_number)

    # Get current month ratings for displayed physicians
    now = timezone.now()
    physician_ids = [p.id for p in page_obj.object_list]
    current_ratings = PhysicianMonthlyRating.objects.filter(
        staff_id__in=physician_ids,
        year=now.year,
        month=now.month
    ).select_related('staff')

    # Create rating lookup
    ratings_dict = {r.staff_id: r for r in current_ratings}

    # Attach ratings to physicians
    for physician in page_obj.object_list:
        physician.current_rating = ratings_dict.get(physician.id)

    # Get filter options
    hospitals = Hospital.objects.filter(status='active')
    if not user.is_px_admin() and user.hospital:
        hospitals = hospitals.filter(id=user.hospital.id)

    departments = Department.objects.filter(status='active')
    if not user.is_px_admin() and user.hospital:
        departments = departments.filter(hospital=user.hospital)

    # Get unique specializations
    specializations = Staff.objects.values_list('specialization', flat=True).distinct().order_by('specialization')

    # Statistics
    stats = {
        'total': queryset.count(),
        'active': queryset.filter(status='active').count(),
    }

    context = {
        'page_obj': page_obj,
        'physicians': page_obj.object_list,
        'stats': stats,
        'hospitals': hospitals,
        'departments': departments,
        'specializations': specializations,
        'filters': request.GET,
        'current_year': now.year,
        'current_month': now.month,
    }

    return render(request, 'physicians/physician_list.html', context)


@login_required
def physician_detail(request, pk):
    """
    Physician detail view with performance metrics.

    Features:
    - Full physician details
    - Current month rating
    - Year-to-date performance
    - Monthly ratings history (last 12 months)
    - Performance trends
    """
    physician = get_object_or_404(
        Staff.objects.select_related('hospital', 'department'),
        pk=pk
    )

    # Check permission
    user = request.user
    if not user.is_px_admin() and user.hospital:
        if physician.hospital != user.hospital:
            from django.http import Http404
            raise Http404("Physician not found")

    now = timezone.now()
    current_year = now.year
    current_month = now.month

    # Get current month rating
    current_month_rating = PhysicianMonthlyRating.objects.filter(
        staff=physician,
        year=current_year,
        month=current_month
    ).first()

    # Get previous month rating
    prev_month = current_month - 1 if current_month > 1 else 12
    prev_year = current_year if current_month > 1 else current_year - 1
    previous_month_rating = PhysicianMonthlyRating.objects.filter(
        staff=physician,
        year=prev_year,
        month=prev_month
    ).first()

    # Get year-to-date stats
    ytd_ratings = PhysicianMonthlyRating.objects.filter(
        staff=physician,
        year=current_year
    )

    ytd_stats = ytd_ratings.aggregate(
        avg_rating=Avg('average_rating'),
        total_surveys=Count('id')
    )

    # Get last 12 months ratings
    ratings_history = PhysicianMonthlyRating.objects.filter(
        staff=physician
    ).order_by('-year', '-month')[:12]

    # Get best and worst months from all ratings (not just last 12 months)
    all_ratings = PhysicianMonthlyRating.objects.filter(staff=physician)
    best_month = all_ratings.order_by('-average_rating').first()
    worst_month = all_ratings.order_by('average_rating').first()

    # Determine trend
    trend = 'stable'
    trend_percentage = 0
    if current_month_rating and previous_month_rating:
        diff = float(current_month_rating.average_rating - previous_month_rating.average_rating)
        if previous_month_rating.average_rating > 0:
            trend_percentage = (diff / float(previous_month_rating.average_rating)) * 100

        if diff > 0.1:
            trend = 'improving'
        elif diff < -0.1:
            trend = 'declining'

    context = {
        'physician': physician,
        'current_month_rating': current_month_rating,
        'previous_month_rating': previous_month_rating,
        'ytd_average': ytd_stats['avg_rating'],
        'ytd_surveys': ytd_stats['total_surveys'],
        'ratings_history': ratings_history,
        'best_month': best_month,
        'worst_month': worst_month,
        'trend': trend,
        'trend_percentage': abs(trend_percentage),
        'current_year': current_year,
        'current_month': current_month,
    }

    return render(request, 'physicians/physician_detail.html', context)


@login_required
def leaderboard(request):
    """
    Physician leaderboard view.

    Features:
    - Top-rated physicians for selected period
    - Filters (hospital, department, month/year)
    - Ranking with trends
    - Performance distribution
    """
    # Get parameters
    now = timezone.now()
    year = int(request.GET.get('year', now.year))
    month = int(request.GET.get('month', now.month))
    hospital_filter = request.GET.get('hospital')
    department_filter = request.GET.get('department')
    limit = int(request.GET.get('limit', 20))

    # Build queryset
    queryset = PhysicianMonthlyRating.objects.filter(
        year=year,
        month=month
    ).select_related('staff', 'staff__hospital', 'staff__department')

    # Apply RBAC filters
    user = request.user
    if not user.is_px_admin() and user.hospital:
        queryset = queryset.filter(staff__hospital=user.hospital)

    # Apply filters
    if hospital_filter:
        queryset = queryset.filter(staff__hospital_id=hospital_filter)

    if department_filter:
        queryset = queryset.filter(staff__department_id=department_filter)

    # Order by rating
    queryset = queryset.order_by('-average_rating')[:limit]

    # Get previous month for trend
    prev_month = month - 1 if month > 1 else 12
    prev_year = year if month > 1 else year - 1

    # Build leaderboard with trends
    leaderboard = []
    for rank, rating in enumerate(queryset, start=1):
        # Get previous month rating for trend
        prev_rating = PhysicianMonthlyRating.objects.filter(
            staff=rating.staff,
            year=prev_year,
            month=prev_month
        ).first()

        trend = 'stable'
        trend_value = 0
        if prev_rating:
            diff = float(rating.average_rating - prev_rating.average_rating)
            trend_value = diff
            if diff > 0.1:
                trend = 'up'
            elif diff < -0.1:
                trend = 'down'

        leaderboard.append({
            'rank': rank,
            'rating': rating,
            'physician': rating.staff,
            'trend': trend,
            'trend_value': trend_value,
            'prev_rating': prev_rating
        })

    # Get filter options
    hospitals = Hospital.objects.filter(status='active')
    if not user.is_px_admin() and user.hospital:
        hospitals = hospitals.filter(id=user.hospital.id)

    departments = Department.objects.filter(status='active')
    if not user.is_px_admin() and user.hospital:
        departments = departments.filter(hospital=user.hospital)

    # Calculate statistics
    all_ratings = PhysicianMonthlyRating.objects.filter(year=year, month=month)
    if not user.is_px_admin() and user.hospital:
        all_ratings = all_ratings.filter(staff__hospital=user.hospital)

    stats = all_ratings.aggregate(
        total_physicians=Count('id'),
        average_rating=Avg('average_rating'),
        total_surveys=Count('total_surveys')
    )

    # Distribution
    excellent = all_ratings.filter(average_rating__gte=4.5).count()
    good = all_ratings.filter(average_rating__gte=3.5, average_rating__lt=4.5).count()
    average = all_ratings.filter(average_rating__gte=2.5, average_rating__lt=3.5).count()
    poor = all_ratings.filter(average_rating__lt=2.5).count()

    context = {
        'leaderboard': leaderboard,
        'year': year,
        'month': month,
        'hospitals': hospitals,
        'departments': departments,
        'filters': request.GET,
        'stats': stats,
        'distribution': {
            'excellent': excellent,
            'good': good,
            'average': average,
            'poor': poor
        }
    }

    return render(request, 'physicians/leaderboard.html', context)


@login_required
def ratings_list(request):
    """
    Monthly ratings list view with filters.

    Features:
    - All monthly ratings
    - Filters (physician, hospital, department, year, month)
    - Search by physician name
    - Pagination
    """
    # Base queryset
    queryset = PhysicianMonthlyRating.objects.select_related(
        'staff', 'staff__hospital', 'staff__department'
    )

    # Apply RBAC filters
    user = request.user
    if not user.is_px_admin() and user.hospital:
        queryset = queryset.filter(staff__hospital=user.hospital)

    # Apply filters
    physician_filter = request.GET.get('physician')
    if physician_filter:
        queryset = queryset.filter(staff_id=physician_filter)

    hospital_filter = request.GET.get('hospital')
    if hospital_filter:
        queryset = queryset.filter(staff__hospital_id=hospital_filter)

    department_filter = request.GET.get('department')
    if department_filter:
        queryset = queryset.filter(staff__department_id=department_filter)

    year_filter = request.GET.get('year')
    if year_filter:
        queryset = queryset.filter(year=int(year_filter))

    month_filter = request.GET.get('month')
    if month_filter:
        queryset = queryset.filter(month=int(month_filter))

    # Search
    search_query = request.GET.get('search')
    if search_query:
        queryset = queryset.filter(
            Q(staff__first_name__icontains=search_query) |
            Q(staff__last_name__icontains=search_query) |
            Q(staff__license_number__icontains=search_query)
        )

    # Ordering
    order_by = request.GET.get('order_by', '-year,-month,-average_rating')
    queryset = queryset.order_by(*order_by.split(','))

    # Pagination
    page_size = int(request.GET.get('page_size', 25))
    paginator = Paginator(queryset, page_size)
    page_number = request.GET.get('page', 1)
    page_obj = paginator.get_page(page_number)

    # Get filter options
    hospitals = Hospital.objects.filter(status='active')
    if not user.is_px_admin() and user.hospital:
        hospitals = hospitals.filter(id=user.hospital.id)

    departments = Department.objects.filter(status='active')
    if not user.is_px_admin() and user.hospital:
        departments = departments.filter(hospital=user.hospital)

    # Get available years
    years = PhysicianMonthlyRating.objects.values_list('year', flat=True).distinct().order_by('-year')

    context = {
        'page_obj': page_obj,
        'ratings': page_obj.object_list,
        'hospitals': hospitals,
        'departments': departments,
        'years': years,
        'filters': request.GET,
    }

    return render(request, 'physicians/ratings_list.html', context)


@login_required
def specialization_overview(request):
    """
    Specialization overview - aggregated ratings by specialization.

    Features:
    - Average rating per specialization
    - Total physicians per specialization
    - Total surveys per specialization
    - Drill-down to physicians in specialization
    """
    # Get parameters
    now = timezone.now()
    year = int(request.GET.get('year', now.year))
    month = int(request.GET.get('month', now.month))
    hospital_filter = request.GET.get('hospital')

    # Base queryset
    queryset = PhysicianMonthlyRating.objects.filter(
        year=year,
        month=month
    ).select_related('staff', 'staff__hospital', 'staff__department')

    # Apply RBAC filters
    user = request.user
    if not user.is_px_admin() and user.hospital:
        queryset = queryset.filter(staff__hospital=user.hospital)

    # Apply filters
    if hospital_filter:
        queryset = queryset.filter(staff__hospital_id=hospital_filter)

    # Aggregate by specialization
    from django.db.models import Avg, Count, Sum

    specialization_data = {}
    for rating in queryset:
        spec = rating.staff.specialization
        if spec not in specialization_data:
            specialization_data[spec] = {
                'specialization': spec,
                'physicians': [],
                'total_physicians': 0,
                'total_surveys': 0,
                'total_positive': 0,
                'total_neutral': 0,
                'total_negative': 0,
                'ratings_sum': 0,
            }

        specialization_data[spec]['physicians'].append(rating)
        specialization_data[spec]['total_physicians'] += 1
        specialization_data[spec]['total_surveys'] += rating.total_surveys
        specialization_data[spec]['total_positive'] += rating.positive_count
        specialization_data[spec]['total_neutral'] += rating.neutral_count
        specialization_data[spec]['total_negative'] += rating.negative_count
        specialization_data[spec]['ratings_sum'] += float(rating.average_rating)

    # Calculate averages
    specializations = []
    for spec, data in specialization_data.items():
        avg_rating = data['ratings_sum'] / data['total_physicians'] if data['total_physicians'] > 0 else 0
        specializations.append({
            'specialization': spec,
            'total_physicians': data['total_physicians'],
            'average_rating': round(avg_rating, 2),
            'total_surveys': data['total_surveys'],
            'positive_count': data['total_positive'],
            'neutral_count': data['total_neutral'],
            'negative_count': data['total_negative'],
            'physicians': sorted(data['physicians'], key=lambda x: x.average_rating, reverse=True)
        })

    # Sort by average rating
    specializations.sort(key=lambda x: x['average_rating'], reverse=True)

    # Get filter options
    hospitals = Hospital.objects.filter(status='active')
    if not user.is_px_admin() and user.hospital:
        hospitals = hospitals.filter(id=user.hospital.id)

    context = {
        'specializations': specializations,
        'year': year,
        'month': month,
        'hospitals': hospitals,
        'filters': request.GET,
    }

    return render(request, 'physicians/specialization_overview.html', context)


@login_required
def department_overview(request):
    """
    Department overview - aggregated ratings by department.

    Features:
    - Average rating per department
    - Total physicians per department
    - Total surveys per department
    - Drill-down to physicians in department
    """
    # Get parameters
    now = timezone.now()
    year = int(request.GET.get('year', now.year))
    month = int(request.GET.get('month', now.month))
    hospital_filter = request.GET.get('hospital')

    # Base queryset
    queryset = PhysicianMonthlyRating.objects.filter(
        year=year,
        month=month
    ).select_related('staff', 'staff__hospital', 'staff__department')

    # Apply RBAC filters
    user = request.user
    if not user.is_px_admin() and user.hospital:
        queryset = queryset.filter(staff__hospital=user.hospital)

    # Apply filters
    if hospital_filter:
        queryset = queryset.filter(staff__hospital_id=hospital_filter)

    # Aggregate by department
    from django.db.models import Avg, Count, Sum

    department_data = {}
    for rating in queryset:
        dept = rating.staff.department
        if not dept:
            continue

        dept_key = str(dept.id)
        if dept_key not in department_data:
            department_data[dept_key] = {
                'department': dept,
                'physicians': [],
                'total_physicians': 0,
                'total_surveys': 0,
                'total_positive': 0,
                'total_neutral': 0,
                'total_negative': 0,
                'ratings_sum': 0,
            }

        department_data[dept_key]['physicians'].append(rating)
        department_data[dept_key]['total_physicians'] += 1
        department_data[dept_key]['total_surveys'] += rating.total_surveys
        department_data[dept_key]['total_positive'] += rating.positive_count
        department_data[dept_key]['total_neutral'] += rating.neutral_count
        department_data[dept_key]['total_negative'] += rating.negative_count
        department_data[dept_key]['ratings_sum'] += float(rating.average_rating)

    # Calculate averages
    departments = []
    for dept_key, data in department_data.items():
        avg_rating = data['ratings_sum'] / data['total_physicians'] if data['total_physicians'] > 0 else 0
        departments.append({
            'department': data['department'],
            'total_physicians': data['total_physicians'],
            'average_rating': round(avg_rating, 2),
            'total_surveys': data['total_surveys'],
            'positive_count': data['total_positive'],
            'neutral_count': data['total_neutral'],
            'negative_count': data['total_negative'],
            'physicians': sorted(data['physicians'], key=lambda x: x.average_rating, reverse=True)
        })

    # Sort by average rating
    departments.sort(key=lambda x: x['average_rating'], reverse=True)

    # Get filter options
    hospitals = Hospital.objects.filter(status='active')
    if not user.is_px_admin() and user.hospital:
        hospitals = hospitals.filter(id=user.hospital.id)

    context = {
        'departments': departments,
        'year': year,
        'month': month,
        'hospitals': hospitals,
        'filters': request.GET,
    }

    return render(request, 'physicians/department_overview.html', context)