apps/intelligence/views.py

"""
Views for the intelligence app.
"""
from django.contrib.auth.decorators import login_required
from django.shortcuts import render, redirect, get_object_or_404
from django.http import HttpResponseNotAllowed, HttpResponseBadRequest
from django.views.decorators.http import require_GET

from apps.intelligence.services import (
    get_events,
    get_user_sessions,
)


@login_required
@require_GET
def event_log_view(request):
    """View recent platform events."""
    events = get_events(limit=50)
    return render(request, "intelligence/event_log.html", {"events": events})


@login_required
@require_GET
def chat_sessions_view(request):
    """View user's chat history."""
    sessions = get_user_sessions(request.user)
    return render(request, "intelligence/chat_sessions.html", {"sessions": sessions})


@login_required
@require_GET
def analytics_dashboard_view(request):
    """Security & analytics overview dashboard."""
    from django.contrib.auth import get_user_model
    from django.utils import timezone
    from datetime import timedelta

    from apps.intelligence.models import (
        Anomaly,
        APIRequestLog,
        RiskScore,
    )
    from apps.security.models import SecurityEvent

    User = get_user_model()
    now = timezone.now()
    last_24h = now - timedelta(hours=24)
    last_7d = now - timedelta(days=7)

    # ── Summary cards ──
    total_users = User.objects.count()
    active_users_24h = User.objects.filter(last_login__gte=last_24h).count()
    high_risk_users = RiskScore.objects.filter(score__gte=0.7).values("user").distinct().count()
    anomaly_count_7d = Anomaly.objects.filter(created_at__gte=last_7d).count()
    api_requests_24h = APIRequestLog.objects.filter(created_at__gte=last_24h).count()

    # ── Recent anomalies ──
    recent_anomalies = Anomaly.objects.select_related("user").order_by("-created_at")[:10]

    # ── Recent security events ──
    recent_events = SecurityEvent.objects.select_related("user").order_by("-created_at")[:10]

    # ── Top risk scores ──
    top_risks = (
        RiskScore.objects.select_related("user")
        .order_by("-score")[:10]
    )

    context = {
        "total_users": total_users,
        "active_users_24h": active_users_24h,
        "high_risk_users": high_risk_users,
        "anomaly_count_7d": anomaly_count_7d,
        "api_requests_24h": api_requests_24h,
        "recent_anomalies": recent_anomalies,
        "recent_events": recent_events,
        "top_risks": top_risks,
    }
    return render(request, "pages/intelligence/dashboard.html", context)


@login_required
@require_GET
def chat_detail_view(request, session_id):
    """View a specific chat session."""
    from apps.intelligence.models import ChatSession
    from core.exceptions import NotFoundError
    
    try:
        session = ChatSession.objects.get(pk=session_id, user=request.user)
    except ChatSession.DoesNotExist:
        raise NotFoundError("Session not found.")
        
    messages = session.messages.all().order_by("created_at")
    return render(request, "intelligence/chat.html", {
        "session": session,
        "messages": messages,
    })


@login_required
def chat_message_create_view(request, session_id):
    """
    HTMX endpoint to send a message and get the AI response.
    Returns the partial HTML for the new messages (User + AI).
    """
    if request.method != "POST":
        return HttpResponseNotAllowed(["POST"])
        
    from apps.intelligence.services import generate_rag_response
    
    content = request.POST.get("content", "").strip()
    if not content:
        return HttpResponseBadRequest("Content is required.")

    # Generate response (Business Logic)
    # This creates both the User message and the AI response message
    ai_message = generate_rag_response(session_id, content)
    
    # We need to render the *two* new messages: the user's input and the AI's response.
    # However, logic in generate_response adds them to DB. 
    # Let's get them from the DB or just construct the context.
    # A simple way is to fetch the last 2 messages from the session.
    
    new_messages = [
        ai_message.session.messages.all().order_by("-created_at")[1], # User msg
        ai_message # AI msg
    ]
    
    return render(request, "intelligence/message_list.html", {"messages": new_messages})


@login_required
def start_chat_view(request):
    """Start a new chat session."""
    from apps.intelligence.services import create_session
    session = create_session(request.user, title="New Chat")
    return redirect("intelligence:chat-detail", session_id=session.id)