import os
import uuid
from typing import Any

from django.core.files.storage import default_storage
from django.utils import timezone
from rest_framework import permissions, status
from rest_framework.response import Response
from rest_framework.views import APIView

from apps.masterdata.platform_setting import PlatformSetting
from apps.notifications.models import Notification
from apps.notifications.whatsapp_service import send_whatsapp_message


def _split_recipients(raw: Any) -> list[str]:
    if isinstance(raw, list):
        return [str(x).strip() for x in raw if str(x).strip()]

    text = str(raw or "")
    if not text.strip():
        return []

    for sep in ["\n", ";", "|"]:
        text = text.replace(sep, ",")
    return [chunk.strip() for chunk in text.split(",") if chunk.strip()]


def _persist_upload_and_build_url(request, uploaded_file) -> str:
    ext = os.path.splitext(uploaded_file.name or "")[1] or ""
    rel_path = f"whatsapp/uploads/{timezone.now().strftime('%Y/%m/%d')}/{uuid.uuid4().hex}{ext}"
    saved_path = default_storage.save(rel_path, uploaded_file)
    file_url = default_storage.url(saved_path)
    return request.build_absolute_uri(file_url)


class AdminWhatsAppSendView(APIView):
    permission_classes = [permissions.IsAdminUser]

    def post(self, request):
        recipients = _split_recipients(request.data.get("recipients"))
        message_type = str(request.data.get("message_type") or "text").strip().lower()
        text = str(request.data.get("text") or "").strip()
        media_url = str(request.data.get("media_url") or "").strip()
        media_file = request.FILES.get("media_file")

        if not recipients:
            return Response({"detail": "At least one recipient is required."}, status=status.HTTP_400_BAD_REQUEST)

        allowed_types = {"text", "image", "video", "audio", "document"}
        if message_type not in allowed_types:
            return Response({"detail": "message_type must be one of: text, image, video, audio, document."}, status=status.HTTP_400_BAD_REQUEST)

        if message_type == "text" and not text:
            return Response({"detail": "text is required for text messages."}, status=status.HTTP_400_BAD_REQUEST)

        if message_type in {"image", "video", "audio", "document"}:
            if media_file is not None:
                media_url = _persist_upload_and_build_url(request, media_file)
            if not media_url:
                return Response({"detail": "media_url or media_file is required for media messages."}, status=status.HTTP_400_BAD_REQUEST)

        provider = (PlatformSetting.get_value("whatsapp_active_provider", "meta_cloud") or "meta_cloud").strip()
        results = []
        success_count = 0
        failed_count = 0

        for recipient in recipients:
            result = send_whatsapp_message(
                recipient=recipient,
                message_type=message_type,
                text=text,
                media_url=media_url,
            )
            ok = bool(result.get("ok"))
            if ok:
                success_count += 1
            else:
                failed_count += 1

            Notification.objects.create(
                channel="whatsapp",
                recipient=result.get("recipient") or recipient,
                subject=f"WhatsApp {message_type} message",
                message=text,
                payload={
                    "message_type": message_type,
                    "media_url": media_url,
                    "provider_response": result,
                },
                status="sent" if ok else "failed",
                provider=provider,
                sent_at=timezone.now(),
            )

            results.append(result)

        return Response(
            {
                "success": failed_count == 0,
                "summary": {
                    "requested": len(recipients),
                    "sent": success_count,
                    "failed": failed_count,
                    "message_type": message_type,
                },
                "results": results,
                "media_url": media_url or None,
            },
            status=status.HTTP_200_OK,
        )


class AdminWhatsAppMessageLogView(APIView):
    permission_classes = [permissions.IsAdminUser]

    def get(self, request):
        limit_raw = request.query_params.get("limit", "50")
        try:
            limit = min(max(int(limit_raw), 1), 200)
        except Exception:
            limit = 50

        qs = Notification.objects.filter(channel="whatsapp").order_by("-created_at")[:limit]
        results = []
        for item in qs:
            payload = item.payload or {}
            provider_response = payload.get("provider_response") if isinstance(payload, dict) else None

            results.append(
                {
                    "id": str(item.id),
                    "recipient": item.recipient,
                    "message": item.message,
                    "status": item.status,
                    "provider": item.provider,
                    "message_type": payload.get("message_type") if isinstance(payload, dict) else None,
                    "media_url": payload.get("media_url") if isinstance(payload, dict) else None,
                    "provider_message_id": (provider_response or {}).get("message_id") if isinstance(provider_response, dict) else None,
                    "created_at": item.created_at,
                    "sent_at": item.sent_at,
                }
            )

        return Response({"count": len(results), "results": results}, status=status.HTTP_200_OK)