import json
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_http_methods
from .models import PushDevice

@csrf_exempt
@require_http_methods(["POST"])
def register_device(request):
    """
    Registers or updates a push notification device token.
    Expects JSON payload:
    {
        "device_token": "ExponentPushToken[...]",
        "platform": "ios" | "android" | "web",
        "device_id": "...",
        "app_version": "1.0",
        "os_version": "15.0"
    }
    """
    try:
        data = json.loads(request.body)
    except json.JSONDecodeError:
        return JsonResponse({"error": "Invalid JSON"}, status=400)
    
    device_token = data.get("device_token")
    if not device_token:
        return JsonResponse({"error": "device_token is required"}, status=400)
    
    platform = data.get("platform", "unknown")
    device_id = data.get("device_id", "")
    app_version = data.get("app_version", "")
    os_version = data.get("os_version", "")
    
    user = request.user if request.user.is_authenticated else None
    
    # Upsert the device token
    device, created = PushDevice.objects.update_or_create(
        device_token=device_token,
        defaults={
            "user": user,
            "platform": platform,
            "device_id": device_id,
            "app_version": app_version,
            "os_version": os_version,
            "is_active": True
        }
    )
    
    return JsonResponse({
        "status": "success",
        "message": "Device registered successfully",
        "is_new": created
    })

def contact_us(request):
    from django.shortcuts import render
    from .models import ContactQuery
    
    context = {}
    if request.method == "POST":
        name = request.POST.get("name")
        email = request.POST.get("email")
        subject = request.POST.get("subject")
        message = request.POST.get("message")
        
        if name and email and subject and message:
            ContactQuery.objects.create(
                name=name,
                email=email,
                subject=subject,
                message=message
            )
            context["success"] = True
        else:
            context["error"] = "Please fill out all fields."
            
    return render(request, "core/contact_us.html", context)

@csrf_exempt
@require_http_methods(["POST"])
def extract_statement(request):
    """
    Extracts category and entities from a natural language statement using AI models.
    Expects JSON payload:
    {
        "statement": "paisy aaye meezan bank mein"
    }
    """
    try:
        data = json.loads(request.body)
    except json.JSONDecodeError:
        return JsonResponse({"error": "Invalid JSON"}, status=400)
        
    statement = data.get("statement")
    if not statement:
        return JsonResponse({"error": "statement is required"}, status=400)
        
    try:
        from core.services.ai_extractor import AIExtractorService
        service = AIExtractorService()
        result = service.process_statement(statement)
        return JsonResponse({"status": "success", "data": result})
    except Exception as e:
        return JsonResponse({"status": "error", "message": str(e)}, status=500)

@csrf_exempt
@require_http_methods(["POST"])
def send_custom_notification(request):
    """
    Sends a custom notification to all active devices or a specific device.
    Ideal for sending updates regarding new application features.
    
    Expects JSON payload:
    {
        "title": "New Update!",
        "message": "Check out the new features.",
        "device_token": "ExponentPushToken[...]", # Optional, if omitted sends to all active devices
        "extra": {"url": "app://update"} # Optional
    }
    """
    try:
        data = json.loads(request.body)
    except json.JSONDecodeError:
        return JsonResponse({"error": "Invalid JSON"}, status=400)

    title = data.get("title")
    message = data.get("message")
    
    if not title or not message:
        return JsonResponse({"error": "title and message are required"}, status=400)

    device_token = data.get("device_token")
    extra = data.get("extra", {})

    from .push import send_push_message

    success_count = 0
    failure_count = 0

    if device_token:
        # Send to a single specified device
        success = send_push_message(device_token, title, message, extra)
        if success:
            success_count += 1
        else:
            failure_count += 1
    else:
        # Send to all active devices
        devices = PushDevice.objects.filter(is_active=True)
        for device in devices:
            success = send_push_message(device.device_token, title, message, extra)
            if success:
                success_count += 1
            else:
                failure_count += 1
                # Mark token as inactive if it fails (likely unregistered)
                device.is_active = False
                device.save(update_fields=['is_active'])

    return JsonResponse({
        "status": "success",
        "message": "Push notifications processed.",
        "success_count": success_count,
        "failure_count": failure_count
    })