training-software/training/views.py

from django.shortcuts import get_object_or_404
from rest_framework import status
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from rest_framework.views import APIView

from .models import CallSession, EmployeeAttendance, Meeting, MeetingParticipant, TrainingRecord
from .permissions import IsMeetingModerator, IsTrainer
from .serializers import (
    CallEventSerializer,
    CallModerationRequestSerializer,
    CallParticipantSerializer,
    CallSessionSerializer,
    EmployeeAttendanceSerializer,
    MeetingAttendanceRequestSerializer,
    MeetingParticipantSerializer,
    MeetingSerializer,
    SignoffRequestSerializer,
    TrainerSignoffSerializer,
    TrainingRecordSerializer,
)
from .services import (
    CallSessionError,
    InvalidTransitionError,
    apply_moderation_action,
    end_call_session,
    get_or_create_call_session,
    mark_in_progress,
    mark_online_passed,
    record_meeting_attendance,
    submit_trainer_signoff,
    toggle_screen_share,
)


class TrainingRecordDetailView(APIView):
    permission_classes = [IsAuthenticated]

    def get(self, request, record_id):
        record = get_object_or_404(
            TrainingRecord,
            pk=record_id,
            enrollment__user=request.user,
        )
        return Response(TrainingRecordSerializer(record).data)


class MarkInProgressView(APIView):
    permission_classes = [IsAuthenticated]

    def post(self, request, record_id):
        record = get_object_or_404(
            TrainingRecord, pk=record_id, enrollment__user=request.user
        )
        try:
            record = mark_in_progress(record)
        except InvalidTransitionError as exc:
            return Response({"detail": str(exc)}, status=status.HTTP_409_CONFLICT)
        return Response(TrainingRecordSerializer(record).data)


class MarkOnlinePassedView(APIView):
    permission_classes = [IsAuthenticated]

    def post(self, request, record_id):
        record = get_object_or_404(
            TrainingRecord, pk=record_id, enrollment__user=request.user
        )
        try:
            record = mark_online_passed(record)
        except InvalidTransitionError as exc:
            return Response({"detail": str(exc)}, status=status.HTTP_409_CONFLICT)
        return Response(TrainingRecordSerializer(record).data)


class TrainerSignoffView(APIView):
    permission_classes = [IsAuthenticated, IsTrainer]

    def post(self, request, record_id):
        record = get_object_or_404(TrainingRecord, pk=record_id)
        serializer = SignoffRequestSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        try:
            signoff = submit_trainer_signoff(
                record,
                trainer=request.user,
                decision=serializer.validated_data["decision"],
                notes=serializer.validated_data["notes"],
            )
        except InvalidTransitionError as exc:
            return Response({"detail": str(exc)}, status=status.HTTP_409_CONFLICT)

        return Response(TrainerSignoffSerializer(signoff).data, status=status.HTTP_201_CREATED)


class PendingSignoffListView(APIView):
    permission_classes = [IsAuthenticated, IsTrainer]

    def get(self, request):
        from .models import CompletionStatus
        records = TrainingRecord.objects.filter(
            status__in=[CompletionStatus.PENDING_SIGNOFF, CompletionStatus.IN_PROGRESS],
        ).select_related("enrollment__user", "enrollment__course")
        return Response(TrainingRecordSerializer(records, many=True).data)


class MeetingListCreateView(APIView):
    permission_classes = [IsAuthenticated, IsTrainer]

    def get(self, request):
        return Response(MeetingSerializer(Meeting.objects.all(), many=True).data)

    def post(self, request):
        serializer = MeetingSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        meeting = serializer.save()
        return Response(MeetingSerializer(meeting).data, status=status.HTTP_201_CREATED)


class MeetingParticipantsCreateView(APIView):
    permission_classes = [IsAuthenticated, IsTrainer]

    def post(self, request, meeting_id):
        meeting = get_object_or_404(Meeting, pk=meeting_id)
        serializer = MeetingParticipantSerializer(data={
            "meeting": str(meeting.id),
            "user": request.data.get("user"),
        })
        serializer.is_valid(raise_exception=True)
        participant = MeetingParticipant.objects.create(
            meeting=meeting,
            user_id=serializer.validated_data["user"].id,
        )
        return Response(MeetingParticipantSerializer(participant).data, status=status.HTTP_201_CREATED)


class MeetingAttendanceView(APIView):
    permission_classes = [IsAuthenticated, IsTrainer]

    def post(self, request, meeting_id):
        meeting = get_object_or_404(Meeting, pk=meeting_id)
        serializer = MeetingAttendanceRequestSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        participant = get_object_or_404(
            MeetingParticipant,
            meeting=meeting,
            user_id=serializer.validated_data["user_id"],
        )

        participant = record_meeting_attendance(
            meeting,
            user_id=participant.user_id,
            status_value=serializer.validated_data["status"],
            actor=request.user,
        )
        return Response(MeetingParticipantSerializer(participant).data)


class MeetingDetailView(APIView):
    permission_classes = [IsAuthenticated, IsTrainer]

    def get(self, request, meeting_id):
        meeting = get_object_or_404(Meeting, pk=meeting_id)
        participants = meeting.participants.select_related("user", "attendance_recorded_by")
        data = MeetingSerializer(meeting).data
        data["participants"] = MeetingParticipantSerializer(participants, many=True).data
        return Response(data)


class MeetingCallSessionView(APIView):
    """
    GET  /meetings/{id}/call/   — get current call session state (participants + trainer)
    POST /meetings/{id}/call/   — start or resume a call session (trainer only)
    DELETE /meetings/{id}/call/ — end a call session (trainer only); sends session_ended to all WS clients
    """

    def get_permissions(self):
        if self.request.method in ("POST", "DELETE"):
            return [IsAuthenticated(), IsMeetingModerator()]
        return [IsAuthenticated()]

    def get(self, request, meeting_id):
        meeting = get_object_or_404(Meeting, pk=meeting_id)
        try:
            session = meeting.call_session
        except CallSession.DoesNotExist:
            return Response({"detail": "No call session exists for this meeting."}, status=status.HTTP_404_NOT_FOUND)
        return Response(CallSessionSerializer(session).data)

    def post(self, request, meeting_id):
        meeting = get_object_or_404(Meeting, pk=meeting_id)
        try:
            session = get_or_create_call_session(meeting, actor=request.user)
        except CallSessionError as exc:
            return Response({"detail": str(exc)}, status=status.HTTP_409_CONFLICT)
        return Response(CallSessionSerializer(session).data, status=status.HTTP_201_CREATED)

    def delete(self, request, meeting_id):
        meeting = get_object_or_404(Meeting, pk=meeting_id)
        try:
            session = meeting.call_session
        except CallSession.DoesNotExist:
            return Response({"detail": "No call session found."}, status=status.HTTP_404_NOT_FOUND)
        try:
            session = end_call_session(session, actor=request.user)
        except CallSessionError as exc:
            return Response({"detail": str(exc)}, status=status.HTTP_409_CONFLICT)

        _broadcast_session_ended(str(meeting.id))
        return Response(CallSessionSerializer(session).data)


class MeetingCallModerationView(APIView):
    """
    POST /meetings/{id}/call/moderate/
    Body: {"action": "mute"|"unmute"|"kick", "user_id": "<uuid>"}
    Moderator-only (meeting:moderate capability). Writes audit event + broadcasts WS event.
    """

    permission_classes = [IsAuthenticated, IsMeetingModerator]

    def post(self, request, meeting_id):
        meeting = get_object_or_404(Meeting, pk=meeting_id)
        try:
            session = meeting.call_session
        except CallSession.DoesNotExist:
            return Response({"detail": "No active call session."}, status=status.HTTP_404_NOT_FOUND)

        serializer = CallModerationRequestSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        action = serializer.validated_data["action"]
        target_user_id = serializer.validated_data["user_id"]

        try:
            apply_moderation_action(session, action, target_user_id, actor=request.user)
        except CallSessionError as exc:
            return Response({"detail": str(exc)}, status=status.HTTP_400_BAD_REQUEST)

        _broadcast_moderation(str(meeting.id), action, str(target_user_id), str(request.user.id))
        return Response({"detail": f"{action} applied."})


class MeetingCallScreenShareView(APIView):
    """
    POST /meetings/{id}/call/screen-share/
    Body: {"action": "start"|"stop"}
    Moderator-only. Only users with meeting:moderate can start/stop screen sharing.
    """

    permission_classes = [IsAuthenticated, IsMeetingModerator]

    def post(self, request, meeting_id):
        meeting = get_object_or_404(Meeting, pk=meeting_id)
        try:
            session = meeting.call_session
        except CallSession.DoesNotExist:
            return Response({"detail": "No active call session."}, status=status.HTTP_404_NOT_FOUND)

        action = request.data.get("action")
        if action not in ("start", "stop"):
            return Response({"detail": "action must be 'start' or 'stop'."}, status=status.HTTP_400_BAD_REQUEST)

        try:
            cp = toggle_screen_share(session, actor=request.user, start=(action == "start"))
        except CallSessionError as exc:
            return Response({"detail": str(exc)}, status=status.HTTP_400_BAD_REQUEST)

        _broadcast_screen_share(str(meeting.id), action, str(request.user.id))
        return Response(CallParticipantSerializer(cp).data)


class MeetingCallEventsView(APIView):
    """
    GET /meetings/{id}/call/events/ — audit log for moderation/session events (moderator only)
    """

    permission_classes = [IsAuthenticated, IsMeetingModerator]

    def get(self, request, meeting_id):
        meeting = get_object_or_404(Meeting, pk=meeting_id)
        try:
            session = meeting.call_session
        except CallSession.DoesNotExist:
            return Response({"detail": "No call session found."}, status=status.HTTP_404_NOT_FOUND)
        events = session.events.select_related("actor", "target_user")
        return Response(CallEventSerializer(events, many=True).data)


def _broadcast_session_ended(meeting_id: str):
    from asgiref.sync import async_to_sync
    from channels.layers import get_channel_layer

    channel_layer = get_channel_layer()
    if channel_layer is None:
        return
    group = f"meeting_call_{meeting_id}"
    async_to_sync(channel_layer.group_send)(group, {"type": "call.session_ended"})


def _broadcast_moderation(meeting_id: str, action: str, user_id: str, by: str):
    from asgiref.sync import async_to_sync
    from channels.layers import get_channel_layer

    channel_layer = get_channel_layer()
    if channel_layer is None:
        return
    group = f"meeting_call_{meeting_id}"

    if action == "kick":
        msg = {"type": "call.kicked", "user_id": user_id, "kicked_by": by}
    elif action == "mute":
        msg = {"type": "call.muted", "user_id": user_id, "by": by}
    else:
        msg = {"type": "call.unmuted", "user_id": user_id, "by": by}

    async_to_sync(channel_layer.group_send)(group, msg)


def _broadcast_screen_share(meeting_id: str, action: str, by: str):
    from asgiref.sync import async_to_sync
    from channels.layers import get_channel_layer

    channel_layer = get_channel_layer()
    if channel_layer is None:
        return
    group = f"meeting_call_{meeting_id}"
    msg_type = "call.screen_share_started" if action == "start" else "call.screen_share_stopped"
    async_to_sync(channel_layer.group_send)(group, {"type": msg_type, "by": by})


class EmployeeAttendanceListView(APIView):
    """
    GET  /training/attendance/          — own attendance history
    GET  /training/attendance/?user=id  — another user's history (trainer/manager/admin only)
    """

    permission_classes = [IsAuthenticated]

    def get(self, request):
        target_user_id = request.query_params.get("user")
        if target_user_id and target_user_id != str(request.user.id):
            from accounts.services import get_effective_capabilities
            caps = get_effective_capabilities(request.user)
            if not any(c in caps for c in ("progress:view_all", "progress:view_team", "users:manage")):
                return Response({"detail": "Permission denied."}, status=403)
            qs = EmployeeAttendance.objects.filter(user_id=target_user_id)
        else:
            qs = EmployeeAttendance.objects.filter(user=request.user)

        qs = qs.select_related("meeting", "updated_by").order_by("-attendance_date")
        return Response(EmployeeAttendanceSerializer(qs, many=True).data)