hospital-management/hr/views.py

"""
HR app views with comprehensive CRUD operations following healthcare best practices.
"""

from django.shortcuts import render, get_object_or_404, redirect
from django.contrib.auth.decorators import login_required
from django.views.decorators.http import require_POST, require_GET, require_http_methods
from django.template.loader import render_to_string
from django.contrib.auth.mixins import LoginRequiredMixin
from django.contrib import messages
from django.views.generic import (
    ListView, DetailView, CreateView, UpdateView, DeleteView, TemplateView
)
from django.urls import reverse_lazy, reverse
from django.http import JsonResponse, HttpResponse
from django.db.models import Q, Count, Avg, Sum
from django.utils import timezone
from django.core.paginator import Paginator
from django.db import transaction
from datetime import datetime, timedelta, date
import json
from accounts.models import User
from .models import (
    Employee, Department, Schedule, ScheduleAssignment,
    TimeEntry, PerformanceReview, TrainingPrograms, TrainingSession, 
    TrainingRecord, ProgramModule, ProgramPrerequisite,
    TrainingAttendance, TrainingAssessment, TrainingCertificates
)
from .forms import (
    EmployeeForm, DepartmentForm, ScheduleForm, ScheduleAssignmentForm,
    TimeEntryForm, PerformanceReviewForm, TrainingRecordForm, TrainingSessionForm, TrainingProgramForm
)
from core.utils import AuditLogger



class HRDashboardView(LoginRequiredMixin, TemplateView):
    """
    Main HR dashboard with comprehensive statistics and recent activity.
    """
    template_name = 'hr/dashboard.html'
    
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        
        # Basic statistics
        context.update({
            'total_employees': Employee.objects.filter(tenant=self.request.user.tenant).count(),
            'active_employees': Employee.objects.filter(
                tenant=self.request.user.tenant,
                employment_status='ACTIVE'
            ).count(),
            'departments': Department.objects.filter(tenant=self.request.user.tenant),
            'pending_reviews': PerformanceReview.objects.filter(
                employee__tenant=self.request.user.tenant,
                status='PENDING'
            ).count(),
        })
        
        # Recent activity
        context.update({
            'recent_hires': Employee.objects.filter(
                tenant=self.request.user.tenant,
                hire_date__gte=timezone.now().date() - timedelta(days=30)
            ).order_by('-hire_date')[:5],
            
            'recent_reviews': PerformanceReview.objects.filter(
                employee__tenant=self.request.user.tenant
            ).order_by('-review_date')[:5],
            
            'recent_training': TrainingRecord.objects.filter(
                employee__tenant=self.request.user.tenant
            ).order_by('-completion_date')[:5],
        })
        
        # Attendance statistics
        today = timezone.now().date()
        context.update({
            'employees_clocked_in': TimeEntry.objects.filter(
                employee__tenant=self.request.user.tenant,
                clock_in_time__date=today,
                clock_out_time__isnull=True
            ).count(),
            
            'total_hours_today': TimeEntry.objects.filter(
                employee__tenant=self.request.user.tenant,
                clock_in_time__date=today,
                clock_out_time__isnull=False
            ).aggregate(
                total=Sum('total_hours')
            )['total'] or 0,
        })
        
        return context


class EmployeeListView(LoginRequiredMixin, ListView):
    """
    List all employees with filtering and search capabilities.
    """
    model = Employee
    template_name = 'hr/employees/employee_list.html'
    context_object_name = 'employees'
    paginate_by = 20
    
    def get_queryset(self):
        queryset = Employee.objects.filter(tenant=self.request.user.tenant)
        
        # Search functionality
        search = self.request.GET.get('search')
        if search:
            queryset = queryset.filter(
                Q(first_name__icontains=search) |
                Q(last_name__icontains=search) |
                Q(employee_id__icontains=search) |
                Q(email__icontains=search)
            )
        
        # Filter by department
        department = self.request.GET.get('department')
        if department:
            queryset = queryset.filter(department_id=department)
        
        # Filter by employment status
        status = self.request.GET.get('status')
        if status:
            queryset = queryset.filter(employment_status=status)
        
        # Filter by position
        position = self.request.GET.get('position')
        if position:
            queryset = queryset.filter(job_title__icontains=position)
        
        return queryset.select_related('department').order_by('last_name', 'first_name')
    
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['departments'] = Department.objects.filter(
            tenant=self.request.user.tenant
        ).order_by('name')
        context['search'] = self.request.GET.get('search', '')
        context['selected_department'] = self.request.GET.get('department', '')
        context['selected_status'] = self.request.GET.get('status', '')
        context['selected_position'] = self.request.GET.get('position', '')
        return context


class EmployeeDetailView(LoginRequiredMixin, DetailView):
    """
    Display detailed information about a specific employee.
    """
    model = Employee
    template_name = 'hr/employees/employee_detail.html'
    context_object_name = 'employee'
    
    def get_queryset(self):
        return Employee.objects.filter(tenant=self.request.user.tenant)
    
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        employee = self.get_object()
        
        # Recent time entries
        context['recent_time_entries'] = TimeEntry.objects.filter(
            employee=employee
        ).order_by('-clock_in_time')[:10]
        
        # Recent performance reviews
        context['recent_reviews'] = PerformanceReview.objects.filter(
            employee=employee
        ).order_by('-review_date')[:5]
        
        # Training records
        context['training_records'] = TrainingRecord.objects.filter(
            employee=employee
        ).order_by('-completion_date')[:10]
        
        # Schedule assignments
        context['current_schedules'] = Schedule.objects.filter(
            employee=employee,
            effective_date__lte=timezone.now().date(),
            end_date__gte=timezone.now().date() if Schedule.end_date else True
        )
        
        return context


class EmployeeCreateView(LoginRequiredMixin, CreateView):
    """
    Create a new employee record.
    """
    model = Employee
    form_class = EmployeeForm
    template_name = 'hr/employees/employee_form.html'
    success_url = reverse_lazy('hr:employee_list')
    
    def form_valid(self, form):
        form.instance.tenant = self.request.user.tenant
        messages.success(self.request, 'Employee created successfully.')
        return super().form_valid(form)
    
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs


class EmployeeUpdateView(LoginRequiredMixin, UpdateView):
    """
    Update an existing employee record.
    """
    model = Employee
    form_class = EmployeeForm
    template_name = 'hr/employees/employee_form.html'
    
    def get_queryset(self):
        return Employee.objects.filter(tenant=self.request.user.tenant)
    
    def get_success_url(self):
        return reverse('hr:employee_detail', kwargs={'pk': self.object.pk})
    
    def form_valid(self, form):
        messages.success(self.request, 'Employee updated successfully.')
        return super().form_valid(form)
    
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs


class EmployeeDeleteView(LoginRequiredMixin, DeleteView):
    """
    Soft delete an employee record (healthcare compliance).
    """
    model = Employee
    template_name = 'hr/employees/employee_confirm_delete.html'
    success_url = reverse_lazy('hr:employee_list')
    
    def get_queryset(self):
        return Employee.objects.filter(tenant=self.request.user.tenant)
    
    def delete(self, request, *args, **kwargs):
        # Soft delete - mark as inactive instead of actual deletion
        employee = self.get_object()
        employee.employment_status = 'INACTIVE'
        employee.termination_date = timezone.now().date()
        employee.save()
        
        messages.success(request, f'Employee {employee.get_full_name()} has been deactivated.')
        return redirect(self.success_url)


class DepartmentListView(LoginRequiredMixin, ListView):
    """
    List all departments with employee counts.
    """
    model = Department
    template_name = 'hr/departments/department_list.html'
    context_object_name = 'departments'
    paginate_by = 20
    
    def get_queryset(self):
        queryset = Department.objects.filter(tenant=self.request.user.tenant)
        
        # Search functionality
        search = self.request.GET.get('search')
        if search:
            queryset = queryset.filter(
                Q(name__icontains=search) |
                Q(department_code__icontains=search) |
                Q(description__icontains=search)
            )
        
        return queryset


class DepartmentDetailView(LoginRequiredMixin, DetailView):
    """
    Display detailed information about a specific department.
    """
    model = Department
    template_name = 'hr/departments/department_detail.html'
    context_object_name = 'department'
    
    def get_queryset(self):
        return Department.objects.filter(tenant=self.request.user.tenant)
    
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        department = self.get_object()
        
        # Department employees
        context['employees'] = Employee.objects.filter(
            department=department
        ).order_by('last_name', 'first_name')

        
        # Department statistics
        context['active_employees'] = Employee.objects.filter(
            department=department,
            employment_status='ACTIVE'
        ).count()
        
        return context


class DepartmentCreateView(LoginRequiredMixin, CreateView):
    """
    Create a new department.
    """
    model = Department
    form_class = DepartmentForm
    template_name = 'hr/departments/department_form.html'
    success_url = reverse_lazy('hr:department_list')
    
    def form_valid(self, form):
        form.instance.tenant = self.request.user.tenant
        messages.success(self.request, 'Department created successfully.')
        return super().form_valid(form)
    
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs


class DepartmentUpdateView(LoginRequiredMixin, UpdateView):
    """
    Update an existing department.
    """
    model = Department
    form_class = DepartmentForm
    template_name = 'hr/departments/department_form.html'
    
    def get_queryset(self):
        return Department.objects.filter(tenant=self.request.user.tenant)
    
    def get_success_url(self):
        return reverse('hr:department_detail', kwargs={'pk': self.object.pk})
    
    def form_valid(self, form):
        messages.success(self.request, 'Department updated successfully.')
        return super().form_valid(form)
    
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs


class DepartmentDeleteView(LoginRequiredMixin, DeleteView):
    """
    Delete a department (only if no employees assigned).
    """
    model = Department
    template_name = 'hr/departments/department_confirm_delete.html'
    success_url = reverse_lazy('hr:department_list')
    
    def get_queryset(self):
        return Department.objects.filter(tenant=self.request.user.tenant)
    
    def delete(self, request, *args, **kwargs):
        department = self.get_object()
        
        # Check if department has employees
        if Employee.objects.filter(department=department).exists():
            messages.error(request, 'Cannot delete department with assigned employees.')
            return redirect('hr:department_detail', pk=department.pk)
        
        messages.success(request, f'Department {department.name} deleted successfully.')
        return super().delete(request, *args, **kwargs)


class ScheduleListView(LoginRequiredMixin, ListView):
    """
    List all schedules with filtering capabilities.
    """
    model = Schedule
    template_name = 'hr/schedules/schedule_list.html'
    context_object_name = 'schedules'
    paginate_by = 20
    
    def get_queryset(self):
        queryset = Schedule.objects.filter(employee__tenant=self.request.user.tenant)
        
        # Filter by status
        is_active = self.request.GET.get('is_active')
        if is_active:
            queryset = queryset.filter(is_active=(is_active == 'true'))
        
        # Filter by date range
        effective_date = self.request.GET.get('effective_date')
        end_date = self.request.GET.get('end_date')
        if effective_date:
            queryset = queryset.filter(effective_date__gte=effective_date)
        if end_date:
            queryset = queryset.filter(end_date__lte=end_date)
        
        return queryset.select_related('employee').order_by('-effective_date')


class ScheduleDetailView(LoginRequiredMixin, DetailView):
    """
    Display detailed information about a specific schedule.
    """
    model = Schedule
    template_name = 'hr/schedules/schedule_detail.html'
    context_object_name = 'schedule'
    
    def get_queryset(self):
        return Schedule.objects.filter(employee__tenant=self.request.user.tenant)
    
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        schedule = self.get_object()
        
        # Schedule assignments
        context['assignments'] = ScheduleAssignment.objects.filter(
            schedule=schedule
        ).order_by('assignment_date', 'start_time')
        
        return context


class ScheduleCreateView(LoginRequiredMixin, CreateView):
    """
    Create a new schedule.
    """
    model = Schedule
    form_class = ScheduleForm
    template_name = 'hr/schedules/schedule_form.html'
    success_url = reverse_lazy('hr:schedule_list')
    
    def form_valid(self, form):
        form.instance.created_by = self.request.user
        messages.success(self.request, 'Schedule created successfully.')
        return super().form_valid(form)
    
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs


class ScheduleUpdateView(LoginRequiredMixin, UpdateView):
    """
    Update an existing schedule (limited after publication).
    """
    model = Schedule
    form_class = ScheduleForm
    template_name = 'hr/schedules/schedule_form.html'
    
    def get_queryset(self):
        return Schedule.objects.filter(employee__tenant=self.request.user.tenant)
    
    def get_success_url(self):
        return reverse('hr:schedule_detail', kwargs={'pk': self.object.pk})
    
    def form_valid(self, form):
        messages.success(self.request, 'Schedule updated successfully.')
        return super().form_valid(form)
    
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs


class ScheduleAssignmentListView(LoginRequiredMixin, ListView):
    """
    List all schedule assignments with filtering capabilities.
    """
    model = ScheduleAssignment
    template_name = 'hr/assignments/schedule_assignment_list.html'
    context_object_name = 'assignments'
    paginate_by = 20
    
    def get_queryset(self):
        queryset = ScheduleAssignment.objects.filter(
            schedule__employee__tenant=self.request.user.tenant
        )
        
        # Filter by employee
        employee = self.request.GET.get('employee')
        if employee:
            queryset = queryset.filter(schedule__employee_id=employee)
        
        # Filter by date range
        start_date = self.request.GET.get('start_date')
        end_date = self.request.GET.get('end_date')
        if start_date:
            queryset = queryset.filter(assignment_date__gte=start_date)
        if end_date:
            queryset = queryset.filter(assignment_date__lte=end_date)
        
        # Filter by status
        status = self.request.GET.get('status')
        if status:
            queryset = queryset.filter(status=status)
        
        return queryset.select_related('schedule__employee', 'department').order_by('assignment_date', 'start_time')


class ScheduleAssignmentCreateView(LoginRequiredMixin, CreateView):
    """
    Create a new schedule assignment.
    """
    model = ScheduleAssignment
    form_class = ScheduleAssignmentForm
    template_name = 'hr/assignments/schedule_assignment_form.html'
    success_url = reverse_lazy('hr:schedule_assignment_list')
    
    def form_valid(self, form):
        messages.success(self.request, 'Schedule assignment created successfully.')
        return super().form_valid(form)
    
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs


class ScheduleAssignmentUpdateView(LoginRequiredMixin, UpdateView):
    """
    Update an existing schedule assignment.
    """
    model = ScheduleAssignment
    form_class = ScheduleAssignmentForm
    template_name = 'hr/assignments/schedule_assignment_form.html'
    success_url = reverse_lazy('hr:schedule_assignment_list')
    
    def get_queryset(self):
        return ScheduleAssignment.objects.filter(schedule__employee__tenant=self.request.user.tenant)
    
    def form_valid(self, form):
        messages.success(self.request, 'Schedule assignment updated successfully.')
        return super().form_valid(form)
    
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs


class ScheduleAssignmentDeleteView(LoginRequiredMixin, DeleteView):
    model = ScheduleAssignment
    template_name = 'hr/assignments/schedule_assignment_confirm_delete.html'
    success_url = reverse_lazy('hr:schedule_assignment_list')
    def get_queryset(self):
        queryset = ScheduleAssignment.objects.filter(schedule__employee__tenant=self.request.user.tenant)
        employee = self.request.GET.get('employee')
        if employee:
            queryset = queryset.filter(schedule__employee_id=employee)


class TimeEntryListView(LoginRequiredMixin, ListView):
    """
    List time entries with filtering capabilities.
    """
    model = TimeEntry
    template_name = 'hr/time_entries/time_entry_list.html'
    context_object_name = 'time_entries'
    paginate_by = 20
    
    def get_queryset(self):
        queryset = TimeEntry.objects.filter(
            employee__tenant=self.request.user.tenant
        ).select_related('employee')
        
        # Filter by employee
        employee = self.request.GET.get('employee')
        if employee:
            queryset = queryset.filter(employee_id=employee)
        
        # Filter by date range
        start_date = self.request.GET.get('start_date')
        end_date = self.request.GET.get('end_date')
        if start_date:
            queryset = queryset.filter(work_date__gte=start_date)
        if end_date:
            queryset = queryset.filter(work_date__lte=end_date)
        
        # Filter by approval status
        status = self.request.GET.get('status')
        if status:
            queryset = queryset.filter(status=status)
        
        return queryset.order_by('-work_date')


class TimeEntryDetailView(LoginRequiredMixin, DetailView):
    """
    Display detailed information about a specific time entry.
    """
    model = TimeEntry
    template_name = 'hr/time_entries/time_entry_detail.html'
    context_object_name = 'time_entry'
    
    def get_queryset(self):
        return TimeEntry.objects.filter(employee__tenant=self.request.user.tenant)


class TimeEntryCreateView(LoginRequiredMixin, CreateView):
    """
    Create a new time entry (manual entry).
    """
    model = TimeEntry
    form_class = TimeEntryForm
    template_name = 'hr/time_entries/time_entry_form.html'
    success_url = reverse_lazy('hr:time_entry_list')
    
    def form_valid(self, form):
        messages.success(self.request, 'Time entry created successfully.')
        return super().form_valid(form)
    
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs


class TimeEntryUpdateView(LoginRequiredMixin, UpdateView):
    """
    Update an existing time entry (limited fields).
    """
    model = TimeEntry
    form_class = TimeEntryForm
    template_name = 'hr/time_entries/time_entry_form.html'
    success_url = reverse_lazy('hr:time_entry_list')
    
    def get_queryset(self):
        return TimeEntry.objects.filter(employee__tenant=self.request.user.tenant)
    
    def form_valid(self, form):
        # Restrict updates for approved entries
        if self.object.status == 'APPROVED' and not self.request.user.is_superuser:
            messages.error(self.request, 'Cannot modify approved time entries.')
            return redirect('hr:time_entry_detail', pk=self.object.pk)
        
        messages.success(self.request, 'Time entry updated successfully.')
        return super().form_valid(form)
    
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs


class PerformanceReviewListView(LoginRequiredMixin, ListView):
    """
    List performance reviews with filtering capabilities.
    """
    model = PerformanceReview
    template_name = 'hr/reviews/performance_review_list.html'
    context_object_name = 'reviews'
    paginate_by = 20
    
    def get_queryset(self):
        queryset = PerformanceReview.objects.filter(
            employee__tenant=self.request.user.tenant
        ).select_related('employee', 'reviewer')
        
        # Filter by employee
        employee = self.request.GET.get('employee')
        if employee:
            queryset = queryset.filter(employee_id=employee)
        
        # Filter by status
        status = self.request.GET.get('status')
        if status:
            queryset = queryset.filter(status=status)
        
        # Filter by review type
        review_type = self.request.GET.get('review_type')
        if review_type:
            queryset = queryset.filter(review_type=review_type)
        
        return queryset.order_by('-review_date')


class PerformanceReviewDetailView(LoginRequiredMixin, DetailView):
    """
    Display detailed information about a specific performance review.
    """
    model = PerformanceReview
    template_name = 'hr/reviews/performance_review_detail.html'
    context_object_name = 'review'

    def get_queryset(self):
        # Eager load employee + department + supervisor to reduce queries
        return (PerformanceReview.objects
                .select_related('employee', 'employee__department', 'employee__supervisor', 'reviewer')
                .filter(employee__tenant=self.request.user.tenant))

    def get_object(self, queryset=None):
        queryset = queryset or self.get_queryset()
        return get_object_or_404(queryset, pk=self.kwargs.get('pk') or self.kwargs.get('id'))

    @staticmethod
    def _split_lines(text):
        if not text:
            return []
        parts = []
        for line in str(text).replace('\r', '').split('\n'):
            for piece in line.split(';'):
                piece = piece.strip()
                if piece:
                    parts.append(piece)
        return parts

    def get_context_data(self, **kwargs):
        ctx = super().get_context_data(**kwargs)
        review = ctx['review']

        # Build categories from competency_ratings JSON: { "Teamwork": 4.0, ... }
        # Make a list of dicts the template can iterate through.
        categories = []
        ratings = review.competency_ratings or {}
        # Keep a stable order (by key) to avoid chart jitter
        for name in sorted(ratings.keys()):
            try:
                score = float(ratings[name])
            except (TypeError, ValueError):
                score = 0.0
            categories.append({'name': name, 'score': score, 'comments': ''})

        # Previous reviews (same employee, exclude current)
        previous_reviews = (
            PerformanceReview.objects
            .filter(employee=review.employee)
            .exclude(pk=review.pk)
            .order_by('-review_date')[:5]
            .select_related('employee')
        )

        # Strengths / AFI lists for bullet rendering
        strengths_list = self._split_lines(review.strengths)
        afi_list = self._split_lines(review.areas_for_improvement)

        # Goals blocks as lists for nicer display
        goals_achieved_list = self._split_lines(review.goals_achieved)
        goals_not_achieved_list = self._split_lines(review.goals_not_achieved)
        future_goals_list = self._split_lines(review.future_goals)

        ctx.update({
            'categories': categories,
            'previous_reviews': previous_reviews,
            'review_strengths_list': strengths_list,
            'review_afi_list': afi_list,
            'goals_achieved_list': goals_achieved_list,
            'goals_not_achieved_list': goals_not_achieved_list,
            'future_goals_list': future_goals_list,
        })

        # convenience on the review object (template already expects these list props sometimes)
        setattr(review, 'strengths_list', strengths_list)
        setattr(review, 'areas_for_improvement_list', afi_list)

        return ctx


class PerformanceReviewCreateView(LoginRequiredMixin, CreateView):
    """
    Create a new performance review.
    """
    model = PerformanceReview
    form_class = PerformanceReviewForm
    template_name = 'hr/reviews/performance_review_form.html'
    success_url = reverse_lazy('hr:performance_review_list')
    
    def form_valid(self, form):
        form.instance.reviewer = self.request.user
        messages.success(self.request, 'Performance review created successfully.')
        return super().form_valid(form)
    
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs


class PerformanceReviewUpdateView(LoginRequiredMixin, UpdateView):
    """
    Update an existing performance review.
    """
    model = PerformanceReview
    form_class = PerformanceReviewForm
    template_name = 'hr/reviews/performance_review_form.html'
    
    def get_queryset(self):
        return PerformanceReview.objects.filter(employee__tenant=self.request.user.tenant)
    
    def get_success_url(self):
        return reverse('hr:performance_review_detail', kwargs={'pk': self.object.pk})
    
    def form_valid(self, form):
        messages.success(self.request, 'Performance review updated successfully.')
        return super().form_valid(form)
    
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs


class PerformanceReviewDeleteView(LoginRequiredMixin, DeleteView):
    """
    Delete a performance review (only if not finalized).
    """
    model = PerformanceReview
    template_name = 'hr/reviews/performance_review_confirm_delete.html'
    context_object_name = 'review'
    success_url = reverse_lazy('hr:performance_review_list')
    
    def get_queryset(self):
        return PerformanceReview.objects.filter(employee__tenant=self.request.user.tenant)
    
    def delete(self, request, *args, **kwargs):
        review = self.get_object()
        
        # Check if review is finalized
        if review.status == 'COMPLETED':
            messages.error(request, 'Cannot delete completed performance reviews.')
            return redirect('hr:performance_review_detail', pk=review.pk)
        
        messages.success(request, 'Performance review deleted successfully.')
        return super().delete(request, *args, **kwargs)


class TrainingManagementView(LoginRequiredMixin, ListView):
    model = TrainingRecord
    template_name = 'hr/training/training_management.html'
    context_object_name = 'training_records'
    paginate_by = 20

    def get_queryset(self):
        tenant = self.request.user.tenant
        qs = (TrainingRecord.objects
              .filter(employee__tenant=tenant)
              .select_related('employee', 'employee__department')
              .order_by( '-completion_date'))
        # optional GET filters (works with the template’s inputs)
        if emp := self.request.GET.get('employee'):
            qs = qs.filter(employee_id=emp)
        if ttype := self.request.GET.get('training_type'):
            qs = qs.filter(training_type=ttype)
        if status := self.request.GET.get('status'):
            qs = qs.filter(status=status)
        return qs

    def get_context_data(self, **kwargs):
        ctx = super().get_context_data(**kwargs)
        tenant = self.request.user.tenant
        today = timezone.now().date()

        base = TrainingRecord.objects.filter(employee__tenant=tenant)

        total_records = base.count()
        completed_trainings = base.filter(status='COMPLETED').count()
        pending_trainings = base.filter(status__in=['SCHEDULED', 'IN_PROGRESS']).count()
        overdue_trainings = base.filter(expiry_date__lt=today, expiry_date__isnull=False).exclude(
            status='COMPLETED').count()

        # compliance rate = “not expired” among trainings that have an expiry_date
        with_expiry = base.filter(expiry_date__isnull=False)
        valid_now = with_expiry.filter(expiry_date__gte=today).count()
        compliance_rate = round((valid_now / with_expiry.count()) * 100, 1) if with_expiry.exists() else 100.0

        # expiring soon = within 30 days
        expiring_soon_count = with_expiry.filter(expiry_date__gte=today,
                                                 expiry_date__lte=today + timedelta(days=30)).count()

        # department compliance (simple example: percent of non-expired per dept among those with expiry)
        dept_rows = []
        departments = Department.objects.filter(tenant=tenant).order_by('name')
        for d in departments:
            d_qs = with_expiry.filter(employee__department=d)
            if not d_qs.exists():
                rate = 100
            else:
                ok = d_qs.filter(expiry_date__gte=today).count()
                rate = round((ok / d_qs.count()) * 100)
            color = 'success' if rate >= 90 else 'warning' if rate >= 70 else 'danger'
            dept_rows.append({'name': d.name, 'compliance_rate': rate, 'compliance_color': color})

        # “compliance alerts” demo (overdue/expiring soon)
        alerts = []
        for tr in base.select_related('employee'):
            if tr.expiry_date:
                if tr.expiry_date < today:
                    alerts.append({
                        'id': tr.id,
                        'employee': tr.employee,
                        'requirement': tr.training_name,
                        'due_date': tr.expiry_date,
                        'priority_color': 'danger',
                        'urgency_color': 'danger',
                        'get_priority_display': 'Overdue',
                    })
                elif today <= tr.expiry_date <= today + timedelta(days=30):
                    alerts.append({
                        'id': tr.id,
                        'employee': tr.employee,
                        'requirement': tr.training_name,
                        'due_date': tr.expiry_date,
                        'priority_color': 'warning',
                        'urgency_color': 'warning',
                        'get_priority_display': 'Expiring Soon',
                    })

        ctx.update({
            'total_records': total_records,
            'completed_trainings': completed_trainings,
            'pending_trainings': pending_trainings,
            'overdue_trainings': overdue_trainings,
            'departments': departments,
            'compliance_rate': compliance_rate,
            'expiring_soon_count': expiring_soon_count,
            'department_compliance': dept_rows,
            'compliance_alerts': alerts,
        })
        return ctx


class TrainingRecordListView(LoginRequiredMixin, ListView):
    """
        List training records with filtering capabilities.
        """
    model = TrainingRecord
    template_name = 'hr/training/training_record_list.html'
    context_object_name = 'training_records'
    paginate_by = 20

    def get_queryset(self):
        queryset = TrainingRecord.objects.filter(
            employee__tenant=self.request.user.tenant
        ).select_related('employee')

        # Filter by employee
        employee = self.request.GET.get('employee')
        if employee:
            queryset = queryset.filter(employee_id=employee)

        # Filter by training type
        training_type = self.request.GET.get('training_type')
        if training_type:
            queryset = queryset.filter(training_type=training_type)

        # Filter by completion status
        status = self.request.GET.get('status')
        if status:
            queryset = queryset.filter(status=status)

        return queryset.order_by('-completion_date')


class TrainingRecordDetailView(LoginRequiredMixin, DetailView):
    """
    Display detailed information about a specific training record.
    """
    model = TrainingRecord
    template_name = 'hr/training/training_record_detail.html'
    context_object_name = 'record'
    
    def get_queryset(self):
        tenant = self.request.user.tenant
        return TrainingRecord.objects.filter(employee__tenant=tenant)


class TrainingRecordCreateView(LoginRequiredMixin, CreateView):
    """
    Create a new training record.
    """
    model = TrainingRecord
    form_class = TrainingRecordForm
    template_name = 'hr/training/training_record_form.html'
    success_url = reverse_lazy('hr:training_record_list')
    
    def form_valid(self, form):
        form.instance.created_by = self.request.user
        messages.success(self.request, 'Training record created successfully.')
        return super().form_valid(form)
    
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs


class TrainingRecordUpdateView(LoginRequiredMixin, UpdateView):
    """
    Update an existing training record.
    """
    model = TrainingRecord
    form_class = TrainingRecordForm
    template_name = 'hr/training/training_record_form.html'
    
    def get_queryset(self):
        return TrainingRecord.objects.filter(employee__tenant=self.request.user.tenant)
    
    def get_success_url(self):
        return reverse('hr:training_record_detail', kwargs={'pk': self.object.pk})
    
    def form_valid(self, form):
        messages.success(self.request, 'Training record updated successfully.')
        return super().form_valid(form)
    
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs


class TrainingRecordDeleteView(LoginRequiredMixin, DeleteView):
    """
    Delete a training record.
    """
    model = TrainingRecord
    template_name = 'hr/training/training_record_confirm_delete.html'
    success_url = reverse_lazy('hr:training_record_list')
    context_object_name = 'record'
    
    def get_queryset(self):
        return TrainingRecord.objects.filter(employee__tenant=self.request.user.tenant)
    
    def delete(self, request, *args, **kwargs):
        messages.success(request, 'Training record deleted successfully.')
        return super().delete(request, *args, **kwargs)


@login_required
def complete_performance_review(request, review_id):
    review = get_object_or_404(PerformanceReview, pk=review_id)
    review.status = 'COMPLETED'
    review.completed_by = request.user
    review.save()

    messages.success(request, 'Performance review completed successfully.')
    return redirect('hr:performance_review_detail', pk=review.pk)

@login_required
def hr_stats(request):
    """
    Return HR statistics for dashboard updates.
    """
    context = {
        'total_employees': Employee.objects.filter(tenant=request.user.tenant).count(),
        'active_employees': Employee.objects.filter(
            tenant=request.user.tenant,
            employment_status='ACTIVE'
        ).count(),
        'total_departments': Department.objects.filter(tenant=request.user.tenant).count(),
        'pending_reviews': PerformanceReview.objects.filter(
            employee__tenant=request.user.tenant,
            status='IN_PROGRESS'
        ).count(),
        'employees_clocked_in': TimeEntry.objects.filter(
            employee__tenant=request.user.tenant,
            clock_in_time__date=timezone.now().date(),
            clock_out_time__isnull=True
        ).count(),
    }
    
    return render(request, 'hr/partials/hr_stats.html', context)


@login_required
def employee_search(request):
    """
    Search employees for HTMX updates.
    """
    search = request.GET.get('search', '')
    employees = Employee.objects.filter(
        tenant=request.user.tenant
    )
    
    if search:
        employees = employees.filter(
            Q(first_name__icontains=search) |
            Q(last_name__icontains=search) |
            Q(employee_id__icontains=search)
        )
    
    employees = employees.select_related('department')[:20]
    
    return render(request, 'hr/partials/employee_list.html', {
        'employees': employees
    })


@login_required
def attendance_summary(request):
    """
    Return attendance summary for dashboard updates.
    """
    today = timezone.now().date()
    tenant = request.user.tenant

    # Total active employees
    total_active_employees = Employee.objects.filter(
        tenant=tenant,
        employment_status='ACTIVE'
    ).count()

    # Employees clocked in today (still working)
    clocked_in_entries = TimeEntry.objects.filter(
        employee__tenant=tenant,
        clock_in_time__date=today,
        clock_out_time__isnull=True
    ).select_related('employee', 'employee__department')

    employees_clocked_in = clocked_in_entries.count()

    # Late arrivals (clocked in after 9:00 AM)
    late_today = TimeEntry.objects.filter(
        employee__tenant=tenant,
        clock_in_time__date=today,
        clock_in_time__time__gt=time(9, 0),  # Assuming 9 AM is late
        clock_out_time__isnull=True
    ).count()

    # Absent today (active employees not clocked in)
    absent_today = total_active_employees - employees_clocked_in

    # Total hours today (completed shifts)
    total_hours_today = TimeEntry.objects.filter(
        employee__tenant=tenant,
        clock_in_time__date=today,
        clock_out_time__isnull=False
    ).aggregate(
        total=Sum('total_hours')
    )['total']

    # Current employees (detailed list for display)
    current_employees = clocked_in_entries.select_related('employee', 'employee__department').order_by(
        '-clock_in_time')[:10]

    context = {
        'employees_clocked_in': employees_clocked_in,
        'absent_today': absent_today,
        'late_today': late_today,
        'total_hours_today': total_hours_today,
        'current_employees': current_employees,
        'total_active_employees': total_active_employees,
    }

    return render(request, 'hr/partials/attendance_summary.html', context)


@require_GET
def clock_controls(request, employee_id):
    """Return the clock controls partial for today's state (HTMX GET)."""
    employee = get_object_or_404(Employee, id=employee_id, tenant=request.user.tenant)
    today = timezone.localdate()

    # Prefer the open entry for today; otherwise the last entry today (finished)
    time_entry = (
        TimeEntry.objects
        .filter(employee=employee, work_date=today)
        .order_by('clock_out_time', '-clock_in_time')  # open first (clock_out_time NULL), else latest finished
        .first()
    )

    return render(request, 'hr/partials/clock_controls.html', {
        'employee': employee,
        'time_entry': time_entry,
    })


def _render_controls(request, employee, time_entry):
    html = render_to_string('hr/partials/clock_controls.html',
                            {'employee': employee, 'time_entry': time_entry},
                            request=request)
    return HttpResponse(html)

@require_POST
def clock_in(request, employee_id):
    employee = get_object_or_404(Employee, id=employee_id, tenant=request.user.tenant)
    today = timezone.localdate()

    open_entry = TimeEntry.objects.filter(
        employee=employee, work_date=today, clock_out_time__isnull=True
    ).first()
    if open_entry:
        return _render_controls(request, employee, open_entry)

    time_entry = TimeEntry.objects.create(
        employee=employee, work_date=today, clock_in_time=timezone.now(), status='DRAFT'
    )

    if request.headers.get('HX-Request'):
        return _render_controls(request, employee, time_entry)
    return JsonResponse({'success': True, 'time_entry_id': time_entry.id})

@require_POST
def clock_out(request, employee_id):
    employee = get_object_or_404(Employee, id=employee_id, tenant=request.user.tenant)
    today = timezone.localdate()

    time_entry = TimeEntry.objects.filter(
        employee=employee, work_date=today, clock_out_time__isnull=True
    ).first()
    if not time_entry:
        # Re-render to default state (will show "Clock In")
        if request.headers.get('HX-Request'):
            return _render_controls(request, employee, None)
        return JsonResponse({'success': False, 'message': 'No active clock-in found.'}, status=400)

    time_entry.clock_out_time = timezone.now()
    time_entry.save()

    if request.headers.get('HX-Request'):
        return _render_controls(request, employee, time_entry)
    return JsonResponse({'success': True, 'time_entry_id': time_entry.id})


@login_required
def approve_time_entry(request, entry_id):
    """
    Approve a time entry.
    """
    time_entry = get_object_or_404(
        TimeEntry,
        id=entry_id,
        employee__tenant=request.user.tenant
    )
    
    if request.method == 'POST':
        # Check if entry is complete
        if not time_entry.clock_out_time:
            messages.error(request, 'Cannot approve incomplete time entry.')
            return redirect('hr:time_entry_detail', pk=time_entry.id)
        
        # Update time entry
        time_entry.status = 'APPROVED'
        time_entry.approved_by = request.user
        time_entry.approval_date = timezone.now()
        time_entry.save()
        
        messages.success(request, 'Time entry approved successfully.')
        
        # Redirect based on source
        next_url = request.POST.get('next', reverse('hr:time_entry_detail', kwargs={'pk': time_entry.id}))
        return redirect(next_url)
    
    return render(request, 'hr/time_entries/time_entry_approve.html', {
        'time_entry': time_entry
    })


@login_required
def publish_schedule(request, schedule_id):
    """
    Publish a schedule.
    """
    schedule = get_object_or_404(
        Schedule,
        id=schedule_id,
        employee__tenant=request.user.tenant
    )
    
    if request.method == 'POST':
        # Check if schedule has assignments
        if not ScheduleAssignment.objects.filter(schedule=schedule).exists():
            messages.error(request, 'Cannot publish empty schedule.')
            return redirect('hr:schedule_detail', pk=schedule.id)
        
        # Update schedule
        schedule.approved_by = request.user
        schedule.approval_date = timezone.now()
        schedule.save()
        
        messages.success(request, 'Schedule published successfully.')
        return redirect('hr:schedule_detail', pk=schedule.id)
    
    return render(request, 'hr/schedules/schedule_publish.html', {
        'schedule': schedule
    })


@login_required
def api_employee_list(request):
    """
    API endpoint for employee list.
    """
    employees = Employee.objects.filter(
        tenant=request.user.tenant
    ).values('employee_id', 'first_name', 'father_name', 'grandfather_name', 'last_name', 'job_title')
    
    return JsonResponse({'employees': list(employees)})


@login_required
def api_department_list(request):
    """
    API endpoint for department list.
    """
    departments = Department.objects.filter(
        tenant=request.user.tenant
    ).values('id', 'name', 'department_code')
    
    return JsonResponse({'departments': list(departments)})


def department_tree(request):
    """
    HTMX view for department tree structure.
    """
    departments = Department.objects.filter(
        tenant=request.user.tenant,
        parent_department=None
    ).prefetch_related('children')

    return render(request, 'hr/departments/department_tree.html', {
        'departments': departments
    })


@login_required
def department_children(request, department_id):
    """
    HTMX endpoint to load department children dynamically.
    """
    tenant = request.user.tenant
    try:
        parent_department = get_object_or_404(
            Department, 
            department_id=department_id,
            tenant=tenant
        )
        
        children = Department.objects.filter(
            tenant=tenant,
            parent_department=parent_department,
            is_active=True
        ).order_by('name')
        print(parent_department)
        print(children)
        # Calculate level based on parent's hierarchy
        level = 1  # Default for direct children
        if hasattr(parent_department, 'level'):
            level = parent_department.level + 1
        
        html_content = ""
        for child in children:
            # Add employee count for each child
            child.employee_count = Employee.objects.filter(
                department=child,
                tenant=tenant,
                employment_status='ACTIVE'
            ).count()
            
            # Render each child using the node template
            from django.template.loader import render_to_string
            html_content += render_to_string(
                'hr/departments/department_tree_node.html',
                {
                    'department': child,
                    'level': level
                },
                request=request
            )
        
        from django.http import HttpResponse
        return HttpResponse(html_content)
        
    except Department.DoesNotExist:
        from django.http import HttpResponse
        return HttpResponse(
            '<div class="text-danger p-2">'
            '<i class="fas fa-exclamation-triangle"></i> Department not found'
            '</div>',
            status=404
        )
    except Exception as e:
        from django.http import HttpResponse
        return HttpResponse(
            '<div class="text-danger p-2">'
            '<i class="fas fa-exclamation-triangle"></i> Error loading children'
            '</div>',
            status=500
        )


def activate_department(request, pk):
    """
    Activate a department.
    """
    department = get_object_or_404(Department, department_id=pk)
    department.is_active = True
    department.save()

    messages.success(request, f'Department "{department.name}" has been activated.')
    return redirect('hr:department_detail', pk=pk)


def deactivate_department(request, pk):
    """
    Deactivate a department.
    """
    department = get_object_or_404(Department, department_id=pk)
    department.is_active = False
    department.save()

    messages.success(request, f'Department "{department.name}" has been deactivated.')
    return redirect('hr:department_detail', pk=pk)


def department_search(request):
    """
    AJAX search for departments.
    """
    query = request.GET.get('q', '')
    departments = []

    if query:
        departments = Department.objects.filter(
            tenant=request.user.tenant,
            name__icontains=query
        ).values('department_id', 'name', 'department_type')[:10]

    return JsonResponse({'departments': list(departments)})


def bulk_activate_departments(request):
    """
    Bulk activate departments.
    """
    if request.method == 'POST':
        department_ids = request.POST.getlist('department_ids')
        count = Department.objects.filter(
            tenant=request.user.tenant,
            department_id__in=department_ids
        ).update(is_active=True)

        messages.success(request, f'{count} departments have been activated.')

    return redirect('hr:department_list')


def bulk_deactivate_departments(request):
    """
    Bulk deactivate departments.
    """
    if request.method == 'POST':
        department_ids = request.POST.getlist('department_ids')
        count = Department.objects.filter(
            tenant=request.user.tenant,
            department_id__in=department_ids
        ).update(is_active=False)

        messages.success(request, f'{count} departments have been deactivated.')

    return redirect('hr:department_list')


def get_department_hierarchy(request):
    """
    Get department hierarchy as JSON.
    """
    departments = Department.objects.filter(
        tenant=request.user.tenant,
        is_active=True
    ).select_related('parent')

    def build_tree(parent=None):
        children = []
        for dept in departments:
            if dept.parent == parent:
                children.append({
                    'id': str(dept.department_id),
                    'name': dept.name,
                    'type': dept.department_type,
                    'children': build_tree(dept)
                })
        return children

    hierarchy = build_tree()
    return JsonResponse({'hierarchy': hierarchy})


@login_required
def assign_department_head(request, pk):
    """
    Assign a department head to a department.
    """
    tenant = request.user.tenant
    department = get_object_or_404(Department, pk=pk, tenant=tenant)

    if request.method == 'POST':
        user_id = request.POST.get('user_id')

        if user_id:
            try:
                user = User.objects.get(id=user_id, tenant=tenant)
                employee = Employee.objects.get(user=user)

                # Remove current department head if exists
                if department.department_head:
                    old_head = department.department_head
                    AuditLogger.log_event(
                        tenant=tenant,
                        request=request,
                        event_type='UPDATE',
                        event_category='SYSTEM_ADMINISTRATION',
                        action=f'Removed department head from {department.name}',
                        description=f'Removed {old_head.get_full_name()} as head of {department.name}',
                        content_object=department,
                        additional_data={
                            'old_department_head_id': old_head.id,
                            'old_department_head_name': old_head.get_full_name()
                        }
                    )

                # Assign new department head
                department.department_head = employee
                department.save()

                # Log the assignment
                AuditLogger.log_event(
                    tenant=tenant,
                    request=request,
                    event_type='UPDATE',
                    event_category='SYSTEM_ADMINISTRATION',
                    action=f'Assigned department head to {department.name}',
                    description=f'Assigned {user.get_full_name()} as head of {department.name}',
                    content_object=department,
                    additional_data={
                        'new_department_head_id': user.id,
                        'new_department_head_name': user.get_full_name()
                    }
                )

                messages.success(
                    request,
                    f'{user.get_full_name()} has been assigned as head of {department.name}.'
                )
                return redirect('hr:department_detail', pk=department.pk)

            except User.DoesNotExist:
                messages.error(request, 'Selected user not found.')
        else:
            # Remove department head
            if department.department_head:
                old_head = department.department_head
                department.department_head = None
                department.save()

                # Log the removal
                AuditLogger.log_event(
                    tenant=tenant,
                    request=request,
                    event_type='UPDATE',
                    event_category='SYSTEM_ADMINISTRATION',
                    action=f'Removed department head from {department.name}',
                    description=f'Removed {old_head.get_full_name()} as head of {department.name}',
                    content_object=department,
                    additional_data={
                        'removed_department_head_id': old_head.id,
                        'removed_department_head_name': old_head.get_full_name()
                    }
                )

                messages.success(
                    request,
                    f'Department head has been removed from {department.name}.'
                )
            else:
                messages.info(request, 'No department head was assigned.')

            return redirect('hr:department_detail', pk=department.pk)

    # Get eligible users (staff members who can be department heads)
    eligible_users = User.objects.filter(
        tenant=tenant,
        is_active=True,
        is_staff=True
    ).exclude(
        id=department.department_head.id if department.department_head else None
    ).order_by('first_name', 'last_name')

    context = {
        'department': department,
        'eligible_users': eligible_users,
        'current_head': department.department_head,
    }

    return render(request, 'hr/departments/assign_department_head.html', context)


@login_required
def mark_time_entry_paid(request, pk):
    """
    Mark a time entry as paid.
    """
    time_entry = get_object_or_404(
        TimeEntry,
        pk=pk,
        tenant=request.user.tenant
    )

    if request.method == 'POST':
        if not request.user.has_perm('hr.change_timeentry'):
            messages.error(request, "You don't have permission to mark time entries as paid.")
            return redirect('hr:time_entry_detail', pk=time_entry.pk)

        time_entry.is_paid = True
        time_entry.payment_date = timezone.now().date()
        time_entry.save()

        messages.success(
            request,
            f"Time entry for {time_entry.employee.get_full_name()} on {time_entry.entry_date} marked as paid."
        )

        redirect_url = request.POST.get('next', reverse('hr:time_entry_detail', kwargs={'pk': time_entry.pk}))
        return redirect(redirect_url)

    return redirect('hr:time_entry_detail', pk=time_entry.pk)


@login_required
def bulk_approve_time_entries(request):
    """
    Bulk approve time entries.
    """
    if not request.user.has_perm('hr.approve_timeentry'):
        messages.error(request, "You don't have permission to approve time entries.")
        return redirect('hr:time_entry_list')

    if request.method == 'POST':
        entry_ids = request.POST.getlist('entry_ids')

        if not entry_ids:
            messages.warning(request, "No time entries selected for approval.")
            return redirect('hr:time_entry_list')

        # Get entries that belong to this tenant
        entries = TimeEntry.objects.filter(
            tenant=request.user.tenant,
            pk__in=entry_ids,
            is_approved=False
        )

        # Update all entries
        updated_count = entries.update(
            is_approved=True,
            approved_by=request.user,
            approval_date=timezone.now()
        )

        messages.success(request, f"{updated_count} time entries approved successfully.")

        redirect_url = request.POST.get('next', reverse('hr:time_entry_list'))
        return redirect(redirect_url)

    return redirect('hr:time_entry_list')


@login_required
def bulk_mark_time_entries_paid(request):
    """
    Bulk mark time entries as paid.
    """
    if not request.user.has_perm('hr.change_timeentry'):
        messages.error(request, "You don't have permission to mark time entries as paid.")
        return redirect('hr:time_entry_list')

    if request.method == 'POST':
        entry_ids = request.POST.getlist('entry_ids')

        if not entry_ids:
            messages.warning(request, "No time entries selected for payment.")
            return redirect('hr:time_entry_list')

        # Get entries that belong to this tenant
        entries = TimeEntry.objects.filter(
            tenant=request.user.tenant,
            pk__in=entry_ids,
            is_approved=True,
            is_paid=False
        )

        # Update all entries
        updated_count = entries.update(
            is_paid=True,
            payment_date=timezone.now().date()
        )

        messages.success(request, f"{updated_count} time entries marked as paid successfully.")

        redirect_url = request.POST.get('next', reverse('hr:time_entry_list'))
        return redirect(redirect_url)

    return redirect('hr:time_entry_list')


@login_required
def acknowledge_review(request, pk):
    """
    Acknowledge a performance review.
    """
    review = get_object_or_404(
        PerformanceReview,
        pk=pk,
        tenant=request.user.tenant
    )

    # Check if the user is the employee being reviewed
    if hasattr(request.user, 'employee_profile') and request.user.employee_profile == review.employee:
        if request.method == 'POST':
            review.is_acknowledged = True
            review.acknowledgment_date = timezone.now()
            review.save()

            messages.success(request, "You have acknowledged this performance review.")

            redirect_url = request.POST.get('next', reverse('hr:performance_review_detail', kwargs={'pk': review.pk}))
            return redirect(redirect_url)
    else:
        messages.error(request, "Only the employee being reviewed can acknowledge this review.")

    return redirect('hr:performance_review_detail', pk=review.pk)


@login_required
def complete_review(request, pk):
    """
    Mark a performance review as completed.
    """
    review = get_object_or_404(
        PerformanceReview,
        pk=pk,
        tenant=request.user.tenant
    )

    if request.method == 'POST':
        if not request.user.has_perm('hr.change_performancereview'):
            messages.error(request, "You don't have permission to complete reviews.")
            return redirect('hr:performance_review_detail', pk=review.pk)

        # Check if reviewer is the one completing the review
        if review.reviewer != request.user:
            messages.warning(request, "Only the assigned reviewer should complete this review.")

        # Update review status
        review.status = 'COMPLETED'
        review.completion_date = timezone.now().date()
        review.save()

        # Update employee's last and next review dates
        employee = review.employee
        employee.last_review_date = review.completion_date
        employee.next_review_date = review.next_review_date
        employee.save()

        messages.success(
            request,
            f"Performance review for {review.employee.get_full_name()} marked as completed."
        )

        redirect_url = request.POST.get('next', reverse('hr:performance_review_detail', kwargs={'pk': review.pk}))
        return redirect(redirect_url)

    return redirect('hr:performance_review_detail', pk=review.pk)


@login_required
def employee_schedule(request, employee_id):
    """
    View an employee's schedule.
    """
    employee = get_object_or_404(
        Employee,
        pk=employee_id,
        tenant=request.user.tenant
    )

    # Get current schedule
    current_schedule = Schedule.objects.filter(
        employee=employee,
        is_current=True,
        is_active=True
    ).first()

    # Get upcoming assignments
    today = timezone.now().date()
    upcoming_assignments = ScheduleAssignment.objects.filter(
        schedule__employee=employee,
        assignment_date__gte=today
    ).order_by('assignment_date', 'start_time')[:14]  # Next 2 weeks

    context = {
        'employee': employee,
        'current_schedule': current_schedule,
        'upcoming_assignments': upcoming_assignments,
    }

    return render(request, 'hr/employee_schedule.html', context)


class TrainingProgramListView(LoginRequiredMixin, ListView):
    """List all training programs."""
    model = TrainingPrograms
    template_name = 'hr/training/program_list.html'
    context_object_name = 'programs'
    paginate_by = 20

    def get_queryset(self):
        queryset = TrainingPrograms.objects.filter(tenant=self.request.user.tenant)
        
        # Search functionality
        search = self.request.GET.get('search')
        if search:
            queryset = queryset.filter(
                Q(name__icontains=search) |
                Q(description__icontains=search) |
                Q(program_provider__icontains=search)
            )
        
        # Filter by program type
        program_type = self.request.GET.get('program_type')
        if program_type:
            queryset = queryset.filter(program_type=program_type)
        
        # Filter by certification status
        is_certified = self.request.GET.get('is_certified')
        if is_certified:
            queryset = queryset.filter(is_certified=(is_certified == 'true'))
        
        return queryset.select_related('instructor').order_by('name')

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['program_types'] = TrainingPrograms.TrainingType.choices
        context['search'] = self.request.GET.get('search', '')
        context['selected_type'] = self.request.GET.get('program_type', '')
        context['selected_certified'] = self.request.GET.get('is_certified', '')
        return context


class TrainingProgramDetailView(LoginRequiredMixin, DetailView):
    """Display detailed information about a training program."""
    model = TrainingPrograms
    template_name = 'hr/training/program_detail.html'
    context_object_name = 'program'

    def get_queryset(self):
        return TrainingPrograms.objects.filter(tenant=self.request.user.tenant)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        program = self.get_object()
        
        # Get program modules
        context['modules'] = ProgramModule.objects.filter(program=program).order_by('order')
        
        # Get prerequisites
        context['prerequisites'] = ProgramPrerequisite.objects.filter(
            program=program
        ).select_related('required_program')
        
        # Get upcoming sessions
        context['upcoming_sessions'] = TrainingSession.objects.filter(
            program=program,
            start_at__gte=timezone.now()
        ).order_by('start_at')[:5]
        
        # Get recent completions
        context['recent_completions'] = TrainingRecord.objects.filter(
            program=program,
            status='COMPLETED'
        ).select_related('employee').order_by('-completion_date')[:10]
        
        # Statistics
        context['total_enrollments'] = TrainingRecord.objects.filter(program=program).count()
        context['completion_rate'] = 0
        if context['total_enrollments'] > 0:
            completed = TrainingRecord.objects.filter(program=program, status='COMPLETED').count()
            context['completion_rate'] = round((completed / context['total_enrollments']) * 100, 1)
        
        return context


class TrainingProgramCreateView(LoginRequiredMixin, CreateView):
    """Create a new training program."""
    model = TrainingPrograms
    form_class = TrainingProgramForm
    template_name = 'hr/training/program_form.html'


    def form_valid(self, form):
        form.instance.tenant = self.request.user.tenant
        form.instance.created_by = self.request.user.employee_profile
        messages.success(self.request, 'Training program created successfully.')
        return super().form_valid(form)

    def get_success_url(self):
        return reverse('hr:training_program_detail', kwargs={'pk': self.object.pk})


class TrainingProgramUpdateView(LoginRequiredMixin, UpdateView):
    """Update an existing training program."""
    model = TrainingPrograms
    template_name = 'hr/training/program_form.html'
    form_class = TrainingProgramForm

    def get_queryset(self):
        return TrainingPrograms.objects.filter(tenant=self.request.user.tenant)

    def form_valid(self, form):
        messages.success(self.request, 'Training program updated successfully.')
        return super().form_valid(form)

    def get_success_url(self):
        return reverse('hr:training_program_detail', kwargs={'pk': self.object.pk})


class TrainingSessionListView(LoginRequiredMixin, ListView):
    """List all training sessions."""
    model = TrainingSession
    template_name = 'hr/training/session_list.html'
    context_object_name = 'sessions'
    paginate_by = 20

    def get_queryset(self):
        queryset = TrainingSession.objects.filter(
            program__tenant=self.request.user.tenant
        ).select_related('program', 'instructor')
        
        # Filter by program
        program_id = self.request.GET.get('program')
        if program_id:
            queryset = queryset.filter(program_id=program_id)
        
        # Filter by delivery method
        delivery_method = self.request.GET.get('delivery_method')
        if delivery_method:
            queryset = queryset.filter(delivery_method=delivery_method)
        
        # Filter by date range
        start_date = self.request.GET.get('start_date')
        if start_date:
            queryset = queryset.filter(start_at__date__gte=start_date)
        
        end_date = self.request.GET.get('end_date')
        if end_date:
            queryset = queryset.filter(start_at__date__lte=end_date)
        
        return queryset.order_by('start_at')

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['programs'] = TrainingPrograms.objects.filter(
            tenant=self.request.user.tenant
        ).order_by('name')
        context['delivery_methods'] = TrainingSession.TrainingDelivery.choices
        return context


class TrainingSessionDetailView(LoginRequiredMixin, DetailView):
    """Display detailed information about a training session."""
    model = TrainingSession
    template_name = 'hr/training/session_detail.html'
    context_object_name = 'session'

    def get_queryset(self):
        return TrainingSession.objects.filter(
            program__tenant=self.request.user.tenant
        ).select_related('program', 'instructor')

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        session = self.get_object()
        
        # Get enrollments
        context['enrollments'] = TrainingRecord.objects.filter(
            session=session
        ).select_related('employee').order_by('enrolled_at')
        
        # Get attendance records
        context['attendance_records'] = TrainingAttendance.objects.filter(
            enrollment__session=session
        ).select_related('enrollment__employee')
        
        # Statistics
        context['total_enrolled'] = context['enrollments'].count()
        context['capacity_percentage'] = 0
        if session.capacity > 0:
            context['capacity_percentage'] = round(
                (context['total_enrolled'] / session.capacity) * 100, 1
            )
        
        return context


class TrainingSessionCreateView(LoginRequiredMixin, CreateView):
    """Create a new training session."""
    model = TrainingSession
    form_class = TrainingSessionForm
    template_name = 'hr/training/session_form.html'


    def form_valid(self, form):
        form.instance.created_by = self.request.user.employee_profile
        messages.success(self.request, 'Training session created successfully.')
        return super().form_valid(form)

    def get_success_url(self):
        return reverse('hr:training_session_detail', kwargs={'pk': self.object.pk})


class TrainingSessionUpdateView(LoginRequiredMixin, UpdateView):
    """Update an existing training session."""
    model = TrainingSession
    form_class = TrainingSessionForm
    template_name = 'hr/training/session_form.html'


    def get_queryset(self):
        return TrainingSession.objects.filter(program__tenant=self.request.user.tenant)

    def form_valid(self, form):
        messages.success(self.request, 'Training session updated successfully.')
        return super().form_valid(form)

    def get_success_url(self):
        return reverse('hr:training_session_detail', kwargs={'pk': self.object.pk})


@login_required
def enroll_employee(request, session_id):
    """Enroll an employee in a training session."""
    session = get_object_or_404(
        TrainingSession,
        pk=session_id,
        program__tenant=request.user.tenant
    )
    
    if request.method == 'POST':
        employee_id = request.POST.get('employee_id')
        employee = get_object_or_404(
            Employee,
            pk=employee_id,
            tenant=request.user.tenant
        )
        
        # Check if already enrolled
        existing_enrollment = TrainingRecord.objects.filter(
            employee=employee,
            session=session
        ).first()
        
        if existing_enrollment:
            messages.warning(request, f'{employee.get_full_name()} is already enrolled in this session.')
        else:
            # Check capacity
            current_enrollments = TrainingRecord.objects.filter(session=session).count()
            status = 'SCHEDULED'
            if session.capacity and current_enrollments >= session.capacity:
                status = 'WAITLISTED'
            
            # Create enrollment
            TrainingRecord.objects.create(
                employee=employee,
                program=session.program,
                session=session,
                status=status,
                created_by=request.user
            )
            
            if status == 'WAITLISTED':
                messages.info(request, f'{employee.get_full_name()} has been added to the waitlist.')
            else:
                messages.success(request, f'{employee.get_full_name()} has been enrolled successfully.')
    
    return redirect('hr:training_session_detail', pk=session.pk)


@login_required
def mark_attendance(request, enrollment_id):
    """Mark attendance for a training enrollment."""
    enrollment = get_object_or_404(
        TrainingRecord,
        pk=enrollment_id,
        employee__tenant=request.user.tenant
    )
    
    if request.method == 'POST':
        status = request.POST.get('status', 'PRESENT')
        notes = request.POST.get('notes', '')
        
        # Create or update attendance record
        attendance, created = TrainingAttendance.objects.get_or_create(
            enrollment=enrollment,
            defaults={
                'status': status,
                'notes': notes,
                'checked_in_at': timezone.now() if status in ['PRESENT', 'LATE'] else None
            }
        )
        
        if not created:
            attendance.status = status
            attendance.notes = notes
            if status in ['PRESENT', 'LATE'] and not attendance.checked_in_at:
                attendance.checked_in_at = timezone.now()
            attendance.save()
        
        messages.success(request, f'Attendance marked for {enrollment.employee.get_full_name()}.')
    
    return redirect('hr:training_session_detail', pk=enrollment.session.pk)


class TrainingCertificateListView(LoginRequiredMixin, ListView):
    """List all training certificates."""
    model = TrainingCertificates
    template_name = 'hr/training/certificate_list.html'
    context_object_name = 'certificates'
    paginate_by = 20

    def get_queryset(self):
        queryset = TrainingCertificates.objects.filter(
            employee__tenant=self.request.user.tenant
        ).select_related('employee', 'program', 'enrollment')
        
        # Filter by employee
        employee_id = self.request.GET.get('employee')
        if employee_id:
            queryset = queryset.filter(employee_id=employee_id)
        
        # Filter by program
        program_id = self.request.GET.get('program')
        if program_id:
            queryset = queryset.filter(program_id=program_id)
        
        # Filter by expiry status
        expiry_status = self.request.GET.get('expiry_status')
        today = timezone.now().date()
        if expiry_status == 'valid':
            queryset = queryset.filter(
                Q(expiry_date__isnull=True) | Q(expiry_date__gt=today)
            )
        elif expiry_status == 'expiring':
            queryset = queryset.filter(
                expiry_date__gt=today,
                expiry_date__lte=today + timedelta(days=30)
            )
        elif expiry_status == 'expired':
            queryset = queryset.filter(expiry_date__lt=today)
        
        return queryset.order_by('-issued_date')

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['employees'] = Employee.objects.filter(
            tenant=self.request.user.tenant,
            employment_status='ACTIVE'
        ).order_by('last_name', 'first_name')
        context['programs'] = TrainingPrograms.objects.filter(
            tenant=self.request.user.tenant,
            is_certified=True
        ).order_by('name')
        return context


class TrainingCertificateDetailView(LoginRequiredMixin, DetailView):
    """Display detailed information about a training certificate."""
    model = TrainingCertificates
    template_name = 'hr/training/certificate_detail.html'
    context_object_name = 'certificate'

    def get_queryset(self):
        return TrainingCertificates.objects.filter(
            employee__tenant=self.request.user.tenant
        ).select_related('employee', 'program', 'enrollment', 'signed_by')


@login_required
def issue_certificate(request, enrollment_id):
    """Issue a certificate for a completed training enrollment."""
    enrollment = get_object_or_404(
        TrainingRecord,
        pk=enrollment_id,
        employee__tenant=request.user.tenant,
        status='COMPLETED',
        passed=True,
        program__is_certified=True
    )
    
    # Check if certificate already exists
    existing_certificate = TrainingCertificates.objects.filter(enrollment=enrollment).first()
    if existing_certificate:
        messages.warning(request, 'Certificate already exists for this enrollment.')
        return redirect('hr:training_certificate_detail', pk=existing_certificate.pk)
    
    if request.method == 'POST':
        certificate_name = request.POST.get('certificate_name', f'{enrollment.program.name} Certificate')
        certification_body = request.POST.get('certification_body', 'Hospital Training Department')
        
        # Calculate expiry date
        expiry_date = None
        if enrollment.program.validity_days:
            expiry_date = enrollment.completion_date + timedelta(days=enrollment.program.validity_days)
        
        # Generate certificate number
        certificate_number = f"CERT-{enrollment.program.tenant.id}-{timezone.now().strftime('%Y%m%d')}-{enrollment.id}"
        
        # Create certificate
        certificate = TrainingCertificates.objects.create(
            program=enrollment.program,
            employee=enrollment.employee,
            enrollment=enrollment,
            certificate_name=certificate_name,
            certificate_number=certificate_number,
            certification_body=certification_body,
            expiry_date=expiry_date,
            created_by=request.user.employee_profile,
            signed_by=request.user.employee_profile
        )
        
        messages.success(request, f'Certificate issued successfully for {enrollment.employee.get_full_name()}.')
        return redirect('hr:training_certificate_detail', pk=certificate.pk)
    
    context = {
        'enrollment': enrollment,
        'suggested_name': f'{enrollment.program.name} Certificate',
        'suggested_body': 'Hospital Training Department'
    }
    return render(request, 'hr/training/issue_certificate.html', context)


@login_required
def training_analytics(request):
    """Display training analytics and reports."""
    tenant = request.user.tenant
    today = timezone.now().date()
    
    # Basic statistics
    total_programs = TrainingPrograms.objects.filter(tenant=tenant).count()
    total_sessions = TrainingSession.objects.filter(program__tenant=tenant).count()
    total_enrollments = TrainingRecord.objects.filter(employee__tenant=tenant).count()
    total_certificates = TrainingCertificates.objects.filter(employee__tenant=tenant).count()
    
    # Completion rates by program type
    program_stats = []
    for program_type, display_name in TrainingPrograms.TrainingType.choices:
        programs = TrainingPrograms.objects.filter(tenant=tenant, program_type=program_type)
        if programs.exists():
            total_enrollments_type = TrainingRecord.objects.filter(program__in=programs).count()
            completed_enrollments = TrainingRecord.objects.filter(
                program__in=programs, status='COMPLETED'
            ).count()
            completion_rate = 0
            if total_enrollments_type > 0:
                completion_rate = round((completed_enrollments / total_enrollments_type) * 100, 1)
            
            program_stats.append({
                'type': display_name,
                'total_programs': programs.count(),
                'total_enrollments': total_enrollments_type,
                'completion_rate': completion_rate
            })
    
    # Expiring certificates
    expiring_certificates = TrainingCertificates.objects.filter(
        employee__tenant=tenant,
        expiry_date__gte=today,
        expiry_date__lte=today + timedelta(days=30)
    ).select_related('employee', 'program').order_by('expiry_date')
    
    # Training compliance by department
    department_compliance = []
    departments = Department.objects.filter(tenant=tenant)
    for dept in departments:
        dept_employees = Employee.objects.filter(department=dept, employment_status='ACTIVE')
        if dept_employees.exists():
            total_required = dept_employees.count() * 5  # Assume 5 mandatory trainings per employee
            completed_trainings = TrainingRecord.objects.filter(
                employee__in=dept_employees,
                status='COMPLETED',
                program__program_type='MANDATORY'
            ).count()
            compliance_rate = round((completed_trainings / total_required) * 100, 1) if total_required > 0 else 0
            
            department_compliance.append({
                'department': dept.name,
                'employees': dept_employees.count(),
                'compliance_rate': compliance_rate
            })
    
    context = {
        'total_programs': total_programs,
        'total_sessions': total_sessions,
        'total_enrollments': total_enrollments,
        'total_certificates': total_certificates,
        'program_stats': program_stats,
        'expiring_certificates': expiring_certificates,
        'department_compliance': department_compliance,
    }
    
    return render(request, 'hr/training/analytics.html', context)


@login_required
def employee_training_transcript(request, employee_id):
    """Display an employee's complete training transcript."""
    employee = get_object_or_404(
        Employee,
        pk=employee_id,
        tenant=request.user.tenant
    )
    
    # Get all training records
    training_records = TrainingRecord.objects.filter(
        employee=employee
    ).select_related('program', 'session').order_by('-completion_date', '-enrolled_at')
    
    # Get all certificates
    certificates = TrainingCertificates.objects.filter(
        employee=employee
    ).select_related('program').order_by('-issued_date')
    
    # Calculate statistics
    total_hours = sum(record.credits_earned for record in training_records if record.credits_earned)
    completed_trainings = training_records.filter(status='COMPLETED').count()
    
    context = {
        'employee': employee,
        'training_records': training_records,
        'certificates': certificates,
        'total_hours': total_hours,
        'completed_trainings': completed_trainings,
    }
    
    return render(request, 'hr/training/employee_transcript.html', context)


@login_required
def training_record_mark_complete(request, record_id):
    """Mark a training record as complete."""
    record = get_object_or_404(
        TrainingRecord,
        pk=record_id,
        employee__tenant=request.user.tenant
    )
    
    if request.method == 'POST':
        # Update record status
        record.status = 'COMPLETED'
        record.completion_date = timezone.now().date()
        record.passed = True
        
        # Set credits earned if not already set
        if not record.credits_earned:
            if record.session and record.session.hours_override:
                record.credits_earned = record.session.hours_override
            elif record.program:
                record.credits_earned = record.program.duration_hours
        
        # Get score from form if provided
        score = request.POST.get('score')
        if score:
            try:
                record.score = float(score)
                record.passed = record.score >= 70  # Assuming 70% is passing
            except (ValueError, TypeError):
                pass
        
        # Add completion notes
        notes = request.POST.get('notes', '')
        if notes:
            existing_notes = record.notes or ''
            record.notes = f"{existing_notes}\n\nCompleted: {notes}".strip()
        
        record.save()
        
        # Auto-issue certificate if program is certified and employee passed
        if (record.program and record.program.is_certified and record.passed and 
            not TrainingCertificates.objects.filter(enrollment=record).exists()):
            
            # Calculate expiry date
            expiry_date = None
            if record.program.validity_days:
                expiry_date = record.completion_date + timedelta(days=record.program.validity_days)
            
            # Generate certificate number
            certificate_number = f"CERT-{record.program.tenant.id}-{timezone.now().strftime('%Y%m%d')}-{record.id}"
            
            # Create certificate
            TrainingCertificates.objects.create(
                program=record.program,
                employee=record.employee,
                enrollment=record,
                certificate_name=f'{record.program.name} Certificate',
                certificate_number=certificate_number,
                certification_body='Hospital Training Department',
                expiry_date=expiry_date,
                created_by=request.user.employee_profile if hasattr(request.user, 'employee_profile') else None
            )
            
            messages.success(request, f'Training record marked as complete and certificate issued for {record.employee.get_full_name()}.')
        else:
            messages.success(request, f'Training record marked as complete for {record.employee.get_full_name()}.')
        
        return redirect('hr:training_record_detail', pk=record.pk)
    
    context = {
        'record': record,
        'can_issue_certificate': (record.program and record.program.is_certified and 
                                 not TrainingCertificates.objects.filter(enrollment=record).exists())
    }
    return render(request, 'hr/training/mark_complete.html', context)


@login_required
def training_record_renew(request, record_id):
    """Renew an expired training record by creating a new enrollment."""
    original_record = get_object_or_404(
        TrainingRecord,
        pk=record_id,
        employee__tenant=request.user.tenant
    )
    
    if request.method == 'POST':
        # Create new training record based on the original
        new_record = TrainingRecord.objects.create(
            employee=original_record.employee,
            program=original_record.program,
            session=None,  # Will need to be assigned to a new session
            status='SCHEDULED',
            created_by=request.user
        )
        
        # Add renewal note
        new_record.notes = f"Renewal of training record #{original_record.id} from {original_record.completion_date}"
        new_record.save()
        
        messages.success(
            request, 
            f'Training renewal created for {original_record.employee.get_full_name()}. '
            f'Please assign to an appropriate session.'
        )
        
        return redirect('hr:training_record_detail', pk=new_record.pk)
    
    context = {
        'record': original_record,
        'available_sessions': TrainingSession.objects.filter(
            program=original_record.program,
            start_at__gte=timezone.now()
        ).order_by('start_at')
    }
    return render(request, 'hr/training/renew_record.html', context)


@login_required
def training_record_mark_expired(request, record_id):
    """Mark a training record as expired."""
    record = get_object_or_404(
        TrainingRecord,
        pk=record_id,
        employee__tenant=request.user.tenant
    )
    
    if request.method == 'POST':
        # Update record status
        record.status = 'FAILED'  # Using FAILED status to indicate expired/invalid
        
        # Add expiry note
        expiry_reason = request.POST.get('reason', 'Marked as expired')
        existing_notes = record.notes or ''
        record.notes = f"{existing_notes}\n\nExpired: {expiry_reason} on {timezone.now().date()}".strip()
        record.save()
        
        # Mark related certificate as expired if exists
        certificate = TrainingCertificates.objects.filter(enrollment=record).first()
        if certificate:
            certificate.expiry_date = timezone.now().date()
            certificate.save()
        
        messages.success(request, f'Training record marked as expired for {record.employee.get_full_name()}.')
        return redirect('hr:training_record_detail', pk=record.pk)
    
    context = {'record': record}
    return render(request, 'hr/training/mark_expired.html', context)


@login_required
def training_record_archive(request, record_id):
    """Archive a training record (soft delete)."""
    record = get_object_or_404(
        TrainingRecord,
        pk=record_id,
        employee__tenant=request.user.tenant
    )
    
    if request.method == 'POST':
        # Add archive note instead of deleting
        archive_reason = request.POST.get('reason', 'Archived by user')
        existing_notes = record.notes or ''
        record.notes = f"{existing_notes}\n\nArchived: {archive_reason} on {timezone.now().date()}".strip()
        
        # Change status to indicate archived
        record.status = 'CANCELLED'
        record.save()
        
        messages.success(request, f'Training record archived for {record.employee.get_full_name()}.')
        return redirect('hr:training_record_list')
    
    context = {'record': record}
    return render(request, 'hr/training/archive_record.html', context)


@login_required
def training_record_duplicate(request, record_id):
    """Duplicate a training record for the same or different employee."""
    original_record = get_object_or_404(
        TrainingRecord,
        pk=record_id,
        employee__tenant=request.user.tenant
    )
    
    if request.method == 'POST':
        # Get target employee (default to same employee)
        employee_id = request.POST.get('employee_id', original_record.employee.id)
        target_employee = get_object_or_404(
            Employee,
            pk=employee_id,
            tenant=request.user.tenant
        )
        
        # Check if employee already has this training
        existing_record = TrainingRecord.objects.filter(
            employee=target_employee,
            program=original_record.program,
            status__in=['SCHEDULED', 'IN_PROGRESS', 'COMPLETED']
        ).first()
        
        if existing_record:
            messages.warning(
                request, 
                f'{target_employee.get_full_name()} already has an active record for this training program.'
            )
            return redirect('hr:training_record_detail', pk=original_record.pk)
        
        # Create duplicate record
        new_record = TrainingRecord.objects.create(
            employee=target_employee,
            program=original_record.program,
            session=None,  # Will need to be assigned to a session
            status='SCHEDULED',
            created_by=request.user
        )
        
        # Add duplication note
        new_record.notes = f"Duplicated from training record #{original_record.id} for {original_record.employee.get_full_name()}"
        new_record.save()
        
        messages.success(
            request, 
            f'Training record duplicated for {target_employee.get_full_name()}. '
            f'Please assign to an appropriate session.'
        )
        
        return redirect('hr:training_record_detail', pk=new_record.pk)
    
    context = {
        'record': original_record,
        'employees': Employee.objects.filter(
            tenant=request.user.tenant,
            employment_status='ACTIVE'
        ).order_by('last_name', 'first_name'),
        'available_sessions': TrainingSession.objects.filter(
            program=original_record.program,
            start_at__gte=timezone.now()
        ).order_by('start_at')
    }
    return render(request, 'hr/training/duplicate_record.html', context)


@require_http_methods(["GET"])
def get_program_sessions(request):
    """
    AJAX endpoint to get sessions for a specific training program.
    """
    program_id = request.GET.get('program_id')
    if not program_id:
        return JsonResponse({'sessions': []})
    
    try:
        program = TrainingPrograms.objects.get(
            id=program_id,
            tenant=request.user.tenant
        )
        
        sessions = TrainingSession.objects.filter(
            program=program,
            start_at__gte=timezone.now()
        ).order_by('start_at')
        
        sessions_data = []
        for session in sessions:
            sessions_data.append({
                'id': session.id,
                'title': session.title or session.program.name,
                'start_at': session.start_at.strftime('%Y-%m-%d %H:%M'),
                'end_at': session.end_at.strftime('%Y-%m-%d %H:%M'),
                'location': session.location or '',
                'delivery_method': session.get_delivery_method_display(),
                'capacity': session.capacity or 0,
                'enrolled_count': session.enrollments.count()
            })
        
        return JsonResponse({'sessions': sessions_data})
    
    except TrainingPrograms.DoesNotExist:
        return JsonResponse({'sessions': []})


@require_http_methods(["GET"])
def get_program_details(request):
    """
    AJAX endpoint to get details for a specific training program.
    """
    program_id = request.GET.get('program_id')
    if not program_id:
        return JsonResponse({'error': 'Program ID required'}, status=400)

    try:
        program = TrainingPrograms.objects.get(
            id=program_id,
            tenant=request.user.tenant
        )

        program_data = {
            'id': program.id,
            'name': program.name,
            'description': program.description,
            'program_type': program.program_type,
            'duration_hours': float(program.duration_hours),
            'cost': float(program.cost),
            'is_certified': program.is_certified,
            'validity_days': program.validity_days,
        }

        return JsonResponse(program_data)

    except TrainingPrograms.DoesNotExist:
        return JsonResponse({'error': 'Program not found'}, status=404)


@login_required
@require_http_methods(["GET"])
def check_time_entry_conflicts(request):
    """
    AJAX endpoint to check for conflicting time entries.
    """
    employee_id = request.GET.get('employee_id')
    date_str = request.GET.get('date')
    start_time_str = request.GET.get('start_time')
    end_time_str = request.GET.get('end_time')
    exclude_id = request.GET.get('exclude_id')

    if not all([employee_id, date_str, start_time_str, end_time_str]):
        return JsonResponse({'error': 'Missing required parameters'}, status=400)

    try:
        employee = Employee.objects.get(id=employee_id, tenant=request.user.tenant)
        date = timezone.datetime.fromisoformat(date_str).date()
        start_time = timezone.datetime.fromisoformat(f"{date_str}T{start_time_str}").time()
        end_time = timezone.datetime.fromisoformat(f"{date_str}T{end_time_str}").time()

        # Convert to datetime for comparison
        start_datetime = timezone.datetime.combine(date, start_time)
        end_datetime = timezone.datetime.combine(date, end_time)

        # Check for overlapping time entries
        conflicting_entries = TimeEntry.objects.filter(
            employee=employee,
            work_date=date
        ).exclude(
            clock_out_time__isnull=True
        )

        if exclude_id:
            conflicting_entries = conflicting_entries.exclude(id=exclude_id)

        conflicts = []
        for entry in conflicting_entries:
            if entry.clock_in_time and entry.clock_out_time:
                # Check for time overlap
                if (entry.clock_in_time < end_datetime and entry.clock_out_time > start_datetime):
                    conflicts.append({
                        'id': entry.id,
                        'start_time': entry.clock_in_time.strftime('%H:%M'),
                        'end_time': entry.clock_out_time.strftime('%H:%M'),
                        'entry_type': entry.get_entry_type_display(),
                        'status': entry.get_status_display()
                    })

        if conflicts:
            message = f"Found {len(conflicts)} conflicting time entr{'y' if len(conflicts) == 1 else 'ies'} for this time period."
            return JsonResponse({
                'conflicts': True,
                'message': message,
                'conflicting_entries': conflicts
            })
        else:
            return JsonResponse({
                'conflicts': False,
                'message': 'No conflicts found.'
            })

    except (Employee.DoesNotExist, ValueError) as e:
        return JsonResponse({'error': 'Invalid parameters'}, status=400)


@login_required
@require_http_methods(["GET"])
def get_employee_schedule_assignments(request):
    """
    AJAX endpoint to get schedule assignments for an employee on a specific date.
    """
    employee_id = request.GET.get('employee_id')
    date_str = request.GET.get('date')

    if not all([employee_id, date_str]):
        return JsonResponse({'error': 'Missing required parameters'}, status=400)

    try:
        employee = Employee.objects.get(id=employee_id, tenant=request.user.tenant)
        date = timezone.datetime.fromisoformat(date_str).date()

        # Get schedule assignments for this employee on this date
        assignments = ScheduleAssignment.objects.filter(
            schedule__employee=employee,
            assignment_date=date,
            status__in=['SCHEDULED', 'CONFIRMED']
        ).select_related('schedule', 'department').order_by('start_time')

        assignments_data = []
        for assignment in assignments:
            assignments_data.append({
                'id': assignment.id,
                'shift_type': assignment.get_shift_type_display(),
                'start_time': assignment.start_time.strftime('%H:%M'),
                'end_time': assignment.end_time.strftime('%H:%M'),
                'department': assignment.department.name if assignment.department else '',
                'location': assignment.location or '',
                'status': assignment.get_status_display(),
                'hours': float(assignment.total_hours)
            })

        return JsonResponse({
            'assignments': assignments_data,
            'count': len(assignments_data)
        })

    except Employee.DoesNotExist:
        return JsonResponse({'error': 'Employee not found'}, status=404)
    except ValueError:
        return JsonResponse({'error': 'Invalid date format'}, status=400)


@login_required
@require_http_methods(["GET"])
def get_schedule_assignment_details(request):
    """
    AJAX endpoint to get details of a specific schedule assignment.
    """
    assignment_id = request.GET.get('assignment_id')

    if not assignment_id:
        return JsonResponse({'error': 'Assignment ID required'}, status=400)

    try:
        assignment = ScheduleAssignment.objects.get(
            id=assignment_id,
            schedule__employee__tenant=request.user.tenant
        )

        assignment_data = {
            'id': assignment.id,
            'shift_type': assignment.get_shift_type_display(),
            'start_time': assignment.start_time.strftime('%H:%M'),
            'end_time': assignment.end_time.strftime('%H:%M'),
            'department': assignment.department.name if assignment.department else '',
            'location': assignment.location or '',
            'status': assignment.get_status_display(),
            'hours': float(assignment.total_hours),
            'break_minutes': assignment.break_minutes,
            'lunch_minutes': assignment.lunch_minutes,
            'notes': assignment.notes or '',
            'assignment_date': assignment.assignment_date.strftime('%Y-%m-%d'),
            'schedule_name': assignment.schedule.name,
            'employee_name': assignment.schedule.employee.get_full_name()
        }

        return JsonResponse(assignment_data)

    except ScheduleAssignment.DoesNotExist:
        return JsonResponse({'error': 'Schedule assignment not found'}, status=404)


@login_required
def export_assignments(request):
    """
    Export schedule assignments in various formats (PDF, Excel, CSV).
    """
    from django.http import HttpResponse
    import csv
    import io
    from datetime import datetime
    
    # Get the format from query parameters
    export_format = request.GET.get('format', 'csv').lower()
    
    # Get filtered queryset based on the same filters as the list view
    queryset = ScheduleAssignment.objects.filter(
        schedule__employee__tenant=request.user.tenant
    ).select_related('schedule__employee', 'department', 'schedule')
    
    # Apply filters
    employee = request.GET.get('employee')
    if employee:
        queryset = queryset.filter(schedule__employee_id=employee)
    
    department = request.GET.get('department')
    if department:
        queryset = queryset.filter(department_id=department)
    
    shift_type = request.GET.get('shift_type')
    if shift_type:
        queryset = queryset.filter(shift_type=shift_type)
    
    date_range = request.GET.get('date_range')
    if date_range and ' - ' in date_range:
        start_date, end_date = date_range.split(' - ')
        queryset = queryset.filter(
            assignment_date__gte=start_date,
            assignment_date__lte=end_date
        )
    
    search = request.GET.get('search')
    if search:
        queryset = queryset.filter(
            Q(schedule__employee__first_name__icontains=search) |
            Q(schedule__employee__last_name__icontains=search) |
            Q(schedule__name__icontains=search)
        )
    
    queryset = queryset.order_by('assignment_date', 'start_time')
    
    if export_format == 'csv':
        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = f'attachment; filename="schedule_assignments_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv"'
        
        writer = csv.writer(response)
        writer.writerow([
            'Employee ID', 'Employee Name', 'Department', 'Schedule', 
            'Date', 'Start Time', 'End Time', 'Shift Type', 'Status', 'Hours'
        ])
        
        for assignment in queryset:
            writer.writerow([
                assignment.schedule.employee.employee_id,
                assignment.schedule.employee.get_full_name(),
                assignment.department.name if assignment.department else '',
                assignment.schedule.name,
                assignment.assignment_date.strftime('%Y-%m-%d'),
                assignment.start_time.strftime('%H:%M'),
                assignment.end_time.strftime('%H:%M'),
                assignment.get_shift_type_display(),
                assignment.get_status_display(),
                f"{assignment.total_hours:.2f}"
            ])
        
        return response
    
    elif export_format == 'excel':
        try:
            import openpyxl
            from openpyxl.utils import get_column_letter
            from openpyxl.styles import Font, PatternFill
            
            wb = openpyxl.Workbook()
            ws = wb.active
            ws.title = "Schedule Assignments"
            
            # Headers
            headers = [
                'Employee ID', 'Employee Name', 'Department', 'Schedule', 
                'Date', 'Start Time', 'End Time', 'Shift Type', 'Status', 'Hours'
            ]
            
            for col, header in enumerate(headers, 1):
                cell = ws.cell(row=1, column=col, value=header)
                cell.font = Font(bold=True)
                cell.fill = PatternFill(start_color="CCCCCC", end_color="CCCCCC", fill_type="solid")
            
            # Data
            for row, assignment in enumerate(queryset, 2):
                ws.cell(row=row, column=1, value=assignment.schedule.employee.employee_id)
                ws.cell(row=row, column=2, value=assignment.schedule.employee.get_full_name())
                ws.cell(row=row, column=3, value=assignment.department.name if assignment.department else '')
                ws.cell(row=row, column=4, value=assignment.schedule.name)
                ws.cell(row=row, column=5, value=assignment.assignment_date.strftime('%Y-%m-%d'))
                ws.cell(row=row, column=6, value=assignment.start_time.strftime('%H:%M'))
                ws.cell(row=row, column=7, value=assignment.end_time.strftime('%H:%M'))
                ws.cell(row=row, column=8, value=assignment.get_shift_type_display())
                ws.cell(row=row, column=9, value=assignment.get_status_display())
                ws.cell(row=row, column=10, value=float(assignment.total_hours))
            
            # Auto-adjust column widths
            for col in range(1, len(headers) + 1):
                ws.column_dimensions[get_column_letter(col)].auto_size = True
            
            response = HttpResponse(
                content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
            )
            response['Content-Disposition'] = f'attachment; filename="schedule_assignments_{datetime.now().strftime("%Y%m%d_%H%M%S")}.xlsx"'
            
            wb.save(response)
            return response
            
        except ImportError:
            messages.error(request, 'Excel export requires openpyxl package.')
            return redirect('hr:schedule_assignment_list')
    
    elif export_format == 'pdf':
        try:
            from reportlab.lib import colors
            from reportlab.lib.pagesizes import letter, A4
            from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer
            from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
            from reportlab.lib.units import inch
            
            response = HttpResponse(content_type='application/pdf')
            response['Content-Disposition'] = f'attachment; filename="schedule_assignments_{datetime.now().strftime("%Y%m%d_%H%M%S")}.pdf"'
            
            doc = SimpleDocTemplate(response, pagesize=A4)
            elements = []
            styles = getSampleStyleSheet()
            
            # Title
            title_style = ParagraphStyle(
                'CustomTitle',
                parent=styles['Heading1'],
                fontSize=16,
                spaceAfter=30,
                alignment=1  # Center alignment
            )
            title = Paragraph("Schedule Assignments Report", title_style)
            elements.append(title)
            elements.append(Spacer(1, 12))
            
            # Table data
            data = [['Employee', 'Department', 'Date', 'Time', 'Shift', 'Status']]
            
            for assignment in queryset:
                data.append([
                    assignment.schedule.employee.get_full_name(),
                    assignment.department.name if assignment.department else '',
                    assignment.assignment_date.strftime('%m/%d/%Y'),
                    f"{assignment.start_time.strftime('%H:%M')}-{assignment.end_time.strftime('%H:%M')}",
                    assignment.get_shift_type_display(),
                    assignment.get_status_display()
                ])
            
            # Create table
            table = Table(data)
            table.setStyle(TableStyle([
                ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
                ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
                ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
                ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
                ('FONTSIZE', (0, 0), (-1, 0), 10),
                ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
                ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
                ('FONTNAME', (0, 1), (-1, -1), 'Helvetica'),
                ('FONTSIZE', (0, 1), (-1, -1), 8),
                ('GRID', (0, 0), (-1, -1), 1, colors.black)
            ]))
            
            elements.append(table)
            doc.build(elements)
            return response
            
        except ImportError:
            messages.error(request, 'PDF export requires reportlab package.')
            return redirect('hr:schedule_assignment_list')
    
    else:
        messages.error(request, 'Invalid export format.')
        return redirect('hr:schedule_assignment_list')