import mongoengine as me
import os
from django.conf import settings
from datetime import datetime

BUSINESS_TYPE_CHOICES = ('individual', 'company')
COUNTRY_ORIGIN_CHOICES = ('Indian', 'Non-Indian')

def validate_business_type(value):
    if value not in BUSINESS_TYPE_CHOICES:
        raise me.ValidationError(f"{value} is not a valid Business Type")

def validate_country_origin(value):
    print("value- country",value)
    if value not in COUNTRY_ORIGIN_CHOICES:
        raise me.ValidationError(f"{value} is not a valid Country of Origin")

class BaseUser(me.Document):
    phone_number = me.StringField(required=True, unique=True)
    first_name = me.StringField(required=True)
    last_name = me.StringField(required=True)
    otp = me.StringField()
    otp_expiry = me.DateTimeField(required=False, null=True)
    is_validated = me.BooleanField(default=False)

    meta = {"abstract": True}

    def get_full_name(self):
        """Return user's display name depending on model type."""
        # For Customer or Admin, use first_name + last_name
        if hasattr(self, "first_name") and hasattr(self, "last_name"):
            return f"{self.first_name} {self.last_name}".strip()

        # For Partner, fall back to business name if available
        if hasattr(self, "business_name") and self.business_name:
            return self.business_name

        # Fallback
        return "User"


class Customer(BaseUser):
    email = me.EmailField(required=True, unique=True)
    dl_origin = me.StringField(
        required=True, 
        choices=COUNTRY_ORIGIN_CHOICES, 
        default="Indian", 
        validation=validate_country_origin
    )
    nationality = me.StringField(required=True)
    date_of_birth = me.DateField(required=False, null=True)
    kyc_status = me.StringField(
        choices=('pending', 'verified', 'rejected'), 
        default='pending'
    )

    # ---------------- New Fields ----------------
    is_active = me.BooleanField(default=True)
    image_url = me.StringField()
    selfie_url = me.StringField()
    joining_date = me.DateTimeField(default=datetime.utcnow)
    # ---------------- File Handling Methods ----------------
    def _get_filename(self, file_obj):
        """
        Generate filename: first 4 of first_name + last 4 of ID + first 4 of last_name + extension
        """
        ext = os.path.splitext(file_obj.name)[1]  # keep original extension
        first_part = (self.first_name[:4] if self.first_name else "user")
        last_part = (self.last_name[:4] if self.last_name else "name")
        user_id_str = str(self.id)
        id_part = user_id_str[-4:] if len(user_id_str) >= 4 else user_id_str
        return f"{first_part}_{id_part}_{last_part}{ext}"

    def _save_file(self, file_obj, folder_name):
        """Save file under MEDIA_ROOT/folder_name/ and return relative path"""
        folder = os.path.join(settings.MEDIA_ROOT, folder_name)
        os.makedirs(folder, exist_ok=True)
        filename = self._get_filename(file_obj)
        filepath = os.path.join(folder, filename)

        with open(filepath, "wb+") as dest:
            for chunk in file_obj.chunks():
                dest.write(chunk)

        return f"{folder_name}/{filename}"

    def _delete_file(self, file_path):
        """Delete file if exists"""
        if file_path:
            full_path = os.path.join(settings.MEDIA_ROOT, file_path)
            if os.path.exists(full_path):
                os.remove(full_path)

    # ---------------- Profile Image ----------------
    def save_image(self, file_obj):
        """Save new profile image and update image_url"""
        # Delete old image if exists
        if self.image_url:
            self.delete_image_file()
        self.image_url = self._save_file(file_obj, "customer")

    def delete_image_file(self):
        """Delete current profile image"""
        self._delete_file(self.image_url)
        self.image_url = None
    
    def save_selfie(self, file_obj):
        """Save user selfie for document verification"""
        # Delete old selfie if exists
        if self.selfie_url:
            self.delete_selfie_file()
        self.selfie_url = self._save_file(file_obj, "customer/selfies")

    def delete_selfie_file(self):
        """Delete stored selfie"""
        self._delete_file(self.selfie_url)
        self.selfie_url = None

class Partner(BaseUser):
    business_name = me.StringField(required=True)
    business_type = me.StringField(
        choices=BUSINESS_TYPE_CHOICES, 
        default="individual", 
        required=True,
        validation=validate_business_type
    )
    aadhar_name = me.StringField()
    aadhar_number = me.StringField()
    aadhar_phone = me.StringField()
    aadhar_verified = me.BooleanField(default=False)
    pan_name = me.StringField()
    pan_number = me.StringField()
    pan_phone = me.StringField()
    pan_verified = me.BooleanField(default=False)
    gstin = me.StringField()
    
    # ---------------- Selfie ----------------
    selfie_url = me.StringField()

    # ---------------- File Handling Methods ----------------
    def _get_filename(self, file_obj):
        ext = os.path.splitext(file_obj.name)[1]  # keep original extension
        first_part = (getattr(self, "business_name", "")[:4] or "user")
        user_id_str = str(self.id)
        id_part = user_id_str[-4:] if len(user_id_str) >= 4 else user_id_str
        return f"{first_part}_{id_part}{ext}"

    def _save_file(self, file_obj, folder_name):
        folder = os.path.join(settings.MEDIA_ROOT, folder_name)
        os.makedirs(folder, exist_ok=True)
        filename = self._get_filename(file_obj)
        filepath = os.path.join(folder, filename)

        with open(filepath, "wb+") as dest:
            for chunk in file_obj.chunks():
                dest.write(chunk)

        return f"{folder_name}/{filename}"

    def _delete_file(self, file_path):
        if file_path:
            full_path = os.path.join(settings.MEDIA_ROOT, file_path)
            if os.path.exists(full_path):
                os.remove(full_path)

    # ---------------- Selfie Methods ----------------
    def save_selfie(self, file_obj):
        """Save partner selfie for verification"""
        if self.selfie_url:
            self.delete_selfie_file()
        self.selfie_url = self._save_file(file_obj, "partner/selfies")

    def delete_selfie_file(self):
        """Delete stored selfie"""
        self._delete_file(self.selfie_url)
        self.selfie_url = None


class PartnerSubUser(BaseUser):
    partner = me.ReferenceField(Partner, reverse_delete_rule=me.CASCADE)
    role = me.StringField()

class Admin(BaseUser):
    role = me.StringField(default="admin")


class RefreshToken(me.Document):
    user_id = me.StringField(required=True)
    role = me.StringField(required=True)
    token = me.StringField(required=True)
    expiry = me.DateTimeField(required=True)
    created_at = me.DateTimeField(default=datetime.utcnow)
    last_used_at = me.DateTimeField(default=datetime.utcnow)
    
    meta = {"collection": "refresh_tokens"}

class Document(me.Document):
    # user_id + user_type approach recommended
    user_id = me.StringField(required=True)
    user_type = me.StringField(required=True, choices=('customer', 'partner'))

    document_type = me.StringField(required=True, choices=("aadhar", "pan", "dl", "gst"))
    front_page = me.StringField(required=True)  # stored file path
    back_page = me.StringField()
    fields = me.DictField()
    uploaded_at = me.DateTimeField(default=datetime.utcnow)

    meta = {
        "collection": "documents",
        "indexes": ["user_id", "document_type", "user_type"]
    }

    # ---------------- File Utils ----------------
    def _get_filename(self, file_obj, prefix="doc"):
        ext = os.path.splitext(file_obj.name)[1]  # keep original extension
        return f"{prefix}_{self.user_id}_{file_obj.name}"

    def _save_file(self, file_obj, folder_name, prefix="doc"):
        folder = os.path.join(settings.MEDIA_ROOT, folder_name)
        os.makedirs(folder, exist_ok=True)
        filename = self._get_filename(file_obj, prefix)
        filepath = os.path.join(folder, filename)

        with open(filepath, "wb+") as dest:
            for chunk in file_obj.chunks():
                dest.write(chunk)

        return f"{folder_name}/{filename}"

    def save_front_page(self, file_obj):
        # Delete old file if exists
        if self.front_page:
            self.delete_file(self.front_page)
        self.front_page = self._save_file(file_obj, "docs/front", prefix="front")

    def save_back_page(self, file_obj):
        # Delete old file if exists
        if self.back_page:
            self.delete_file(self.back_page)
        self.back_page = self._save_file(file_obj, "docs/back", prefix="back")

    def delete_file(self, file_path):
        if file_path:
            full_path = os.path.join(settings.MEDIA_ROOT, file_path)
            if os.path.exists(full_path):
                os.remove(full_path)