import json
import os
from rest_framework.views import APIView ,status
from rest_framework.response import Response
from bson import ObjectId
from .authentication import JWTAuthentication
from .permissions import MethodRolePermission
from .models import Customer, Partner, PartnerSubUser, Admin, RefreshToken,Document
from rest_framework.permissions import AllowAny
from .serializers import (
    CustomerDetailsSerializer, CustomerDocumentListSerializer, CustomerDocumentSerializer, CustomerRegisterSerializer, PartnerDocumentSerializer,PartnerRegisterSerializer, PartnerSendOTPSerializer,
    PartnerSubUserRegisterSerializer, AdminRegisterSerializer, PartnerUpdateSerializer, PartnerValidationSerializer, PartnerVerifyOTPSerializer,
    SendOTPSerializer, VerifyOTPSerializer,
)

import datetime
from mongoengine import ValidationError
from .services import generate_otp, set_otp, verify_otp
import jwt
from django.conf import settings
# import datetime
import logging
# ========== REGISTRATION BASE VIEW ==========

class BaseRegisterView(APIView):
    model = None
    serializer_class = None
    role = None

    def post(self, request):
        serializer = self.serializer_class(data=request.data)
        try:
            if serializer.is_valid():
                data = serializer.validated_data        

                # ✅ Unique phone check
                if self.model.objects(phone_number=data["phone_number"]).first():
                    return Response({"error": "Phone already registered"}, status=status.HTTP_400_BAD_REQUEST)

                # ✅ PartnerSubUser logic
                if self.role == "partner_sub_user":
                    partner = Partner.objects(id=data["partner_id"]).first()
                    if not partner:
                        return Response({"error": "Partner not found"}, status=status.HTTP_404_NOT_FOUND)
                    data["partner"] = partner
                    del data["partner_id"]

                # ✅ Save the user
                user = self.model(**data)
                user.save()

                # ✅ Generate OTP
                otp = set_otp(user)

                # ✅ Return OTP inside message only
                return Response({
                    "status": True,
                    "message": f"Registration successful. OTP sent to {user.phone_number}.",
                    "isRegistered": True
                }, status=status.HTTP_201_CREATED)

        except ValidationError as e:
            return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)

        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)


class CustomerRegisterView(BaseRegisterView):
    """
    Customer self-registration with OTP.

    ✅ If phone already exists → re-send OTP, isRegistered=True
    ✅ If new phone → create user, send OTP, isRegistered=False
    """
    model = Customer
    serializer_class = CustomerRegisterSerializer
    role = "customer"
    permission_classes = [AllowAny]  # Public endpoint

    def post(self, request):
        serializer = self.serializer_class(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        data = serializer.validated_data
        phone = data["phone_number"]

        try:
            # ---------------- Check if customer exists ----------------
            existing_customer = self.model.objects(phone_number=phone).first()

            if existing_customer:
                # ✅ Generate new OTP for existing user (BaseUser handles it)
                set_otp(existing_customer)
                return Response({
                    "status": True,
                    "message": f"OTP re-sent successfully to {phone}",
                    "isRegistered": True
                }, status=status.HTTP_200_OK)

            # ---------------- Split full_name into first_name / last_name ----------------
            full_name = data.pop("full_name", "").strip()
            parts = full_name.split(" ", 1)
            data["first_name"] = parts[0] if len(parts) > 0 else ""
            data["last_name"] = parts[1] if len(parts) > 1 else ""

            # ---------------- Create new customer ----------------
            user = self.model(**data)
            user.save()

            # ---------------- Send OTP via BaseUser logic ----------------
            set_otp(user)

            return Response({
                "status": True,
                "message": f"Registration successful. OTP sent to {user.phone_number}",
                "isRegistered": False
            }, status=status.HTTP_201_CREATED)

        except ValidationError as e:
            return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)
        except Exception as e:
            return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)


class CustomerAddView(BaseRegisterView):
    """
    Admin-only customer registration.
    Does NOT send OTP, just registers the customer.
    """
    model = Customer
    serializer_class = CustomerRegisterSerializer
    role = "customer"

    # Correct
    authentication_classes = [JWTAuthentication]  # Authentication
    permission_classes = [MethodRolePermission]   # Permissions

    allowed_roles = {"POST": ["admin"]}  # Only admin can register customers

    def post(self, request):
        serializer = self.serializer_class(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        data = serializer.validated_data

        # Split full_name into first_name and last_name
        full_name = data.pop("full_name", "")
        parts = full_name.strip().split(" ", 1)
        data["first_name"] = parts[0] if len(parts) > 0 else ""
        data["last_name"] = parts[1] if len(parts) > 1 else ""

        # Unique phone check
        if self.model.objects(phone_number=data["phone_number"]).first():
            return Response({"error": "Phone already registered"}, status=status.HTTP_400_BAD_REQUEST)

        # Save the user
        user = self.model(**data)
        user.save()

        # Return success without OTP
        return Response({
            "status": True,
            "message": f"Customer '{user.first_name} {user.last_name}' added successfully.",
            "isRegistered": True
        }, status=status.HTTP_201_CREATED)

class PartnerAddView(BaseRegisterView):
    """
    Admin-only partner registration.
    Does NOT send OTP, just registers the partner.
    """
    model = Partner
    serializer_class = PartnerRegisterSerializer
    role = "partner"

    authentication_classes = [JWTAuthentication]
    permission_classes = [MethodRolePermission]
    allowed_roles = {"POST": ["admin"]}

    def post(self, request):
        serializer = self.serializer_class(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        data = serializer.validated_data

        # ---------------- Check if phone already exists ----------------
        if self.model.objects(phone_number=data["phone_number"]).first():
            return Response({"error": "Phone already registered"}, status=status.HTTP_400_BAD_REQUEST)

        # ---------------- Save the partner ----------------
        partner = self.model(**data)
        partner.save()

        return Response({
            "status": True,
            "message": f"Partner '{partner.phone_number}' added successfully.",
            "isRegistered": True
        }, status=status.HTTP_201_CREATED)




class PartnerRegisterView(BaseRegisterView):
    model = Partner
    serializer_class = PartnerRegisterSerializer
    role = "partner"
    permission_classes = []

class PartnerSubUserRegisterView(BaseRegisterView):
    model = PartnerSubUser
    serializer_class = PartnerSubUserRegisterSerializer
    role = "partner_sub_user"

class AdminRegisterView(BaseRegisterView):
    model = Admin
    serializer_class = AdminRegisterSerializer
    role = "admin"
    permission_classes = []

# ========== OTP BASE VIEWS ==========

class BaseSendOTPView(APIView):
    model = None
    role = None

    def post(self, request):
        serializer = SendOTPSerializer(data=request.data)
        if serializer.is_valid():
            phone = serializer.validated_data["phone_number"]
            user = self.model.objects(phone_number=phone).first()
            if not user:
                  return Response({
                    "message": f"{self.role} not found",
                    "isRegistered": False
                }, status=200)

            otp_received = set_otp(user)
            return Response({"message": f"OTP sent to {phone} is {otp_received}", "isRegistered": True}, status=200)
        return Response(serializer.errors, status=400)

# views.py
class BaseVerifyOTPView(APIView):
    model = None
    role = None

    def post(self, request):
        serializer = VerifyOTPSerializer(data=request.data)
        if serializer.is_valid():
            phone = serializer.validated_data["phone_number"]
            otp = serializer.validated_data["otp"]

            user = self.model.objects(phone_number=phone).first()
            if not user:
                return Response({"error": f"{self.role} not found"}, status=404)

            if not verify_otp(user, otp):
                return Response({"error": "Invalid or expired OTP"}, status=400)

            # ✅ ACCESS TOKEN
            access_payload = {
                "id": str(user.id),
                "role": self.role,
                "exp": datetime.datetime.utcnow() + datetime.timedelta(minutes=260)
            }
            access_token = jwt.encode(access_payload, settings.SECRET_KEY, algorithm="HS256")

            # ✅ REFRESH TOKEN
            refresh_payload = {
                "id": str(user.id),
                "role": self.role,
                "type": "refresh",
                "exp": datetime.datetime.utcnow() + datetime.timedelta(days=7)
            }
            refresh_token = jwt.encode(refresh_payload, settings.SECRET_KEY, algorithm="HS256")

            # Store refresh token in DB
            from .models import RefreshToken
            RefreshToken(
                user_id=str(user.id),
                role=self.role,
                token=refresh_token,
                expiry=datetime.datetime.utcnow() + datetime.timedelta(days=90)
            ).save()

            return Response({
                "access_token": access_token,
                "refresh_token": refresh_token
            })
        return Response(serializer.errors, status=400)


# Role-specific OTP views
class CustomerSendOTPView(BaseSendOTPView):
    model = Customer
    role = "customer"
    permission_classes = []

class CustomerVerifyOTPView(BaseVerifyOTPView):
    model = Customer
    role = "customer"
    permission_classes = []

class PartnerSendOTPView(BaseSendOTPView):
    model = Partner
    role = "partner"
    permission_classes = []

class PartnerVerifyOTPView(BaseVerifyOTPView):
    model = Partner
    role = "partner"
    permission_classes = []

class PartnerSubUserSendOTPView(BaseSendOTPView):
    model = PartnerSubUser
    role = "partner_sub_user"

class PartnerSubUserVerifyOTPView(BaseVerifyOTPView):
    model = PartnerSubUser
    role = "partner_sub_user"

class AdminSendOTPView(BaseSendOTPView):
    model = Admin
    role = "admin"
    permission_classes = []

class AdminVerifyOTPView(BaseVerifyOTPView):
    model = Admin
    role = "admin"
    permission_classes = []

# views.py

class TokenRefreshView(APIView):
    permission_classes = [AllowAny]
    def post(self, request):
        refresh_token = request.data.get("refresh_token")
        if not refresh_token:
            return Response({"error": "Refresh token required"}, status=400)

        try:
            payload = jwt.decode(refresh_token, settings.SECRET_KEY, algorithms=["HS256"])
            if payload.get("type") != "refresh":
                return Response({"error": "Invalid token type"}, status=400)
        except jwt.ExpiredSignatureError:
            return Response({"error": "Refresh token expired"}, status=401)
        except jwt.InvalidTokenError:
            return Response({"error": "Invalid token"}, status=401)

        from .models import RefreshToken
        stored = RefreshToken.objects(token=refresh_token).first()
        if not stored:
            return Response({"error": "Refresh token not found or revoked"}, status=401)

        # Issue new access + refresh tokens
        access_payload = {
            "id": payload["id"],
            "role": payload["role"],
            "exp": datetime.datetime.utcnow() + datetime.timedelta(minutes=30)
        }
        access_token = jwt.encode(access_payload, settings.SECRET_KEY, algorithm="HS256")

        new_refresh_payload = {
            "id": payload["id"],
            "role": payload["role"],
            "type": "refresh",
            "exp": datetime.datetime.utcnow() + datetime.timedelta(days=90)
        }
        new_refresh_token = jwt.encode(new_refresh_payload, settings.SECRET_KEY, algorithm="HS256")

        # Rolling refresh: replace old one
        stored.token = new_refresh_token
        stored.expiry = datetime.datetime.utcnow() + datetime.timedelta(days=90)
        stored.last_used_at = datetime.datetime.utcnow()
        stored.save()

        return Response({
            "access_token": access_token,
            "refresh_token": new_refresh_token
        })
    
class PartnerValidationUpdateView(APIView):
    """
    Update Aadhaar, PAN, and Business details for an existing partner.
    Works only after OTP verification.
    Only fields provided in the request will be updated.
    Resets verification flags if document numbers change.
    Marks partner as validated only if both Aadhaar and PAN are verified.
    Lookup is done by mobile number instead of email.
    Returns clear messages for missing or pending verifications.
    """
    authentication_classes = [JWTAuthentication]   # Require JWT token
    permission_classes = [MethodRolePermission]    # Enforce role-based access
    allowed_roles = {
        "PUT": ["admin", "partner"]
    }
    def put(self, request):
        serializer = PartnerValidationSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        data = serializer.validated_data
        phone_number = data.get("phone_number")

        # ✅ Find partner
        partner = Partner.objects(phone_number=phone_number).first()
        if not partner:
            return Response({
                "message": "Partner not found",
                "is_validated": False,
                "aadhaar_pending": True,
                "pan_pending": True
            }, status=status.HTTP_404_NOT_FOUND)

        # Lists to track missing or pending verifications
        missing_docs = []
        pending_docs = []

        # -------------------- Aadhaar --------------------
        if "aadhar_number" in data:
            new_aadhar = data["aadhar_number"]
            if partner.aadhar_number and partner.aadhar_number != new_aadhar:
                partner.aadhar_verified = False  # reset verification if changed
            partner.aadhar_number = new_aadhar

            if "aadhar_name" in data:
                partner.aadhar_name = data["aadhar_name"]
            if "aadhar_phone" in data:
                partner.aadhar_phone = data["aadhar_phone"]

        # Aadhaar pending or missing check
        if partner.aadhar_number:
            if not partner.aadhar_verified:
                pending_docs.append("Aadhaar")
            aadhaar_pending = not partner.aadhar_verified
        else:
            missing_docs.append("Aadhaar")
            aadhaar_pending = True

        # -------------------- PAN --------------------
        if "pan_number" in data:
            new_pan = data["pan_number"]
            if partner.pan_number and partner.pan_number != new_pan:
                partner.pan_verified = False  # reset verification if changed
            partner.pan_number = new_pan

            if "pan_name" in data:
                partner.pan_name = data["pan_name"]
            if "pan_phone" in data:
                partner.pan_phone = data["pan_phone"]

        # PAN pending or missing check
        if partner.pan_number:
            if not partner.pan_verified:
                pending_docs.append("PAN")
            pan_pending = not partner.pan_verified
        else:
            missing_docs.append("PAN")
            pan_pending = True

        # -------------------- Business fields --------------------
        if "business_name" in data:
            partner.business_name = data["business_name"]
        if "gstin" in data:
            partner.gstin = data["gstin"]

        # -------------------- Save partner --------------------
        partner.is_validated = partner.aadhar_verified and partner.pan_verified
        partner.save()

        # -------------------- Prepare response message --------------------
        messages = []
        if missing_docs:
            messages.append(f"Missing documents: {', '.join(missing_docs)}")
        if pending_docs:
            messages.append(f"Verification pending for: {', '.join(pending_docs)}")

        if partner.is_validated:
            message = "Partner validation completed successfully"
        elif messages:
            message = "; ".join(messages)
        else:
            message = "Partner details updated successfully"

        # -------------------- Response --------------------
        return Response({
            "message": message,
            "is_validated": partner.is_validated,
            "aadhar_verified": partner.aadhar_verified,
            "pan_verified": partner.pan_verified,
            "aadhaar_pending": aadhaar_pending,
            "pan_pending": pan_pending
        }, status=status.HTTP_200_OK)

class PartnerListView(APIView):
    """
    List all partners (Admin only) with selected fields.
    Status is represented by validation status.
    """
    authentication_classes = [JWTAuthentication]
    permission_classes = [MethodRolePermission]
    allowed_roles = {
        "GET": ["admin"]
    }

    def get(self, request):
        partners = Partner.objects()
        partner_list = []
        for p in partners:
            full_name = f"{getattr(p, 'first_name', '')} {getattr(p, 'last_name', '')}".strip()
            partner_list.append({
                "id": str(p.id),
                "name": full_name,  # Use partner_name field
                "company_name": getattr(p, "business_name", ""),
                "phone": p.phone_number,
                "status": "Verified" if p.is_validated else "Not Verified"
            })
        return Response({"partners": partner_list}, status=status.HTTP_200_OK)

class CustomerListView(APIView):
    """
    List all customers (Admin only) with selected fields.
    """
    authentication_classes = [JWTAuthentication]
    permission_classes = [MethodRolePermission]
    allowed_roles = {
        "GET": ["admin"]
    }

    def get(self, request):
        customers = Customer.objects()
        customer_list = []

        for c in customers:
            full_name = f"{getattr(c, 'first_name', '')} {getattr(c, 'last_name', '')}".strip()
            customer_list.append({
                "id": str(c.id),
                "name": full_name,
                "phone_number": c.phone_number,
                "joining_date": c.joining_date.isoformat() if c.joining_date else None,
                "kyc_status": c.kyc_status
            })

        return Response({"customers": customer_list}, status=status.HTTP_200_OK)
    
class LogoutView(APIView):
    """
    Securely log out a user by deleting their refresh token.
    This ensures the user must log in again to get new tokens.
    """
    permission_classes = [AllowAny]

    def post(self, request):
        refresh_token = request.data.get("refresh_token")

        if not refresh_token:
            return Response({"error": "Refresh token required"}, status=status.HTTP_400_BAD_REQUEST)

        # ✅ Decode the refresh token (optional, just for verification)
        try:
            payload = jwt.decode(refresh_token, settings.SECRET_KEY, algorithms=["HS256"])
            if payload.get("type") != "refresh":
                return Response({"error": "Invalid token type"}, status=status.HTTP_400_BAD_REQUEST)
        except jwt.ExpiredSignatureError:
            # Even if expired, we can still delete it
            pass
        except jwt.InvalidTokenError:
            return Response({"error": "Invalid token"}, status=status.HTTP_401_UNAUTHORIZED)

        # ✅ Delete refresh token from DB (revoke access)
        stored = RefreshToken.objects(token=refresh_token).first()
        if stored:
            stored.delete()
            return Response({"message": "Logged out successfully"}, status=status.HTTP_200_OK)
        else:
            return Response({"error": "Refresh token not found or already revoked"}, status=status.HTTP_404_NOT_FOUND)


class PartnerSendDocOTPView(APIView):

    authentication_classes = [JWTAuthentication]   # Require JWT token
    permission_classes = [MethodRolePermission]    # Enforce role-based access
    allowed_roles = {
        "POST": ["admin", "partner"]
    }

    def post(self, request):
        serializer = PartnerSendOTPSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        data = serializer.validated_data
        phone = data.get('phone_number')         # Registered phone
        optional_mobile = data.get('optional_mobile') # Aadhaar OTP phone
        document_number = data['document_number']
        doc_type = data['type']

        # First check partner exists
        partner = Partner.objects(phone_number=phone).first()
        if not partner:
            return Response({
                "message": "Registered phone number not found",
                "is_registered": False
            }, status=status.HTTP_404_NOT_FOUND)

        # Choose phone to send OTP based on document type
        otp_phone = optional_mobile if doc_type in ["aadhar", "pan"] and optional_mobile else phone

        # Generate OTP
        otp = set_otp(partner)

        # Response
        return Response({
            "message": f"OTP sent to {otp_phone}",
            "otp": otp,  # Remove in production
            "phone_used_for_otp": otp_phone,
            "type": doc_type,
            "is_registered": True
        }, status=status.HTTP_200_OK)


class PartnerVerifyDocOTPView(APIView):
    """
    Verify OTP for Aadhaar or PAN for a partner.
    Supports optional different mobile number for Aadhaar/PAN OTP.
    Updates verification flags and saves the document number.
    Returns only a message in the response.
    """
    authentication_classes = [JWTAuthentication]
    permission_classes = [MethodRolePermission]
    allowed_roles = {
        "POST": ["admin", "partner"]
    }
    def post(self, request):
        serializer = PartnerVerifyOTPSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        data = serializer.validated_data
        phone = data['phone_number']                    
        optional_mobile = data.get('optional_mobile')  
        otp = data['otp']
        doc_type = data['type']
        document_number = data['document_number']

        # Get partner by registered phone
        partner = Partner.objects(phone_number=phone).first()
        if not partner:
            return Response({
                "message": "Registered phone number not found"
            }, status=status.HTTP_404_NOT_FOUND)

        # Verify OTP
        if not verify_otp(partner, otp):
            return Response({
                "message": "Invalid or expired OTP"
            }, status=status.HTTP_400_BAD_REQUEST)

        # Determine which phone was used for OTP
        otp_phone = optional_mobile if optional_mobile else phone

        # Save verified document info
        if doc_type == "aadhar":
            partner.aadhar_number = document_number
            partner.aadhar_phone = otp_phone
            partner.aadhar_verified = True
            message = "Aadhaar verification successful"

        elif doc_type == "pan":
            partner.pan_number = document_number
            partner.pan_phone = otp_phone
            partner.pan_verified = True
            message = "PAN verification successful"

        partner.save()

        # ✅ Only message in response
        return Response({"message": message}, status=status.HTTP_200_OK)
    
class PartnerDetailView(APIView):
    authentication_classes = [JWTAuthentication]
    permission_classes = [MethodRolePermission]
    allowed_roles = {
        "GET": ["admin"],
        "PUT": ["admin"]
    }

    def get(self, request, partner_id):
        if not ObjectId.is_valid(partner_id):
            return Response({"error": "Invalid partner ID"}, status=status.HTTP_400_BAD_REQUEST)

        partner = Partner.objects(id=partner_id).first()
        if not partner:
            return Response({"error": "Partner not found"}, status=status.HTTP_404_NOT_FOUND)

        return Response({
            "partner": {
                "first_name": partner.first_name,
                "last_name": partner.last_name,
                "phone_number": partner.phone_number,
                "business_type": partner.business_type,
                "business_name": partner.business_name,
                "status": "Verified" if partner.is_validated else "Not Verified"
            }
        }, status=status.HTTP_200_OK)

    def put(self, request, partner_id):
        if not ObjectId.is_valid(partner_id):
            return Response({"error": "Invalid partner ID"}, status=status.HTTP_400_BAD_REQUEST)

        partner = Partner.objects(id=partner_id).first()
        if not partner:
            return Response({"error": "Partner not found"}, status=status.HTTP_404_NOT_FOUND)

        serializer = PartnerUpdateSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        serializer.update(partner, serializer.validated_data)

        return Response({
            "message": "Partner updated successfully",
            "partner": {
                "first_name": partner.first_name,
                "last_name": partner.last_name,
                "phone_number": partner.phone_number,
                "business_type": partner.business_type,
                "business_name": partner.business_name,
                "status": "Verified" if partner.is_validated else "Not Verified"
            }
        }, status=status.HTTP_200_OK)

    
class CustomerDetailView(APIView):
    """
    Retrieve or update a Customer.
    Admin only.
    Supports image upload.
    """
    authentication_classes = [JWTAuthentication]
    permission_classes = [MethodRolePermission]
    allowed_roles = {
        "GET": ["admin"],
        "PUT": ["admin"]
    }

    def get_object(self, customer_id):
        if not ObjectId.is_valid(customer_id):
            return None
        return Customer.objects(id=customer_id).first()

    # ---------------- GET ----------------
    def get(self, request, customer_id):
        customer = self.get_object(customer_id)
        if not customer:
            return Response({"error": "Customer not found"}, status=status.HTTP_404_NOT_FOUND)

        serializer = CustomerDetailsSerializer(customer)
        return Response(serializer.data, status=status.HTTP_200_OK)

    # ---------------- PUT ----------------
    def put(self, request, customer_id):
        customer = self.get_object(customer_id)
        if not customer:
            return Response({"error": "Customer not found"}, status=status.HTTP_404_NOT_FOUND)

        # Use a serializer for input validation
        serializer = CustomerRegisterSerializer(data=request.data, partial=True)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        # Update only provided fields
        for attr, value in serializer.validated_data.items():
            if attr == "full_name":
                # Split full_name into first_name and last_name
                parts = value.strip().split(" ", 1)
                customer.first_name = parts[0]
                customer.last_name = parts[1] if len(parts) > 1 else ""
            else:
                setattr(customer, attr, value)

        # Handle profile image if provided
        image_file = request.FILES.get('image')
        if image_file:
            customer.delete_image_file()  # delete old image if exists
            customer.save_image(image_file)

        # Save updates
        customer.save()

        # Return updated customer details
        details_serializer = CustomerDetailsSerializer(customer)
        return Response(details_serializer.data, status=status.HTTP_200_OK)

class CustomerDocumentUploadView(APIView):
    authentication_classes = [JWTAuthentication]
    permission_classes = [MethodRolePermission]
    allowed_roles = {"POST": ["admin", "customer"]}

    def post(self, request):
        user_id = request.data.get("user_id")
        user_type = "customer"

        # ---------------- Get Customer ----------------
        customer = Customer.objects(id=user_id).first()
        if not customer:
            return Response({"error": "Customer not found."}, status=404)

        # ---------------- Save selfie (mandatory) ----------------
        selfie_file = request.FILES.get("selfie")
        if not selfie_file:
            return Response(
                {"selfie": "Selfie is required for KYC."},
                status=status.HTTP_400_BAD_REQUEST
            )
        customer.save_selfie(selfie_file)

        # ---------------- Update KYC status ----------------
        kyc_status = request.data.get("kyc_status")
        if kyc_status in ("pending", "verified", "rejected"):
            customer.kyc_status = kyc_status
        customer.save()

        saved_docs = []
        any_updates = False

        # ---------------- Iterate over document types ----------------
        for doc_type in ["aadhar", "dl"]:
            fields_key = f"{doc_type}[fields]"
            front_key = f"{doc_type}[front_page]"
            back_key = f"{doc_type}[back_page]"

            fields_data = None
            if fields_key in request.data:
                try:
                    fields_raw = request.data.getlist(fields_key)[0]
                    fields_data = json.loads(fields_raw)
                    if not isinstance(fields_data, dict):
                        raise ValueError
                except Exception:
                    return Response(
                        {fields_key: "Invalid JSON format for fields."},
                        status=status.HTTP_400_BAD_REQUEST
                    )

            front_file = request.FILES.get(front_key)
            back_file = request.FILES.get(back_key)

            if not any([fields_data, front_file, back_file]):
                continue  # skip if nothing to update

            # ---------------- Find existing document ----------------
            existing_doc = Document.objects(
                user_id=user_id,
                user_type=user_type,
                document_type=doc_type
            ).first()

            if existing_doc:
                updated = False

                # Update fields if provided
                if fields_data and fields_data != existing_doc.fields:
                    existing_doc.fields = fields_data
                    updated = True

                # Update files using model methods
                if front_file:
                    existing_doc.save_front_page(front_file)
                    updated = True
                if back_file:
                    existing_doc.save_back_page(back_file)
                    updated = True

                if updated:
                    existing_doc.save()
                    any_updates = True

                saved_docs.append({
                    "id": str(existing_doc.id),
                    "document_type": existing_doc.document_type,
                    "fields": existing_doc.fields,
                    "front_page": os.path.join(settings.MEDIA_URL, existing_doc.front_page)
                    if existing_doc.front_page else None,
                    "back_page": os.path.join(settings.MEDIA_URL, existing_doc.back_page)
                    if existing_doc.back_page else None,
                    "uploaded_at": existing_doc.uploaded_at.isoformat(),
                })

            else:
                # ---------------- Create New Document ----------------
                if not front_file:
                    return Response(
                        {f"{doc_type}": f"{doc_type.capitalize()} front file is required for new upload."},
                        status=status.HTTP_400_BAD_REQUEST
                    )

                # Create new document instance
                new_doc = Document(
                    user_id=user_id,
                    user_type=user_type,
                    document_type=doc_type,
                    fields=fields_data or {}
                )

                new_doc.save_front_page(front_file)
                if back_file:
                    new_doc.save_back_page(back_file)  # optional
                new_doc.save()
                any_updates = True

                saved_docs.append({
                    "id": str(new_doc.id),
                    "document_type": new_doc.document_type,
                    "fields": new_doc.fields,
                    "front_page": os.path.join(settings.MEDIA_URL, new_doc.front_page),
                    "back_page": os.path.join(settings.MEDIA_URL, new_doc.back_page)
                    if new_doc.back_page else None,
                    "uploaded_at": new_doc.uploaded_at.isoformat(),
                })

        # ---------------- Final Response ----------------
        if not any_updates:
            return Response({"message": "No updates found."}, status=status.HTTP_200_OK)

        response = {
            "documents": saved_docs,
            "selfie_url": os.path.join(settings.MEDIA_URL, customer.selfie_url),
            "kyc_status": customer.kyc_status
        }

        return Response(response, status=status.HTTP_201_CREATED)



class PartnerDocumentUploadView(APIView):
    authentication_classes = [JWTAuthentication]
    permission_classes = [MethodRolePermission]
    allowed_roles = {"POST": ["admin", "partner"]}

    def post(self, request):
        user_id = request.data.get("user_id")
        user_type = "partner"

        # ---------------- Get Partner ----------------
        partner = Partner.objects(id=user_id).first()
        if not partner:
            return Response({"error": "Partner not found"}, status=404)

        # ---------------- Save selfie (mandatory) ----------------
        selfie_file = request.FILES.get("selfie")
        if not selfie_file:
            return Response(
                {"selfie": "Selfie is required for KYC."},
                status=status.HTTP_400_BAD_REQUEST
            )
        partner.save_selfie(selfie_file)

        # ---------------- Update KYC status ----------------
        kyc_status = request.data.get("kyc_status")
        if kyc_status in ("pending", "verified", "rejected"):
            partner.kyc_status = kyc_status
        partner.save()

        saved_docs = []
        any_updates = False

        # ---------------- Iterate over partner document types ----------------
        for doc_type in ["aadhar", "pan", "gst"]:
            fields_key = f"{doc_type}[fields]"
            front_key = f"{doc_type}[front_page]"
            back_key = f"{doc_type}[back_page]"

            fields_data = None
            if fields_key in request.data:
                try:
                    fields_raw = request.data.getlist(fields_key)[0]
                    fields_data = json.loads(fields_raw)
                    if not isinstance(fields_data, dict):
                        raise ValueError
                except Exception:
                    return Response(
                        {fields_key: "Invalid JSON format for fields."},
                        status=status.HTTP_400_BAD_REQUEST
                    )

            front_file = request.FILES.get(front_key)
            back_file = request.FILES.get(back_key)

            if not any([fields_data, front_file, back_file]):
                continue  # skip if nothing to update

            # ---------------- Find existing document ----------------
            existing_doc = Document.objects(
                user_id=user_id,
                user_type=user_type,
                document_type=doc_type
            ).first()

            if existing_doc:
                updated = False

                # Update fields if provided
                if fields_data and fields_data != existing_doc.fields:
                    existing_doc.fields = fields_data
                    updated = True

                # Update files using model methods
                if front_file:
                    existing_doc.save_front_page(front_file)
                    updated = True
                if back_file:
                    existing_doc.save_back_page(back_file)
                    updated = True

                if updated:
                    existing_doc.uploaded_at = datetime.datetime.utcnow()
                    existing_doc.save()
                    any_updates = True

                saved_docs.append({
                    "id": str(existing_doc.id),
                    "document_type": existing_doc.document_type,
                    "fields": existing_doc.fields,
                    "front_page": os.path.join(settings.MEDIA_URL, existing_doc.front_page)
                    if existing_doc.front_page else None,
                    "back_page": os.path.join(settings.MEDIA_URL, existing_doc.back_page)
                    if existing_doc.back_page else None,
                    "uploaded_at": existing_doc.uploaded_at.isoformat(),
                })

            else:
                # ---------------- Create New Document ----------------
                if not front_file:
                    return Response(
                        {f"{doc_type}": f"{doc_type.capitalize()} front file is required for new upload."},
                        status=status.HTTP_400_BAD_REQUEST
                    )

                # Create new document instance
                new_doc = Document(
                    user_id=user_id,
                    user_type=user_type,
                    document_type=doc_type,
                    fields=fields_data or {}
                )

                new_doc.save_front_page(front_file)
                if back_file:
                    new_doc.save_back_page(back_file)  # optional
                new_doc.save()
                any_updates = True

                saved_docs.append({
                    "id": str(new_doc.id),
                    "document_type": new_doc.document_type,
                    "fields": new_doc.fields,
                    "front_page": os.path.join(settings.MEDIA_URL, new_doc.front_page),
                    "back_page": os.path.join(settings.MEDIA_URL, new_doc.back_page)
                    if new_doc.back_page else None,
                    "uploaded_at": new_doc.uploaded_at.isoformat(),
                })

        # ---------------- Final Response ----------------
        if not any_updates:
            return Response({"message": "No updates found."}, status=status.HTTP_200_OK)

        response = {
            "documents": saved_docs,
            "selfie_url": os.path.join(settings.MEDIA_URL, partner.selfie_url),
            "kyc_status": partner.kyc_status
        }

        return Response(response, status=status.HTTP_201_CREATED)
