# assistant/views.py — heavily simplified
import pickle
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
import json

# Loaded at startup — takes 8 seconds
model = pickle.load(open("/models/classifier.pkl", "rb"))  # Deserialize the trained ML model from disk once at import time
vectorizer = pickle.load(open("/models/vectorizer.pkl", "rb"))  # Deserialize the text vectorizer (e.g., TF-IDF) once at import time

@csrf_exempt  # Disable Django CSRF protection for this API-style endpoint
def assistant_view(request):
    if request.method != "POST":  # Reject non-POST HTTP methods
        return JsonResponse({"error": "POST required"}, status=405)  # Return 405 Method Not Allowed if not POST

    data = json.loads(request.body)  # Parse the incoming JSON request body into a Python dict
    user_text = data["text"]  # Extract the user's input text from the parsed JSON payload

    # Preprocessing
    tokens = tokenize(user_text)  # Tokenize the raw text into tokens (words, subwords, etc.)
    features = vectorizer.transform([tokens])  # Convert tokens into a numerical feature vector the model understands

    # Inference — the slow part
    prediction = model.predict(features)[0]  # Run the model to get the predicted class (first/only prediction)
    confidence = max(model.predict_proba(features)[0])  # Get the probability of the most likely class as confidence

    # Post-processing
    response = format_response(prediction, confidence)  # Format the raw prediction into a user-friendly response dict
    return JsonResponse(response)  # Serialize the response dict to JSON and return it to the client

def health(request):
    return JsonResponse({"status": "ok"})  # Simple health-check endpoint returning a success status

# urls.py
from django.urls import path
from assistant.views import assistant_view, health

urlpatterns = [
    path("assistant", assistant_view),  # Route /assistant to the inference endpoint
    path("health", health),  # Route /health to the health-check endpoint
]

# assistant/inference_client.py
import os
import json
import pickle
from urllib.request import Request, urlopen
from urllib.error import URLError

class InferenceClient:
    """Routes to in-process model or remote service based on config."""
    def __init__(self):
        self.mode = os.getenv("INFERENCE_MODE", "local")  # Read the routing mode from env var, default to local inference
        self.remote_url = os.getenv("INFERENCE_URL", "http://localhost:8001/predict")  # URL of the remote inference service
        self.model = None  # Placeholder for the ML model (loaded lazily below)
        self.vectorizer = None  # Placeholder for the vectorizer (loaded lazily below)

        if self.mode in ("local", "shadow", "canary"):  # Only load the model locally if we might need it
            self.model = pickle.load(open("/models/classifier.pkl", "rb"))  # Deserialize the trained classifier into memory
            self.vectorizer = pickle.load(open("/models/vectorizer.pkl", "rb"))  # Deserialize the text vectorizer into memory

    def predict(self, text: str) -> dict:
        if self.mode == "local":  # In local mode, run inference in-process
            return self._predict_local(text)  # Delegate to the local prediction method
        else:  # In remote/shadow/canary mode, call the external inference service
            return self._predict_remote(text)  # Delegate to the remote prediction method

    def _predict_local(self, text: str) -> dict:
        tokens = tokenize(text)  # Tokenize the input text
        features = self.vectorizer.transform([tokens])  # Vectorize the tokens into numerical features
        pred = self.model.predict(features)[0]  # Get the model's predicted class label
        conf = max(self.model.predict_proba(features)[0])  # Get the confidence score (highest probability)
        return {"prediction": pred, "confidence": float(conf)}  # Return structured result with native float type

    def _predict_remote(self, text: str) -> dict:
        body = json.dumps({"text": text}).encode()  # Serialize the input text to JSON bytes for the HTTP request body
        req = Request(self.remote_url, data=body, headers={"Content-Type": "application/json"})  # Build the HTTP POST request
        try:
            resp = urlopen(req, timeout=5)  # Send the request with a 5-second timeout to prevent hanging
            return json.loads(resp.read())  # Parse and return the JSON response from the remote service
        except URLError as e:  # Catch network/connection errors from the remote call
            raise RuntimeError(f"Remote inference failed: {e}")  # Re-raise as a generic runtime error for the caller

# assistant/views.py
from django.http import JsonResponse, HttpResponseNotAllowed
from django.views.decorators.csrf import csrf_exempt
import json
from .inference_client import InferenceClient

client = InferenceClient()  # Instantiate the client once at module level (singleton per worker)

@csrf_exempt  # Disable CSRF for this API-style endpoint
def assistant_view(request):
    if request.method != "POST":  # Validate that this is a POST request
        return HttpResponseNotAllowed(["POST"])  # Return 405 with allowed methods if not POST

    data = json.loads(request.body)  # Parse the JSON request body
    result = client.predict(data["text"])  # Delegate inference to the client (local or remote based on mode)
    response = format_response(result["prediction"], result["confidence"])  # Format the structured result for the user
    return JsonResponse(response)  # Send the formatted response back to the client

def health(request):
    return JsonResponse({"status": "ok"})  # Health-check endpoint returning a simple success status

# inference_service/manage.py — Django project for inference only
# inference_service/inference/views.py
import pickle
import json
import time
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt

model = pickle.load(open("/models/classifier.pkl", "rb"))  # Load the ML model into memory at startup
vectorizer = pickle.load(open("/models/vectorizer.pkl", "rb"))  # Load the vectorizer into memory at startup

@csrf_exempt  # Disable CSRF for this internal-service endpoint
def predict_view(request):
    if request.method != "POST":  # Reject non-POST requests
        return JsonResponse({"error": "POST required"}, status=405)  # Return 405 with error message

    data = json.loads(request.body)  # Parse the incoming JSON request
    start = time.time()  # Record the start time for latency measurement

    tokens = tokenize(data["text"])  # Tokenize the user's input text
    features = vectorizer.transform([tokens])  # Convert tokens to feature vectors
    pred = model.predict(features)[0]  # Run inference to get the predicted class
    conf = max(model.predict_proba(features)[0])  # Extract the confidence score from class probabilities

    return JsonResponse({  # Return a JSON response with prediction details
        "prediction": pred,  # The predicted class label
        "confidence": float(conf),  # The confidence score as a native float
        "latency_ms": round((time.time() - start) * 1000),  # Compute and return the request latency in milliseconds
    })

def health(request):
    return JsonResponse({"status": "ok"})  # Health-check endpoint for load balancer liveness probes

# assistant/inference_client.py
import logging

logger = logging.getLogger(__name__)  # Create a module-level logger for tracking shadow-mode results

class InferenceClient:
    def predict(self, text: str):
        local_result = self._predict_local(text)  # Always run local inference first to get the baseline result

        if self.mode == "shadow":  # In shadow mode, also call the remote service but don't use its result
            # Fire-and-forget to the remote service — log but don't block
            try:
                remote_result = self._predict_remote(text)  # Send the same text to the remote inference service
                if remote_result["prediction"] != local_result["prediction"]:  # Check if the two services disagree
                    logger.warning(  # Log the mismatch for offline analysis
                        "Prediction mismatch",
                        extra={"local": local_result, "remote": remote_result},  # Include both results in structured log
                    )
            except Exception as e:  # Catch any error from the remote call (timeout, network, etc.)
                logger.warning(f"Shadow inference failed: {e}")  # Log the failure but don't surface it to the user

        return local_result  # Always return the local result to the caller regardless of shadow outcome

# assistant/management/commands/compare_predictions.py
from django.core.management.base import BaseCommand
import json

class Command(BaseCommand):
    help = "Analyze shadow mode prediction mismatches from logs"  # Description shown in manage.py help output

    def handle(self, *args, **options):  # Entry point called when this management command runs
        # Parse your structured logs and report mismatch rate
        pass  # TODO: implement log parsing and mismatch analysis logic

# assistant/inference_client.py
class InferenceClient:
    def predict(self, user_id: str, text: str) -> dict:
        should_canary = (
            self.mode == "remote"  # Always route to remote in full-remote mode
            or (self.mode == "canary" and hash(user_id) % 100 < 1)  # In canary mode, route 1% of users by user ID hash
        )

        if should_canary:  # This request should be handled by the remote service
            try:
                return self._predict_remote(text)  # Send the request to the external inference service
            except Exception as e:  # Remote call failed (timeout, network error, service down)
                logger.error(f"Remote failed, falling back to local: {e}")  # Log the failure for monitoring
                return self._predict_local(text)  # Fall back to the in-process model to avoid serving an error
        else:  # This request stays on the local model (either not in canary group or mode is local)
            return self._predict_local(text)  # Run inference in-process with the local model

@csrf_exempt  # Disable CSRF protection for this API endpoint
def assistant_view(request):
    data = json.loads(request.body)  # Parse the JSON request body
    user_id = data.get("user_id", "anonymous")  # Extract user ID from payload, defaulting to "anonymous" if missing
    result = client.predict(user_id, data["text"])  # Call the client with user ID for consistent canary routing
    return JsonResponse(format_response(result["prediction"], result["confidence"]))  # Format and return the result

# assistant/monitoring.py
import logging
import time

inference_logger = logging.getLogger("inference")  # Create a dedicated logger for inference events

def record_inference(mode: str, latency_ms: float, user_id: str):  # Log inference metrics for observability
    inference_logger.info("inference_completed", extra={  # Emit a structured log line for log aggregators
        "mode": mode,  # Which inference mode was used (local, remote, canary, shadow)
        "latency_ms": latency_ms,  # How long the inference took in milliseconds
        "user_id": user_id[-4:],  # Only the last 4 characters of the user ID for privacy compliance
    })

# assistant/inference_client.py
class InferenceClient:
    def __init__(self):
        self.remote_url = os.getenv("INFERENCE_URL", "http://inference:8001/predict")  # Read remote service URL from env, with K8s service DNS as default

    def predict(self, text: str) -> dict:
        body = json.dumps({"text": text}).encode()  # Serialize the input text to JSON bytes
        req = Request(self.remote_url, data=body, headers={"Content-Type": "application/json"})  # Build the HTTP POST request
        resp = urlopen(req, timeout=5)  # Send the request with a 5-second timeout
        return json.loads(resp.read())  # Parse and return the JSON response from the remote service

# settings.py — before
INSTALLED_APPS = [
    "django.contrib.auth",  # Authentication framework
    "django.contrib.contenttypes",  # Content type framework (required by auth and permissions)
    "assistant",  # The main assistant application
    "inference_engine",  # No longer needed  # Inference-specific app that can be removed after extraction
]

# settings.py — after
INSTALLED_APPS = [
    "django.contrib.auth",  # Authentication framework
    "django.contrib.contenttypes",  # Content type framework
    "assistant",  # The main assistant application
]

# inference_service/inference/views.py
import hashlib
import json
from django.core.cache import cache

@csrf_exempt  # Disable CSRF for this internal-service endpoint
def predict_view(request):
    data = json.loads(request.body)  # Parse the incoming JSON request
    text_hash = hashlib.sha256(data["text"].encode()).hexdigest()  # Compute a SHA-256 hash of the input text to use as cache key

    # Check cache
    cached = cache.get(f"pred:{text_hash}")  # Look up the prediction result in the cache by its key
    if cached:  # Cache hit — a previous identical query was made recently
        return JsonResponse(json.loads(cached))  # Return the cached result directly, skipping inference entirely

    # Run inference
    tokens = tokenize(data["text"])  # Tokenize the input text
    features = vectorizer.transform([tokens])  # Convert tokens to feature vectors
    pred = model.predict(features)[0]  # Run the model to get the predicted class
    conf = max(model.predict_proba(features)[0])  # Get the confidence score
    result = {"prediction": pred, "confidence": float(conf)}  # Build the result dictionary

    # Cache for 1 hour
    cache.set(f"pred:{text_hash}", json.dumps(result), timeout=3600)  # Store the serialized result in cache with a 1-hour TTL
    return JsonResponse(result)  # Return the fresh prediction result to the client